Skip to content

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

refactor(hive): migrate to gohive v2 with database/sql interface (#19070)

Danny Xucb1613684617
diff --git a/backend/plugin/db/hive/dump.go b/backend/plugin/db/hive/dump.go
index 547e6f2b70..916450fae9 100644
--- a/backend/plugin/db/hive/dump.go
+++ b/backend/plugin/db/hive/dump.go
@@ -6,7 +6,8 @@ import (
"io"
"strings"
- "github.com/beltran/gohive"
+ // Import gohive v2 driver for database/sql registration.
+ _ "github.com/beltran/gohive/v2"
"github.com/pkg/errors"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -56,6 +57,10 @@ type MaterializedViewDDLOptions struct {
}
func (d *Driver) Dump(ctx context.Context, out io.Writer, _ *storepb.DatabaseSchemaMetadata) error {
+ if d.db == nil {
+ return errors.New("connection not initialized")
+ }
+
var builder strings.Builder
databaseName := d.config.ConnectionContext.DatabaseName
@@ -68,19 +73,19 @@ func (d *Driver) Dump(ctx context.Context, out io.Writer, _ *storepb.DatabaseSch
}
schema := database.Schemas[0]
- cursor := d.conn.Cursor()
- if err := executeCursor(ctx, cursor, fmt.Sprintf("use %s", databaseName)); err != nil {
- return err
+ // Set current database
+ if _, err := d.db.ExecContext(ctx, fmt.Sprintf("USE %s", databaseName)); err != nil {
+ return errors.Wrap(err, "failed to set database")
}
- // dump managed tables.
+ // Dump managed tables
for _, table := range schema.GetTables() {
- tableDDL, err := showCreateDDL(ctx, d.conn, "TABLE", table.Name)
+ tableDDL, err := d.showCreateDDL(ctx, "TABLE", table.Name)
if err != nil {
return errors.Wrapf(err, "failed to dump table %s", table.Name)
}
- // dump indexes.
+ // Dump indexes
for _, index := range table.GetIndexes() {
indexDDL, err := genIndexDDL(&IndexDDLOptions{
databaseName: databaseName,
@@ -107,25 +112,25 @@ func (d *Driver) Dump(ctx context.Context, out io.Writer, _ *storepb.DatabaseSch
_, _ = builder.WriteString(tableDDL)
}
- // dump external tables.
+ // Dump external tables
for _, extTable := range schema.GetExternalTables() {
- tabDDL, err := showCreateDDL(ctx, d.conn, "TABLE", extTable.Name)
+ tabDDL, err := d.showCreateDDL(ctx, "TABLE", extTable.Name)
if err != nil {
return errors.Wrapf(err, "failed to dump table %s", extTable.Name)
}
_, _ = builder.WriteString(tabDDL)
}
- // dump views.
+ // Dump views
for _, view := range schema.GetViews() {
- viewDDL, err := showCreateDDL(ctx, d.conn, "VIEW", view.Name)
+ viewDDL, err := d.showCreateDDL(ctx, "VIEW", view.Name)
if err != nil {
return errors.Wrapf(err, "failed to dump view %s", view.Name)
}
_, _ = builder.WriteString(viewDDL)
}
- // dump materialized views.
+ // Dump materialized views
for _, mtView := range schema.GetMaterializedViews() {
mtViewDDL, err := genMaterializedViewDDL(&MaterializedViewDDLOptions{
databaseName: databaseName,
@@ -157,30 +162,40 @@ func (d *Driver) Dump(ctx context.Context, out io.Writer, _ *storepb.DatabaseSch
return nil
}
-// This function shows DDLs for creating certain type of schema [VIEW, DATABASE, TABLE].
-func showCreateDDL(ctx context.Context, conn *gohive.Connection, objectType string, objectName string) (string, error) {
+func (d *Driver) showCreateDDL(ctx context.Context, objectType string, objectName string) (string, error) {
objectName = fmt.Sprintf("`%s`", objectName)
- // 'SHOW CREATE TABLE' can also be used for dumping views.
+ // 'SHOW CREATE TABLE' can also be used for dumping views
stmt := fmt.Sprintf("SHOW CREATE %s %s", objectType, objectName)
if objectType == "VIEW" {
stmt = fmt.Sprintf("SHOW CREATE TABLE %s", objectName)
}
- schemaDDLResult, err := queryStatement(ctx, conn, stmt)
+ rows, err := d.db.QueryContext(ctx, stmt)
if err != nil {
- return "", err
+ return "", errors.Wrapf(err, "failed to execute %s", stmt)
}
+ defer rows.Close()
- var schemaDDL string
- for _, row := range schemaDDLResult.Rows {
- if row == nil || len(row.Values) == 0 {
- return "", errors.New("empty row")
+ var schemaDDL strings.Builder
+ for rows.Next() {
+ var ddlLine string
+ if err := rows.Scan(&ddlLine); err != nil {
+ return "", errors.Wrap(err, "failed to scan DDL row")
}
- schemaDDL += fmt.Sprintln(row.Values[0].GetStringValue())
+ schemaDDL.WriteString(ddlLine)
+ schemaDDL.WriteString("\n")
+ }
+
+ if err := rows.Err(); err != nil {
+ return "", errors.Wrap(err, "error reading DDL rows")
+ }
+
+ if schemaDDL.Len() == 0 {
+ return "", errors.New("empty DDL result")
}
- return fmt.Sprintf(schemaStmtFmt, objectType, objectName, schemaDDL), nil
+ return fmt.Sprintf(schemaStmtFmt, objectType, objectName, schemaDDL.String()), nil
}
func genIndexDDL(opts *IndexDDLOptions) (string, error) {
diff --git a/backend/plugin/db/hive/hive.go b/backend/plugin/db/hive/hive.go
index d150f008b2..b36ec1d06c 100644
--- a/backend/plugin/db/hive/hive.go
+++ b/backend/plugin/db/hive/hive.go
@@ -8,9 +8,9 @@ import (
"strings"
"time"
- "github.com/beltran/gohive"
+ // Import gohive v2 driver for database/sql registration.
+ _ "github.com/beltran/gohive/v2"
"github.com/pkg/errors"
- "go.uber.org/multierr"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/types/known/durationpb"
"google.golang.org/protobuf/types/known/structpb"
@@ -36,74 +36,109 @@ func init() {
}
type Driver struct {
- config db.ConnectionConfig
- ctx db.ConnectionContext
- conn *gohive.Connection
+ config db.ConnectionConfig
+ ctx db.ConnectionContext
+ db *sql.DB
+ connString string
}
var (
_ db.Driver = (*Driver)(nil)
)
+func buildHiveDSN(config db.ConnectionConfig) string {
+ port := config.DataSource.Port
+ if port == "" {
+ port = "10000" // default Hive port
+ }
+
+ // Basic DSN format: hive://host:port/database
+ dsn := fmt.Sprintf("hive://%s:%s", config.DataSource.Host, port)
+
+ // Add database if specified
+ if config.ConnectionContext.DatabaseName != "" {
+ dsn = fmt.Sprintf("%s/%s", dsn, config.ConnectionContext.DatabaseName)
+ }
+
+ // Add authentication parameters
+ auth := "NONE"
+ service := "hive"
+
+ if t, ok := config.DataSource.GetSaslConfig().GetMechanism().(*storepb.SASLConfig_KrbConfig); ok {
+ auth = "KERBEROS"
+ if t.KrbConfig.Primary != "" {
+ service = t.KrbConfig.Primary
+ }
+ }
+
+ dsn = fmt.Sprintf("%s?auth=%s&service=%s", dsn, auth, service)
+
+ return dsn
+}
+
func (d *Driver) Open(ctx context.Context, _ storepb.Engine, config db.ConnectionConfig) (db.Driver, error) {
if config.DataSource.Host == "" {
return nil, errors.Errorf("hostname not set")
}
- d.config = config
- d.ctx = config.ConnectionContext
-
- port, err := strconv.Atoi(config.DataSource.Port)
- if err != nil {
- return nil, errors.Errorf("conversion failure for 'port' [string -> int]")
- }
+ // Build DSN connection string
+ connString := buildHiveDSN(config)
- var authConnParam = "NONE"
- hiveConfig := gohive.NewConnectConfiguration()
+ // Handle Kerberos authentication if needed
if t, ok := config.DataSource.GetSaslConfig().GetMechanism().(*storepb.SASLConfig_KrbConfig); ok {
- // Kerberos environment mutex.
+ // Kerberos environment mutex
util.Lock.Lock()
defer util.Lock.Unlock()
- hiveConfig.Hostname = t.KrbConfig.Instance
- hiveConfig.Service = t.KrbConfig.Primary
if err := util.BootKerberosEnv(t); err != nil {
return nil, errors.Wrapf(err, "failed to init SASL environment")
}
- authConnParam = "KERBEROS"
}
- conn, err := gohive.Connect(config.DataSource.Host, port, authConnParam, hiveConfig)
+ // Open database connection using v2 driver
+ sqlDB, err := sql.Open("hive", connString)
if err != nil {
- return nil, err
+ return nil, errors.Wrap(err, "failed to open hive connection")
}
- d.conn = conn
- if config.ConnectionContext.DatabaseName != "" {
- cursor := d.conn.Cursor()
- if err := executeCursor(ctx, cursor, fmt.Sprintf("use %s", config.ConnectionContext.DatabaseName)); err != nil {
- return nil, multierr.Combine(d.conn.Close(), err)
- }
+ // Configure connection pool (Hive doesn't support many concurrent connections well)
+ sqlDB.SetMaxOpenConns(5)
+ sqlDB.SetMaxIdleConns(2)
+ sqlDB.SetConnMaxLifetime(0) // connections don't expire
+
+ // Verify connection works
+ if err := sqlDB.PingContext(ctx); err != nil {
+ sqlDB.Close()
+ return nil, errors.Wrap(err, "failed to ping hive server")
}
+
+ d.config = config
+ d.ctx = config.ConnectionContext
+ d.db = sqlDB
+ d.connString = connString
+
return d, nil
}
func (d *Driver) Close(_ context.Context) error {
- return d.conn.Close()
+ if d.db != nil {
+ return d.db.Close()
+ }
+ return nil
}
func (d *Driver) Ping(ctx context.Context) error {
- cursor := d.conn.Cursor()
- defer cursor.Close()
-
- if err := executeCursor(ctx, cursor, "SELECT 1"); err != nil {
+ if d.db == nil {
+ return errors.New("connection not initialized")
+ }
+ if err := d.db.PingContext(ctx); err != nil {
return errors.Wrapf(err, "bad connection")
}
return nil
}
-func (*Driver) GetDB() *sql.DB {
- return nil
+func (d *Driver) GetDB() *sql.DB {
+ return d.db
}
// Transaction statements [BEGIN, COMMIT, ROLLBACK] are not supported in Hive 4.0 temporarily.
@@ -117,29 +152,37 @@ func (d *Driver) Execute(ctx context.Context, statementsStr string, _ db.Execute
// Due to these limitations, we execute statements individually regardless of transaction mode
// but we still parse and respect the transaction mode directive for consistency
- var affectedRows int64
-
- cursor := d.conn.Cursor()
- defer cursor.Close()
+ if d.db == nil {
+ return 0, errors.New("connection not initialized")
+ }
statements, err := base.SplitMultiSQL(storepb.Engine_HIVE, statementsStr)
if err != nil {
return 0, errors.Wrapf(err, "failed to split statements")
}
+ var totalAffected int64
for _, statement := range statements {
query := strings.TrimRight(statement.Text, ";")
- if err := executeCursor(ctx, cursor, query); err != nil {
- return 0, err
+
+ result, err := d.db.ExecContext(ctx, query)
+ if err != nil {
+ return totalAffected, errors.Wrapf(err, "failed to execute statement: %s", query)
}
- operationStatus := cursor.Poll(false)
- affectedRows += operationStatus.GetNumModifiedRows()
+
+ // Hive may not always return accurate row counts
+ affected, _ := result.RowsAffected()
+ totalAffected += affected
}
- return affectedRows, nil
+ return totalAffected, nil
}
func (d *Driver) QueryConn(ctx context.Context, _ *sql.Conn, statement string, queryCtx db.QueryContext) ([]*v1pb.QueryResult, error) {
+ if d.db == nil {
+ return nil, errors.New("connection not initialized")
+ }
+
singleSQLs, err := base.SplitMultiSQL(storepb.Engine_HIVE, statement)
if err != nil {
return nil, errors.Wrapf(err, "failed to split statements")
@@ -152,7 +195,7 @@ func (d *Driver) QueryConn(ctx context.Context, _ *sql.Conn, statement string, q
statement = fmt.Sprintf("EXPLAIN %s", statement)
}
- result, err := queryStatementWithLimit(ctx, d.conn, statement, queryCtx.MaximumSQLResultSize)
+ result, err := d.queryStatementWithLimit(ctx, statement, queryCtx.MaximumSQLResultSize)
if err != nil {
return nil, err
}
@@ -167,83 +210,119 @@ func parseValueType(value any, gohiveType string) *v1pb.RowValue {
if value == nil {
return &v1pb.RowValue{Kind: &v1pb.RowValue_NullValue{NullValue: structpb.NullValue_NULL_VALUE}}
}
+
+ // database/sql returns values as []byte or various Go types
+ // We need to handle both the type name and the actual Go type
switch gohiveType {
- case "BOOLEAN_TYPE":
- return &v1pb.RowValue{Kind: &v1pb.RowValue_BoolValue{BoolValue: value.(bool)}}
- case "TINYINT_TYPE":
- return &v1pb.RowValue{Kind: &v1pb.RowValue_Int32Value{Int32Value: int32(value.(int8))}}
- case "SMALLINT_TYPE":
- return &v1pb.RowValue{Kind: &v1pb.RowValue_Int32Value{Int32Value: int32(value.(int16))}}
- case "INT_TYPE":
- return &v1pb.RowValue{Kind: &v1pb.RowValue_Int32Value{Int32Value: value.(int32)}}
- case "BIGINT_TYPE":
- return &v1pb.RowValue{Kind: &v1pb.RowValue_Int64Value{Int64Value: value.(int64)}}
- case "DOUBLE_TYPE", "FLOAT_TYPE":
- // convert float64 to string to avoid truncation, because our v1pb.RowValue_FloatValue is float32.
- return &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: strconv.FormatFloat(value.(float64), 'f', 20, 64)}}
- case "BINARY_TYPE":
- return &v1pb.RowValue{Kind: &v1pb.RowValue_BytesValue{BytesValue: value.([]byte)}}
+ case "BOOLEAN_TYPE", "BOOLEAN":
+ if b, ok := value.(bool); ok {
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_BoolValue{BoolValue: b}}
+ }
+ case "TINYINT_TYPE", "TINYINT":
+ if i, ok := value.(int64); ok {
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_Int32Value{Int32Value: int32(i)}}
+ }
+ case "SMALLINT_TYPE", "SMALLINT":
+ if i, ok := value.(int64); ok {
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_Int32Value{Int32Value: int32(i)}}
+ }
+ case "INT_TYPE", "INT":
+ if i, ok := value.(int64); ok {
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_Int32Value{Int32Value: int32(i)}}
+ }
+ case "BIGINT_TYPE", "BIGINT":
+ if i, ok := value.(int64); ok {
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_Int64Value{Int64Value: i}}
+ }
+ case "DOUBLE_TYPE", "DOUBLE", "FLOAT_TYPE", "FLOAT":
+ if f, ok := value.(float64); ok {
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: strconv.FormatFloat(f, 'f', 20, 64)}}
+ }
+ case "BINARY_TYPE", "BINARY":
+ if b, ok := value.([]byte); ok {
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_BytesValue{BytesValue: b}}
+ }
default:
- // convert all remaining types to string.
- return &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: value.(string)}}
+ // Fall through to default string conversion
}
-}
-func queryStatement(ctx context.Context, conn *gohive.Connection, statement string) (*v1pb.QueryResult, error) {
- return queryStatementWithLimit(ctx, conn, statement, 0)
+ // Default: convert to string
+ // database/sql often returns values as []byte for string types
+ switch v := value.(type) {
+ case []byte:
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: string(v)}}
+ case string:
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: v}}
+ case int64:
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: strconv.FormatInt(v, 10)}}
+ case float64:
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: strconv.FormatFloat(v, 'f', -1, 64)}}
+ case bool:
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: strconv.FormatBool(v)}}
+ default:
+ return &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: fmt.Sprintf("%v", v)}}
+ }
}
-func queryStatementWithLimit(ctx context.Context, conn *gohive.Connection, statement string, limit int64) (*v1pb.QueryResult, error) {
+func (d *Driver) queryStatementWithLimit(ctx context.Context, statement string, limit int64) (*v1pb.QueryResult, error) {
startTime := time.Now()
- cursor := conn.Cursor()
- defer cursor.Close()
-
- // run query.
- if err := executeCursor(ctx, cursor, statement); err != nil {
- return nil, err
+ rows, err := d.db.QueryContext(ctx, statement)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to execute query")
}
+ defer rows.Close()
result := &v1pb.QueryResult{
Statement: statement,
}
- // We will get an error when a certain statement doesn't need returned results.
- for _, row := range cursor.Description() {
- if len(row) == 0 {
- return nil, errors.New("description row has zero length")
- }
- result.ColumnNames = append(result.ColumnNames, row[0])
- result.ColumnTypeNames = append(result.ColumnTypeNames, row[1])
+ // Get column information
+ columnTypes, err := rows.ColumnTypes()
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to get column types")
+ }
+
+ for _, col := range columnTypes {
+ result.ColumnNames = append(result.ColumnNames, col.Name())
+ result.ColumnTypeNames = append(result.ColumnTypeNames, col.DatabaseTypeName())
}
- // process query results.
- for cursor.HasMore(ctx) {
+ // Prepare value holders for scanning
+ numColumns := len(columnTypes)
+ values := make([]any, numColumns)
+ valuePtrs := make([]any, numColumns)
+ for i := range values {
+ valuePtrs[i] = &values[i]
+ }
+
+ // Process query results
+ for rows.Next() {
+ if err := rows.Scan(valuePtrs...); err != nil {
+ return nil, errors.Wrap(err, "failed to scan row")
+ }
+
queryRow := &v1pb.QueryRow{}
- rowMap := cursor.RowMap(ctx)
- for i, columnName := range result.ColumnNames {
- columnType := result.ColumnTypeNames[i]
- val := parseValueType(rowMap[columnName], columnType)
+ for i, columnType := range result.ColumnTypeNames {
+ val := parseValueType(values[i], columnType)
queryRow.Values = append(queryRow.Values, val)
}
- // Rows.
result.Rows = append(result.Rows, queryRow)
+
+ // Check size limit
n := len(result.Rows)
if (n&(n-1) == 0) && limit > 0 && int64(proto.Size(result)) > limit {
result.Error = common.FormatMaximumSQLResultSizeMessage(limit)
break
}
}
+
+ if err := rows.Err(); err != nil {
+ return nil, errors.Wrap(err, "error iterating rows")
+ }
+
result.Latency = durationpb.New(time.Since(startTime))
result.RowsCount = int64(len(result.Rows))
return result, nil
}
-
-func executeCursor(ctx context.Context, cursor *gohive.Cursor, statement string) error {
- cursor.Exec(ctx, statement)
- if cursor.Err != nil {
- return errors.Wrap(cursor.Err, "failed to execute statement")
- }
- return nil
-}
diff --git a/backend/plugin/db/hive/sync.go b/backend/plugin/db/hive/sync.go
index 78756fa353..698df05ec7 100644
--- a/backend/plugin/db/hive/sync.go
+++ b/backend/plugin/db/hive/sync.go
@@ -56,7 +56,7 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetad
}
func (d *Driver) getVersion(ctx context.Context) (string, error) {
- result, err := queryStatement(ctx, d.conn, "SELECT VERSION()")
+ result, err := d.queryStatementWithLimit(ctx, "SELECT VERSION()", 0)
if err != nil {
return "", errors.Wrap(err, "failed to get version from instance")
}
@@ -75,7 +75,7 @@ func (d *Driver) getVersion(ctx context.Context) (string, error) {
func (d *Driver) getDatabaseNames(ctx context.Context) ([]string, error) {
var databaseNames []string
- result, err := queryStatement(ctx, d.conn, "SHOW DATABASES")
+ result, err := d.queryStatementWithLimit(ctx, "SHOW DATABASES", 0)
if err != nil {
return nil, errors.Wrap(err, "failed to get version from instance")
}
@@ -89,7 +89,7 @@ func (d *Driver) getDatabaseNames(ctx context.Context) ([]string, error) {
}
func (d *Driver) listTablesNames(ctx context.Context, databaseName string) ([]string, error) {
- result, err := queryStatement(ctx, d.conn, fmt.Sprintf("SHOW TABLES FROM %s", databaseName))
+ result, err := d.queryStatementWithLimit(ctx, fmt.Sprintf("SHOW TABLES FROM %s", databaseName), 0)
if err != nil {
return nil, errors.Wrap(err, "failed to get version from instance")
}
@@ -182,7 +182,7 @@ func (d *Driver) getTables(ctx context.Context, databaseName string) (
func (d *Driver) getPartitions(ctx context.Context, databaseName, tableName string) ([]*storepb.TablePartitionMetadata, error) {
// partitions.
- partitionResult, err := queryStatement(ctx, d.conn, fmt.Sprintf("SHOW PARTITIONS `%s`.`%s`", databaseName, tableName))
+ partitionResult, err := d.queryStatementWithLimit(ctx, fmt.Sprintf("SHOW PARTITIONS `%s`.`%s`", databaseName, tableName), 0)
if err != nil {
slog.Debug("failed to get partitions", log.BBError(err))
return nil, nil
@@ -241,25 +241,18 @@ func (d *Driver) getTableInfo(ctx context.Context, tableName string, databaseNam
) {
tableInfo := &TableInfo{}
- cursor := d.conn.Cursor()
query := fmt.Sprintf("DESCRIBE FORMATTED `%s`.`%s`", databaseName, tableName)
- if err := executeCursor(ctx, cursor, query); err != nil {
+ rows, err := d.db.QueryContext(ctx, query)
+ if err != nil {
return nil, errors.Wrapf(err, "failed to describe table %s", tableName)
}
+ defer rows.Close()
section := columnSection
- for cursor.HasMore(ctx) {
- rowMap := cursor.RowMap(ctx)
+ for rows.Next() {
var colName, dataType, comment string
- colNameVal, dataTypeVal, commentVal := rowMap["col_name"], rowMap["data_type"], rowMap["comment"]
- if v, ok := colNameVal.(string); ok {
- colName = v
- }
- if v, ok := dataTypeVal.(string); ok {
- dataType = v
- }
- if v, ok := commentVal.(string); ok {
- comment = v
+ if err := rows.Scan(&colName, &dataType, &comment); err != nil {
+ return nil, errors.Wrap(err, "failed to scan row")
}
// The first rows are column metadata, followed by "# Detailed Table Information" and "# Storage Information"
@@ -277,7 +270,7 @@ func (d *Driver) getTableInfo(ctx context.Context, tableName string, databaseNam
}
switch section {
case columnSection:
- if colNameVal != nil && dataTypeVal != nil && colName != "" && dataType != "" {
+ if colName != "" && dataType != "" {
// Column metadata.
position := len(tableInfo.colMetadatas) + 1
tableInfo.colMetadatas = append(tableInfo.colMetadatas, &storepb.ColumnMetadata{
@@ -322,6 +315,10 @@ func (d *Driver) getTableInfo(ctx context.Context, tableName string, databaseNam
}
}
+ if err := rows.Err(); err != nil {
+ return nil, errors.Wrap(err, "error iterating rows")
+ }
+
return tableInfo, nil
}
diff --git a/go.mod b/go.mod
index f107c36b03..99c13d23b4 100644
--- a/go.mod
+++ b/go.mod
@@ -28,7 +28,7 @@ require (
github.com/aws/aws-sdk-go-v2/credentials v1.19.7
github.com/aws/aws-sdk-go-v2/feature/rds/auth v1.6.17
github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.41.1
- github.com/beltran/gohive v1.8.1
+ github.com/beltran/gohive/v2 v2.0.0
github.com/blang/semver/v4 v4.0.0
github.com/bmatcuk/doublestar/v4 v4.9.2
github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0
@@ -167,7 +167,6 @@ require (
github.com/go-asn1-ber/asn1-ber v1.5.8-0.20250403174932-29230038a667 // indirect
github.com/go-logr/logr v1.4.3 // indirect
github.com/go-logr/stdr v1.2.2 // indirect
- github.com/go-zookeeper/zk v1.0.4 // indirect
github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 // indirect
github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect
github.com/golang/geo v0.0.0-20210211234256-740aa86cb551 // indirect
@@ -382,9 +381,6 @@ replace (
github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos => github.com/bytebase/azure-sdk-for-go/sdk/data/azcosmos v0.0.0-20250109032656-87cf24d45689
github.com/antlr4-go/antlr/v4 => github.com/bytebase/antlr/v4 v4.0.0-20240827034948-8c385f108920
- // Hive fix.
- github.com/beltran/gohive => github.com/bytebase/gohive v0.0.0-20240422092929-d76993a958a4
- github.com/beltran/gosasl => github.com/bytebase/gosasl v0.0.0-20240422091407-6b7481e86f08
// copied from pingcap/tidb
// fix potential security issue(CVE-2020-26160) introduced by indirect dependency.
diff --git a/go.sum b/go.sum
index debbd0cfb6..ee878f78da 100644
--- a/go.sum
+++ b/go.sum
@@ -815,6 +815,10 @@ github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPn
github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
github.com/bazelbuild/rules_go v0.49.0 h1:5vCbuvy8Q11g41lseGJDc5vxhDjJtfxr6nM/IC4VmqM=
github.com/bazelbuild/rules_go v0.49.0/go.mod h1:Dhcz716Kqg1RHNWos+N6MlXNkjNP2EwZQ0LukRKJfMs=
+github.com/beltran/gohive/v2 v2.0.0 h1:Rb7d33EwaG1mc2Cl014x3Mh5RGTNxmKd652gCXzVw5c=
+github.com/beltran/gohive/v2 v2.0.0/go.mod h1:MrxyI0sdriG52I+Bo2lJpGR75bxjcI/Hx3+MBnYqR10=
+github.com/beltran/gosasl v1.0.0 h1:iiRtLxkvKhrNv3Ohh/n2NiyyfwIo/UbMzy/dZWiUHXE=
+github.com/beltran/gosasl v1.0.0/go.mod h1:Qx8cW6jkI8riyzmklj80kAIkv+iezFUTBiGU0qHhHes=
github.com/beltran/gssapi v0.0.0-20200324152954-d86554db4bab h1:ayfcn60tXOSYy5zUN1AMSTQo4nJCf7hrdzAVchpPst4=
github.com/beltran/gssapi v0.0.0-20200324152954-d86554db4bab/go.mod h1:GLe4UoSyvJ3cVG+DVtKen5eAiaD8mAJFuV5PT3Eeg9Q=
github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
@@ -855,10 +859,6 @@ github.com/bytebase/gh-ost2 v1.1.7-0.20251002210738-35e5dddaad7c h1:scJ4ycKuUAaA
github.com/bytebase/gh-ost2 v1.1.7-0.20251002210738-35e5dddaad7c/go.mod h1:X0CGYwIZUnjfrv02/nBlftxqSBMm4mYJzFwiyn2D4d8=
github.com/bytebase/go-mssqldb v0.0.0-20240801091126-3ff3ca07d898 h1:0ggqA9XL4yvtePPvRDRYMed3jtdNk4s0o8AMW8uJPSA=
github.com/bytebase/go-mssqldb v0.0.0-20240801091126-3ff3ca07d898/go.mod h1:2KhUz4GSLcdJGXSJMXAf2BjmakcgoOkNyPpHdGAxRpY=
-github.com/bytebase/gohive v0.0.0-20240422092929-d76993a958a4 h1:5o+GWOu+j68eAODMw7/lFJavWCCiPMeqEHuOGx0YmoU=
-github.com/bytebase/gohive v0.0.0-20240422092929-d76993a958a4/go.mod h1:sV29Oj7v/xsXJjJwLRYimdnEX6aZOA1ofAlZ+D/snOo=
-github.com/bytebase/gosasl v0.0.0-20240422091407-6b7481e86f08 h1:S1GgjJLspz4E4z4CvomGvKgxyv0ATfZm27qHM418jWc=
-github.com/bytebase/gosasl v0.0.0-20240422091407-6b7481e86f08/go.mod h1:Qx8cW6jkI8riyzmklj80kAIkv+iezFUTBiGU0qHhHes=
github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0 h1:bJ8NSf2K+pccl5m/wuu97fiYjDwpJH6IzURAq/3XA2U=
github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0/go.mod h1:BEWMfiZtqshdmulKJcIsWb45MUaEvDO4CROcgi8dfFg=
github.com/bytebase/parser v0.0.0-20260113041207-12c6f17e2d8e h1:MtSRG2W59qJujPTbK8jUoQKJX4wLRYXJDWDOgtVa8kY=
@@ -1105,8 +1105,6 @@ github.com/go-test/deep v1.1.1 h1:0r/53hagsehfO4bzD2Pgr/+RgHqhmf+k1Bpse2cTu1U=
github.com/go-test/deep v1.1.1/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE=
github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
-github.com/go-zookeeper/zk v1.0.4 h1:DPzxraQx7OrPyXq2phlGlNSIyWEsAox0RJmjTseMV6I=
-github.com/go-zookeeper/zk v1.0.4/go.mod h1:nOB03cncLtlp4t+UAkGSV+9beXP/akpekBwL+UX1Qcw=
github.com/goccy/go-json v0.9.11/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=