Object Storage Service:OSS tables

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="create table bucket sample")
parser.add_argument('--region', help='The region in which the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS Tables.')
parser.add_argument('--name', help='The name of the table bucket.', required=True)
parser.add_argument('--sse-algorithm', help='The server-side encryption algorithm.')
parser.add_argument('--kms-key-arn', help='The KMS key ARN for encryption.')

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    encryption_configuration = None
    if args.sse_algorithm is not None or args.kms_key_arn is not None:
        encryption_configuration = oss_tables.models.EncryptionConfiguration(
            sse_algorithm=args.sse_algorithm,
            kms_key_arn=args.kms_key_arn,
        )

    result = client.create_table_bucket(oss_tables.models.CreateTableBucketRequest(
        name=args.name,
        encryption_configuration=encryption_configuration,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
          f' arn: {result.arn}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region string
	name   string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
	flag.StringVar(&name, "name", "", "The name of the bucket.")
}

func main() {
	flag.Parse()
	if len(name) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	result, err := client.CreateTableBucket(context.TODO(), &tables.CreateTableBucketRequest{
		Name: oss.Ptr(name),
	})

	if err != nil {
		log.Fatalf("failed to create table bucket %v", err)
	}

	log.Printf("create table bucket result:%#v\n", result)
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class CreateTableBucketSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String name = "mytablebucket";
        String sseAlgorithm = "AES256";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            CreateTableBucketRequest.Builder requestBuilder = CreateTableBucketRequest.newBuilder()
                    .name(name);

            EncryptionConfiguration encryptionConfig = EncryptionConfiguration.newBuilder()
                    .sseAlgorithm(sseAlgorithm)
                    .build();
            requestBuilder.encryptionConfiguration(encryptionConfig);

            CreateTableBucketResult result = client.createTableBucket(requestBuilder.build());

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Created table bucket with ARN: %s%n", result.arn());
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="get table bucket sample")
parser.add_argument('--region', help='The region in which the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.get_table_bucket(oss_tables.models.GetTableBucketRequest(
        table_bucket_arn=args.table_bucket_arn,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
          f' arn: {result.arn},'
          f' name: {result.name},'
          f' owner account id: {result.owner_account_id},'
          f' created at: {result.created_at},'
          f' table bucket id: {result.table_bucket_id},'
          f' type: {result.type}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The arn of the table bucket.")
}

func main() {
	flag.Parse()
	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	result, err := client.GetTableBucket(context.TODO(), &tables.GetTableBucketRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
	})

	if err != nil {
		log.Fatalf("failed to get table bucket %v", err)
	}

	log.Printf("get table bucket result:%#v\n", result)
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class GetTableBucketSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            GetTableBucketResult result = client.getTableBucket(GetTableBucketRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .build());

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Table bucket ARN: %s%n", result.arn());
            System.out.printf("Table bucket name: %s%n", result.name());
            System.out.printf("Table bucket type: %s%n", result.type());
            System.out.printf("Owner account ID: %s%n", result.ownerAccountId());
            System.out.printf("Table bucket ID: %s%n", result.tableBucketId());
            System.out.printf("Created at: %s%n", result.createdAt());
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="list table buckets sample")
parser.add_argument('--region', help='The region in which the table buckets are located.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS Tables.')
parser.add_argument('--prefix', help='The prefix used to filter the table buckets.')
parser.add_argument('--max-buckets', help='The maximum number of buckets to return.', type=int)

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.list_table_buckets(oss_tables.models.ListTableBucketsRequest(
        prefix=args.prefix,
        max_buckets=args.max_buckets,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
          f' continuation token: {result.continuation_token}')

    if result.table_buckets:
        for i, bucket in enumerate(result.table_buckets):
            print(f'bucket {i + 1}:'
                  f' arn: {bucket.arn},'
                  f' name: {bucket.name},'
                  f' id: {bucket.table_bucket_id},'
                  f' owner account id: {bucket.owner_account_id},'
                  f' created at: {bucket.created_at}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
}

func main() {
	flag.Parse()

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	p := client.NewListTableBucketsPaginator(&tables.ListTableBucketsRequest{})

	var i int
	log.Println("Table Buckets:")
	for p.HasNext() {
		i++

		page, err := p.NextPage(context.TODO())
		if err != nil {
			log.Fatalf("failed to get page %v, %v", i, err)
		}

		// Log the objects found
		for _, b := range page.TableBuckets {
			log.Printf("Table Bucket %v,%v,%v,%v,%v,%v\n", oss.ToString(b.Name), oss.ToString(b.Arn), oss.ToString(b.OwnerAccountId), oss.ToString(b.TableBucketId), oss.ToString(b.CreatedAt), oss.ToString(b.Type))
		}
	}
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class ListTableBucketsSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        int maxBuckets = 10;

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            ListTableBucketsRequest request = ListTableBucketsRequest.newBuilder()
                    .maxBuckets(maxBuckets)
                    .build();

            ListTableBucketsResult result = client.listTableBuckets(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Continuation token: %s%n", result.continuationToken());
            System.out.printf("Number of buckets: %d%n", result.tableBuckets().size());

            for (int i = 0; i < result.tableBuckets().size(); i++) {
                TableBucketSummary bucket = result.tableBuckets().get(i);
                System.out.printf("Bucket %d:%n", i + 1);
                System.out.printf("  ARN: %s%n", bucket.arn());
                System.out.printf("  Name: %s%n", bucket.name());
                System.out.printf("  ID: %s%n", bucket.tableBucketId());
                System.out.printf("  Owner Account ID: %s%n", bucket.ownerAccountId());
                System.out.printf("  Created At: %s%n", bucket.createdAt());
            }
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="delete table bucket sample")
parser.add_argument('--region', help='The region in which the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.delete_table_bucket(oss_tables.models.DeleteTableBucketRequest(
        table_bucket_arn=args.table_bucket_arn,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The arn of the table bucket.")
}

func main() {
	flag.Parse()
	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	result, err := client.DeleteTableBucket(context.TODO(), &tables.DeleteTableBucketRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
	})

	if err != nil {
		log.Fatalf("failed to delete table bucket %v", err)
	}

	log.Printf("delete table bucket result:%#v\n", result)
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class DeleteTableBucketSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            DeleteTableBucketRequest request = DeleteTableBucketRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .build();

            DeleteTableBucketResult result = client.deleteTableBucket(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.println("Successfully deleted table bucket.");
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="create namespace sample")
parser.add_argument('--region', help='The region where the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The endpoint for accessing OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)
parser.add_argument('--namespace', help='The namespace to create, comma separated if multiple.', required=True)

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    namespaces = args.namespace.split(",")

    result = client.create_namespace(oss_tables.models.CreateNamespaceRequest(
        table_bucket_arn=args.table_bucket_arn,
        namespace=namespaces,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id}')
    print(f'successfully created namespace(s) in table bucket: {args.table_bucket_arn}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
)

func init() {
	flag.StringVar(&region, "region", "", "The region where the bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The ARN of the table bucket.")
}

func main() {
	flag.Parse()
	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	result, err := client.CreateNamespace(context.TODO(), &tables.CreateNamespaceRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
		Namespace:      []string{"my_space"},
	})

	if err != nil {
		log.Fatalf("failed to create namespace %v", err)
	}

	log.Printf("create namespace result:%#v\n", result)
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

import java.util.Arrays;
import java.util.List;

public class CreateNamespaceSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";
        String namespace = "mynamespace";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            List<String> namespaces = Arrays.asList("mynamespace");

            CreateNamespaceRequest request = CreateNamespaceRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .namespace(namespaces)
                    .build();

            CreateNamespaceResult result = client.createNamespace(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Successfully created namespace(s) in table bucket: %s%n", tableBucketARN);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="get namespace sample")
parser.add_argument('--region', help='The region where the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The endpoint for accessing OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)
parser.add_argument('--namespace', help='The namespace to get.', required=True)

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.get_namespace(oss_tables.models.GetNamespaceRequest(
        table_bucket_arn=args.table_bucket_arn,
        namespace=args.namespace,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
          f' namespace: {result.namespace},'
          f' namespace id: {result.namespace_id},'
          f' table bucket id: {result.table_bucket_id},'
          f' owner account id: {result.owner_account_id},'
          f' created at: {result.created_at},'
          f' created by: {result.created_by}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
)

func init() {
	flag.StringVar(&region, "region", "", "The region where the bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The ARN of the table bucket.")
}

func main() {
	flag.Parse()
	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	result, err := client.GetNamespace(context.TODO(), &tables.GetNamespaceRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
		Namespace:      oss.Ptr("my_space"),
	})

	if err != nil {
		log.Fatalf("failed to get namespace %v", err)
	}

	log.Printf("get namespace result:%#v\n", result)
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class GetNamespaceSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";
        String namespace = "mynamespace";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            GetNamespaceRequest request = GetNamespaceRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .namespace(namespace)
                    .build();

            GetNamespaceResult result = client.getNamespace(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Successfully retrieved namespace: %s from table bucket: %s%n", result.namespaceId(), tableBucketARN);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="list namespaces sample")
parser.add_argument('--region', help='The region where the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The endpoint for accessing OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)
parser.add_argument('--prefix', help='The prefix to filter namespaces.')
parser.add_argument('--max-namespaces', type=int, help='The maximum number of namespaces to return.')

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.list_namespaces(oss_tables.models.ListNamespacesRequest(
        table_bucket_arn=args.table_bucket_arn,
        prefix=args.prefix,
        max_namespaces=args.max_namespaces,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
          f' continuation token: {result.continuation_token}')

    if result.namespaces:
        for i, ns in enumerate(result.namespaces):
            print(f'namespace {i + 1}:'
                  f' namespace: {ns.namespace},'
                  f' namespace id: {ns.namespace_id},'
                  f' owner account id: {ns.owner_account_id},'
                  f' created at: {ns.created_at},'
                  f' created by: {ns.created_by}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
)

func init() {
	flag.StringVar(&region, "region", "", "The region where the bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The ARN of the table bucket.")
}

func main() {
	flag.Parse()
	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	p := client.NewListNameSpacesPaginator(&tables.ListNamespacesRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
	})

	var i int
	log.Println("Namespaces:")
	for p.HasNext() {
		i++

		page, err := p.NextPage(context.TODO())
		if err != nil {
			log.Fatalf("failed to get page %v, %v", i, err)
		}

		for _, b := range page.Namespaces {
			log.Printf("Namespace %v,%v,%v,%v,%v,%v\n", oss.ToString(b.CreatedAt), oss.ToString(b.CreatedBy), oss.ToString(b.OwnerAccountId), oss.ToString(b.TableBucketId), oss.ToString(b.NamespaceId), b.Namespace)
		}
	}
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class ListNamespacesSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";
        int maxNamespaces = 10;

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            ListNamespacesRequest request = ListNamespacesRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .maxNamespaces(maxNamespaces)
                    .build();

            ListNamespacesResult result = client.listNamespaces(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Successfully listed namespaces for table bucket: %s%n", tableBucketARN);
            System.out.printf("Continuation token: %s%n", result.continuationToken());

            for (int i = 0; i < result.namespaces().size(); i++) {
                NamespaceSummary ns = result.namespaces().get(i);
                if (ns.namespace() != null && !ns.namespace().isEmpty()) {
                    System.out.printf("Namespace %%d: %%s (ID: %%s)%%n", i+1, ns.namespace().get(0), ns.namespaceId());
                } else {
                    System.out.printf("Namespace %%d: (no namespace name) (ID: %%s)%%n", i+1, ns.namespaceId());
                }
            }
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="delete namespace sample")
parser.add_argument('--region', help='The region where the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The endpoint for accessing OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)
parser.add_argument('--namespace', help='The namespace to delete.', required=True)

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.delete_namespace(oss_tables.models.DeleteNamespaceRequest(
        table_bucket_arn=args.table_bucket_arn,
        namespace=args.namespace,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id}')
    print(f'successfully deleted namespace: {args.namespace}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
)

func init() {
	flag.StringVar(&region, "region", "", "The region where the bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The ARN of the table bucket.")
}

func main() {
	flag.Parse()
	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	result, err := client.DeleteNamespace(context.TODO(), &tables.DeleteNamespaceRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
		Namespace:      oss.Ptr("my_space"),
	})

	if err != nil {
		log.Fatalf("failed to delete namespace %v", err)
	}

	log.Printf("delete namespace result:%#v\n", result)
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class DeleteNamespaceSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";
        String namespace = "mynamespace";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            DeleteNamespaceRequest request = DeleteNamespaceRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .namespace(namespace)
                    .build();

            DeleteNamespaceResult result = client.deleteNamespace(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Successfully deleted namespace: %s from table bucket: %s%n", namespace, tableBucketARN);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="create table sample")
parser.add_argument('--region', help='The region in which the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)
parser.add_argument('--namespace', help='The namespace of the table.', required=True)
parser.add_argument('--name', help='The name of the table.', required=True)
parser.add_argument('--format', help='The format of the table.', required=True)

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    # Create schema fields
    schema = oss_tables.models.IcebergSchema(fields=[
        oss_tables.models.SchemaField(name="id", type="long", required=True),
        oss_tables.models.SchemaField(name="name", type="string", required=False),
        oss_tables.models.SchemaField(name="ts", type="timestamptz", required=False),
    ])

    # Create partition spec
    partition_spec = oss_tables.models.IcebergPartitionSpec(
        spec_id=0,
        fields=[
            oss_tables.models.IcebergPartitionField(
                source_id=2,
                field_id=1001,
                name="region",
                transform="identity",
            ),
        ],
    )

    # Create Iceberg metadata. Use 'properties' to specify 'format-version', which supports "2" and "3".
    iceberg_metadata = oss_tables.models.IcebergMetadata(
        schema=schema,
        partition_spec=partition_spec,
        properties={"format-version": "2"},
    )

    # Set metadata
    metadata = oss_tables.models.TableMetadata(iceberg=iceberg_metadata)

    # Add encryption configuration. 'sse_algorithm' supports "AES256" and "KMS". If using "KMS", 'kms_key_arn' must also be specified.
    encryption_configuration = oss_tables.models.EncryptionConfiguration(
        sse_algorithm="AES256",
    )

    result = client.create_table(oss_tables.models.CreateTableRequest(
        table_bucket_arn=args.table_bucket_arn,
        namespace=args.namespace,
        name=args.name,
        format=args.format,
        metadata=metadata,
        encryption_configuration=encryption_configuration,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
          f' table arn: {result.table_arn},'
          f' version token: {result.version_token}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
	namespace      string
	name           string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The arn of the table bucket.")
	flag.StringVar(&namespace, "namespace", "", "The name of the namespace.")
	flag.StringVar(&name, "name", "", "The name of the table.")
}

func main() {
	flag.Parse()
	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(namespace) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, namespace name required")
	}

	if len(name) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table name required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	// Build the complete Iceberg metadata using a map. 'format-version' in properties specifies the table format version ("2" or "3").
	icebergMap := map[string]any{
		"schema": map[string]any{
			"fields": []map[string]any{
				{"name": "id", "type": "long", "required": true},
				{"name": "data", "type": "string"},
			},
		},
		"properties": map[string]any{
			"format-version": "2",
		},
	}

	result, err := client.CreateTable(context.TODO(), &tables.CreateTableRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
		Namespace:      oss.Ptr(namespace),
		Name:           oss.Ptr(name),
		Format:         oss.Ptr("ICEBERG"),
		Metadata: &tables.TableMetadata{
			Iceberg: &tables.IcebergMetadata{Schema: icebergMap},
		},
		// Server-side encryption: SseAlgorithm
		EncryptionConfiguration: &tables.EncryptionConfiguration{
			SseAlgorithm: oss.Ptr("AES256"),
		},
	})

	if err != nil {
		log.Fatalf("failed to create table %v", err)
	}

	log.Printf("create table result:%#v\n", result)
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

import java.util.ArrayList;
import java.util.List;

public class CreateTableSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";
        String namespace = "mynamespace";
        String name = "mytable";
        String format = "iceberg";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            // Create schema fields
            List<SchemaField> fields = new ArrayList<>();
            fields.add(SchemaField.newBuilder()
                .name("id")
                .type("long")
                .required(true)
                .build());
            fields.add(SchemaField.newBuilder()
                .name("name")
                .type("string")
                .required(false)
                .build());
            fields.add(SchemaField.newBuilder()
                .name("ts")
                .type("timestamptz")
                .required(false)
                .build());

            // Create schema
            IcebergSchema icebergSchema = IcebergSchema.newBuilder()
                .fields(fields)
                .build();

            // Create partition spec
            IcebergPartitionField partitionField = IcebergPartitionField.newBuilder()
                .sourceId(2)
                .transform("identity")
                .name("region")
                .fieldId(1001)
                .build();
            List<IcebergPartitionField> partitionFields = new ArrayList<>();
            partitionFields.add(partitionField);
            IcebergPartitionSpec partitionSpec = IcebergPartitionSpec.newBuilder()
                .specId(0)
                .fields(partitionFields)
                .build();

            // Create iceberg metadata
            IcebergMetadata icebergMetadata = IcebergMetadata.newBuilder()
                .schema(icebergSchema)
                .partitionSpec(partitionSpec)
                .build();

            // Set metadata
            TableMetadata metadata = TableMetadata.newBuilder()
                .iceberg(icebergMetadata)
                .build();

            // Add encryption configuration
            EncryptionConfiguration encryptionConfig = EncryptionConfiguration.newBuilder()
                .sseAlgorithm("AES256")
                .build();

            CreateTableRequest request = CreateTableRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .namespace(namespace)
                    .name(name)
                    .format(format)
                    .metadata(metadata)
                    .encryptionConfiguration(encryptionConfig)
                    .build();

            CreateTableResult result = client.createTable(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Created table with ARN: %s%n", result.tableARN());
            System.out.printf("Version token: %s%n", result.versionToken());
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="get table sample")
parser.add_argument('--region', help='The region where the Table Bucket is located.', required=True)
parser.add_argument('--endpoint', help='The endpoint to access OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the Table Bucket.')
parser.add_argument('--namespace', help='The namespace of the Table.')
parser.add_argument('--name', help='The name of the Table.')
parser.add_argument('--table-arn', help='The ARN of the Table.')

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.get_table(oss_tables.models.GetTableRequest(
        table_bucket_arn=args.table_bucket_arn,
        namespace=args.namespace,
        name=args.name,
        table_arn=args.table_arn,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
          f' name: {result.name},'
          f' table arn: {result.table_arn},'
          f' format: {result.format},'
          f' created by: {result.created_by},'
          f' created at: {result.created_at}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
	namespace      string
	name           string
	tableArn       string
)

func init() {
	flag.StringVar(&region, "region", "", "The region where the Table Bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The ARN of the Table Bucket.")
	flag.StringVar(&namespace, "namespace", "", "The namespace of the Table.")
	flag.StringVar(&name, "name", "", "The name of the Table.")
	flag.StringVar(&tableArn, "table-arn", "", "The ARN of the Table.")
}

func main() {
	flag.Parse()

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	// Method 1: Query by using the Table Bucket ARN, namespace, and name.
	result, err := client.GetTable(context.TODO(), &tables.GetTableRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
		Namespace:      oss.Ptr(namespace),
		Name:           oss.Ptr(name),
	})

	// Method 2: Query by using the Table ARN.
	//result, err := client.GetTable(context.TODO(), &tables.GetTableRequest{
	//	TableARN: oss.Ptr(tableArn),
	//})

	if err != nil {
		log.Fatalf("failed to get table %v", err)
	}

	log.Printf("get table result:%#v\n", result)
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class GetTableSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";
        String namespace = "mynamespace";
        String tableName = "mytable";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            // Method 1: Query by using the Table Bucket ARN, namespace, and name.
            GetTableRequest request = GetTableRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .namespace(namespace)
                    .name(tableName)
                    .build();

            // Method 2: Query by using the Table ARN.
            // GetTableRequest request = GetTableRequest.newBuilder()
            //         .tableARN("acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket/table/table-id")
            //         .build();

            GetTableResult result = client.getTable(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Table name: %s%n", result.name());
            System.out.printf("Table ARN: %s%n", result.tableARN());
            System.out.printf("Format: %s%n", result.format());
            System.out.printf("Created by: %s%n", result.createdBy());
            System.out.printf("Created at: %s%n", result.createdAt());
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="list tables sample")
parser.add_argument('--region', help='The region of the table bucket.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)
parser.add_argument('--namespace', help='The namespace of the tables.', required=True)
parser.add_argument('--prefix', help='The prefix to filter tables.')
parser.add_argument('--max-tables', type=int, help='The maximum number of tables to return.')

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.list_tables(oss_tables.models.ListTablesRequest(
        table_bucket_arn=args.table_bucket_arn,
        namespace=args.namespace,
        prefix=args.prefix,
        max_tables=args.max_tables,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
          f' continuation token: {result.continuation_token}')

    if result.table_summaries:
        for i, table in enumerate(result.table_summaries):
            print(f'table {i + 1}:'
                  f' name: {table.name},'
                  f' namespace: {table.namespace},'
                  f' type: {table.type},'
                  f' table arn: {table.table_arn},'
                  f' created at: {table.created_at},'
                  f' modified at: {table.modified_at}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
	namespace      string
)

func init() {
	flag.StringVar(&region, "region", "", "The region of the table bucket.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The ARN of the table bucket.")
	flag.StringVar(&namespace, "namespace", "", "The namespace of the tables.")
}

func main() {
	flag.Parse()
	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(namespace) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, namespace name required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	p := client.NewListTablesPaginator(&tables.ListTablesRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
		Namespace:      oss.Ptr(namespace),
	})

	var i int
	log.Println("Tables:")
	for p.HasNext() {
		i++

		page, err := p.NextPage(context.TODO())
		if err != nil {
			log.Fatalf("failed to get page %v, %v", i, err)
		}

		for _, b := range page.Tables {
			log.Printf("Table %v,%v,%v,%v,%v,%v\n", oss.ToString(b.CreatedAt), oss.ToString(b.TableARN), oss.ToString(b.ModifiedAt), oss.ToString(b.Type), oss.ToString(b.Name), b.Namespace)
		}
	}
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class ListTablesSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";
        String namespace = "mynamespace";
        int maxTables = 10;

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            ListTablesRequest request = ListTablesRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .namespace(namespace)
                    .maxTables(maxTables)
                    .build();

            ListTablesResult result = client.listTables(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Continuation token: %s%n", result.continuationToken());

            if (result.tables() != null) {
                System.out.printf("Number of tables: %d%n", result.tables().size());
                for (int i = 0; i < result.tables().size(); i++) {
                    TableSummary table = result.tables().get(i);
                    System.out.printf("Table %d:%n", i + 1);
                    System.out.printf("  Name: %s%n", table.name());
                    System.out.printf("  Namespace: %s%n", table.namespace());
                    System.out.printf("  ARN: %s%n", table.tableARN());
                    System.out.printf("  Type: %s%n", table.type());
                    System.out.printf("  Created at: %s%n", table.createdAt());
                    System.out.printf("  Modified at: %s%n", table.modifiedAt());
                }
            } else {
                System.out.println("No tables found.");
            }
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="rename table sample")
parser.add_argument('--region', help='The region where the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The endpoint for accessing OSSTables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)
parser.add_argument('--namespace', help='The namespace of the table.', required=True)
parser.add_argument('--name', help='The current name of the table.', required=True)
parser.add_argument('--new-namespace-name', help='The new namespace name for the table.')
parser.add_argument('--new-name', help='The new name for the table.')
parser.add_argument('--version-token', help='The version token for the table.')

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.rename_table(oss_tables.models.RenameTableRequest(
        table_bucket_arn=args.table_bucket_arn,
        namespace=args.namespace,
        name=args.name,
        new_namespace_name=args.new_namespace_name,
        new_name=args.new_name,
        version_token=args.version_token,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id}')
    print(f'successfully renamed table: {args.namespace}/{args.name}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
	namespace      string
	name           string
	newName        string
)

func init() {
	flag.StringVar(&region, "region", "", "The region where the table bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The ARN of the table bucket.")
	flag.StringVar(&namespace, "namespace", "", "The name of the namespace.")
	flag.StringVar(&name, "name", "", "The name of the table.")
	flag.StringVar(&newName, "new-name", "", "The new name of the table.")
}

func main() {
	flag.Parse()

	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(namespace) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, namespace name required")
	}

	if len(name) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table name required")
	}

	if len(newName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table new name required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	result, err := client.RenameTable(context.TODO(), &tables.RenameTableRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
		Namespace:      oss.Ptr(namespace),
		Name:           oss.Ptr(name),
		NewName:        oss.Ptr(newName),
	})

	if err != nil {
		log.Fatalf("failed to rename table %v", err)
	}

	log.Printf("rename table result:%#v\n", result)
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class RenameTableSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";
        String namespace = "mynamespace";
        String name = "mytable";
        String newName = "mytable-renamed";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            RenameTableRequest request = RenameTableRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .namespace(namespace)
                    .name(name)
                    .newName(newName)
                    .build();

            RenameTableResult result = client.renameTable(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Successfully renamed table from %s/%s to %s/%s%n",
                    namespace, name, namespace, newName);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

# Step 1: Delete a table
# Full sample: delete_table.py
import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="delete table sample")
parser.add_argument('--region', help='The region in which the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)
parser.add_argument('--namespace', help='The namespace of the table.', required=True)
parser.add_argument('--name', help='The name of the table.', required=True)
parser.add_argument('--version-token', help='The version token for optimistic locking.')

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.delete_table(oss_tables.models.DeleteTableRequest(
        table_bucket_arn=args.table_bucket_arn,
        namespace=args.namespace,
        name=args.name,
        version_token=args.version_token,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id}')
    print(f'successfully deleted table: {args.namespace}/{args.name}')

if __name__ == "__main__":
    main()

# ----------------------------------------------------------------
# Step 2: Delete a namespace (To delete a namespace, you must first delete all tables within it.)
# Full sample: delete_namespace.py
import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="delete namespace sample")
parser.add_argument('--region', help='The region in which the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)
parser.add_argument('--namespace', help='The namespace to delete.', required=True)

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.delete_namespace(oss_tables.models.DeleteNamespaceRequest(
        table_bucket_arn=args.table_bucket_arn,
        namespace=args.namespace,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id}')
    print(f'successfully deleted namespace: {args.namespace}')

if __name__ == "__main__":
    main()

// Step 1: Delete a table
// Full sample: delete_table.go
package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
	namespace      string
	name           string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The ARN of the table bucket.")
	flag.StringVar(&namespace, "namespace", "", "The name of the namespace.")
	flag.StringVar(&name, "name", "", "The name of the table.")
}

func main() {
	flag.Parse()

	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(namespace) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, namespace name required")
	}

	if len(name) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table name required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	result, err := client.DeleteTable(context.TODO(), &tables.DeleteTableRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
		Namespace:      oss.Ptr(namespace),
		Name:           oss.Ptr(name),
	})

	if err != nil {
		log.Fatalf("failed to delete table %v", err)
	}

	log.Printf("delete table result:%#v\n", result)
}

// ----------------------------------------------------------------
// Step 2: Delete a namespace (To delete a namespace, you must first delete all tables within it.)
// Full sample: delete_namespace.go
package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The ARN of the table bucket.")
}

func main() {
	flag.Parse()
	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	result, err := client.DeleteNamespace(context.TODO(), &tables.DeleteNamespaceRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
		Namespace:      oss.Ptr("my_space"),
	})

	if err != nil {
		log.Fatalf("failed to delete namespace %v", err)
	}

	log.Printf("delete namespace result:%#v\n", result)
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class DeleteTableSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";
        String namespace = "mynamespace";
        String tableName = "mytable";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            DeleteTableRequest request = DeleteTableRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .namespace(namespace)
                    .name(tableName)
                    .build();

            DeleteTableResult result = client.deleteTable(request);

            System.out.printf("Status code: %d, request id: %s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Successfully deleted table: %s/%s from bucket: %s%n",
                    namespace, tableName, tableBucketARN);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="get table metadata location sample")
parser.add_argument('--region', help='The region where the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The endpoint for accessing OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)
parser.add_argument('--namespace', help='The table namespace.', required=True)
parser.add_argument('--name', help='The table name.', required=True)

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.get_table_metadata_location(
        oss_tables.models.GetTableMetadataLocationRequest(
            table_bucket_arn=args.table_bucket_arn,
            namespace=args.namespace,
            name=args.name,
        )
    )

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
          f' version token: {result.version_token},'
          f' metadata location: {result.metadata_location},'
          f' warehouse location: {result.warehouse_location}')

if __name__ == "__main__":
    main()

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.tables as oss_tables

parser = argparse.ArgumentParser(description="update table metadata location sample")
parser.add_argument('--region', help='The region where the table bucket is located.', required=True)
parser.add_argument('--endpoint', help='The endpoint for accessing OSS Tables.')
parser.add_argument('--table-bucket-arn', help='The ARN of the table bucket.', required=True)
parser.add_argument('--namespace', help='The table namespace.', required=True)
parser.add_argument('--name', help='The table name.', required=True)
parser.add_argument('--version-token', help='The version token.', required=True)
parser.add_argument('--metadata-location', help='The new metadata location.', required=True)

def main():
    args = parser.parse_args()

    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_tables.Client(cfg)

    result = client.update_table_metadata_location(
        oss_tables.models.UpdateTableMetadataLocationRequest(
            table_bucket_arn=args.table_bucket_arn,
            namespace=args.namespace,
            name=args.name,
            version_token=args.version_token,
            metadata_location=args.metadata_location,
        )
    )

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
          f' name: {result.name},'
          f' version token: {result.version_token},'
          f' metadata location: {result.metadata_location},'
          f' table arn: {result.table_arn}')

if __name__ == "__main__":
    main()

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region         string
	tableBucketArn string
	namespace      string
	name           string
)

func init() {
	flag.StringVar(&region, "region", "", "The region where the bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The ARN of the table bucket.")
	flag.StringVar(&namespace, "namespace", "", "The table namespace.")
	flag.StringVar(&name, "name", "", "The table name.")
}

func main() {
	flag.Parse()

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(namespace) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, namespace name required")
	}

	if len(name) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table name required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	result, err := client.GetTableMetadataLocation(context.TODO(), &tables.GetTableMetadataLocationRequest{
		TableBucketARN: oss.Ptr(tableBucketArn),
		Namespace:      oss.Ptr(namespace),
		Name:           oss.Ptr(name),
	})

	if err != nil {
		log.Fatalf("failed to get table metadata location %v", err)
	}

	log.Printf("get table metadata location result:%#v\n", result)
}

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/tables"
)

var (
	region           string
	tableBucketArn   string
	namespace        string
	name             string
	metadataLocation string
	versionToken     string
)

func init() {
	flag.StringVar(&region, "region", "", "The region where the bucket is located.")
	flag.StringVar(&tableBucketArn, "table-bucket-arn", "", "The ARN of the table bucket.")
	flag.StringVar(&namespace, "namespace", "", "The table namespace.")
	flag.StringVar(&name, "name", "", "The table name.")
	flag.StringVar(&metadataLocation, "metadata-location", "", "The table's metadata location.")
	flag.StringVar(&versionToken, "version-token", "", "The table's version token.")
}

func main() {
	flag.Parse()

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	if len(tableBucketArn) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table bucket arn required")
	}

	if len(namespace) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, namespace name required")
	}

	if len(name) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table name required")
	}

	if len(metadataLocation) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table metadata location required")
	}

	if len(versionToken) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, table version token required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	client := tables.NewTablesClient(cfg)

	result, err := client.UpdateTableMetadataLocation(context.TODO(), &tables.UpdateTableMetadataLocationRequest{
		TableBucketARN:   oss.Ptr(tableBucketArn),
		Namespace:        oss.Ptr(namespace),
		Name:             oss.Ptr(name),
		MetadataLocation: oss.Ptr(metadataLocation),
		VersionToken:     oss.Ptr(versionToken),
	})

	if err != nil {
		log.Fatalf("failed to update table metadata location %v", err)
	}

	log.Printf("update table metadata location result:%#v\n", result)
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class GetTableMetadataLocationSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";
        String namespace = "mynamespace";
        String name = "mytable";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            GetTableMetadataLocationRequest request = GetTableMetadataLocationRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .namespace(namespace)
                    .name(name)
                    .build();

            GetTableMetadataLocationResult result = client.getTableMetadataLocation(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Metadata location: %s%n", result.metadataLocation());
            System.out.printf("Version token: %s%n", result.versionToken());
            System.out.printf("Warehouse location: %s%n", result.warehouseLocation());
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.tables.OSSTablesClient;
import com.aliyun.sdk.service.oss2.tables.models.*;

public class UpdateTableMetadataLocationSample {

    public static void main(String[] args) throws Exception {
        String region = "cn-hangzhou";
        String tableBucketARN = "acs:osstables:cn-hangzhou:1234567890:bucket/mytablebucket";
        String namespace = "mynamespace";
        String name = "mytable";
        String versionToken = "your-version-token";
        String metadataLocation = "oss://warehouse/metadata/v1.metadata.json";

        try (OSSTablesClient client = OSSTablesClient.newBuilder()
                .credentialsProvider(new EnvironmentVariableCredentialsProvider())
                .region(region)
                .build()) {
            UpdateTableMetadataLocationRequest request = UpdateTableMetadataLocationRequest.newBuilder()
                    .tableBucketARN(tableBucketARN)
                    .namespace(namespace)
                    .name(name)
                    .versionToken(versionToken)
                    .metadataLocation(metadataLocation)
                    .build();

            UpdateTableMetadataLocationResult result = client.updateTableMetadataLocation(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
            System.out.printf("Successfully updated table metadata location for table: %s%n", name);
            System.out.printf("New metadata location: %s%n", result.metadataLocation());
            System.out.printf("New version token: %s%n", result.versionToken());
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}