Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

5.0 KB
Raw Blame
package dynamodb

import (
	"context"
	"slices"
	"strings"

	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
	"github.com/aws/aws-sdk-go-v2/service/sts"
	metadatapb "github.com/bytebase/omni/metadata"
	"github.com/pkg/errors"

	"github.com/bytebase/bytebase/backend/plugin/db"
)

// SyncInstance syncs the instance.
func (d *Driver) SyncInstance(ctx context.Context) (*db.InstanceMetadata, error) {
	// DynamoDB do not have the concept of Database, which is important concept in Bytebase.
	// We use the format {account_id}-{region} as the pseudo database name.
	stsClient := sts.NewFromConfig(d.awsConfig)
	identity, err := stsClient.GetCallerIdentity(ctx, &sts.GetCallerIdentityInput{})
	if err != nil {
		return nil, errors.Wrapf(err, "failed to get caller identity")
	}
	if identity.Account == nil {
		return nil, errors.New("account id is empty in the caller identity")
	}
	region := d.awsConfig.Region
	if region == "" {
		return nil, errors.New("region is empty in the AWS config")
	}
	databaseName := formatDatabaseName(*identity.Account, region)

	return &db.InstanceMetadata{
		Databases: []*metadatapb.DatabaseSchemaMetadata{
			{
				Name: databaseName,
			},
		},
	}, nil
}

// SyncDBSchema syncs a single database schema.
func (d *Driver) SyncDBSchema(ctx context.Context) (*metadatapb.DatabaseSchemaMetadata, error) {
	schemaMetadata := &metadatapb.SchemaMetadata{}

	tableNames, err := d.listAllTables(ctx)
	if err != nil {
		return nil, errors.Wrapf(err, "failed to list all tables")
	}

	// DynamoDB do not support batch describe table, the operation that we call describe table one by one may be
	// very slow because the multi round trip to AWS.
	// We may need to optimize this in the future.
	for _, tableName := range tableNames {
		tableMetadata, err := d.syncTable(ctx, tableName)
		if err != nil {
			return nil, errors.Wrapf(err, "failed to describe table: %s", tableName)
		}
		if tableMetadata != nil {
			schemaMetadata.Tables = append(schemaMetadata.Tables, tableMetadata)
		}
	}

	return &metadatapb.DatabaseSchemaMetadata{
		Name: d.config.ConnectionContext.DatabaseName,
		Schemas: []*metadatapb.SchemaMetadata{
			schemaMetadata,
		},
	}, nil
}

func (d *Driver) syncTable(ctx context.Context, tableName string) (*metadatapb.TableMetadata, error) {
	tableMetadata := &metadatapb.TableMetadata{
		Name: tableName,
	}
	out, err := d.client.DescribeTable(ctx, &dynamodb.DescribeTableInput{
		TableName: &tableName,
	})
	if err != nil {
		return nil, errors.Wrapf(err, "failed to describe table: %s", tableName)
	}
	if out.Table == nil {
		return nil, errors.Errorf("table not found: %s", tableName)
	}
	if out.Table.TableStatus != types.TableStatusActive {
		return nil, nil
	}
	if out.Table.KeySchema != nil {
		var hashKeyAttributes, rangeKeyAttributes []string
		for _, keySchema := range out.Table.KeySchema {
			switch keySchema.KeyType {
			case types.KeyTypeHash:
				hashKeyAttributes = append(hashKeyAttributes, *keySchema.AttributeName)
			case types.KeyTypeRange:
				rangeKeyAttributes = append(rangeKeyAttributes, *keySchema.AttributeName)
			default:
				// Unknown key type, ignore
			}
		}
		tableMetadata.Indexes = append(tableMetadata.Indexes, &metadatapb.IndexMetadata{
			Name:        strings.Join(hashKeyAttributes, ","),
			Expressions: append([]string{}, hashKeyAttributes...),
			Type:        "HASH",
		})
		tableMetadata.Indexes = append(tableMetadata.Indexes, &metadatapb.IndexMetadata{
			Name:        strings.Join(rangeKeyAttributes, ","),
			Expressions: append([]string{}, rangeKeyAttributes...),
			Type:        "RANGE",
		})
		columnsMap := make(map[string]bool)
		for _, key := range hashKeyAttributes {
			columnsMap[key] = true
		}
		for _, key := range rangeKeyAttributes {
			columnsMap[key] = true
		}
		sortedColumns := make([]string, 0, len(columnsMap))
		for key := range columnsMap {
			sortedColumns = append(sortedColumns, key)
		}
		slices.Sort(sortedColumns)
		tableMetadata.Columns = make([]*metadatapb.ColumnMetadata, 0, len(sortedColumns))
		for _, key := range sortedColumns {
			tableMetadata.Columns = append(tableMetadata.Columns, &metadatapb.ColumnMetadata{
				Name: key,
			})
		}
	}
	if out.Table.TableName != nil {
		tableMetadata.Name = *out.Table.TableName
	}
	if out.Table.ItemCount != nil {
		tableMetadata.RowCount = *out.Table.ItemCount
	}

	return tableMetadata, nil
}

func (d *Driver) listAllTables(ctx context.Context) ([]string, error) {
	var result []string
	var exclusiveStartTableName *string
	for {
		out, err := d.client.ListTables(ctx, &dynamodb.ListTablesInput{
			Limit:                   new(int32(100)),
			ExclusiveStartTableName: exclusiveStartTableName,
		})
		if err != nil {
			return nil, errors.Wrapf(err, "failed to list tables")
		}
		result = append(result, out.TableNames...)
		if out.LastEvaluatedTableName == nil {
			break
		}
		exclusiveStartTableName = out.LastEvaluatedTableName
	}
	return result, nil
}

func formatDatabaseName(accountID string, region string) string {
	return accountID + "-" + region
}