Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
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.goindex 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.BuilderdatabaseName := 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 tablesfor _, 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 indexesfor _, 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 tablesfor _, 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 viewsfor _, 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 viewsfor _, 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.DatabaseSchreturn 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 viewsstmt := 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.goindex 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 neededif t, ok := config.DataSource.GetSaslConfig().GetMechanism().(*storepb.SASLConfig_KrbConfig); ok {- // Kerberos environment mutex.+ // Kerberos environment mutexutil.Lock.Lock()defer util.Lock.Unlock()- hiveConfig.Hostname = t.KrbConfig.Instance- hiveConfig.Service = t.KrbConfig.Primaryif 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 int64for _, 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, qstatement = 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 typeswitch 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 limitn := 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.goindex 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) + 1tableInfo.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.modindex f107c36b03..99c13d23b4 100644--- a/go.mod+++ b/go.mod@@ -28,7 +28,7 @@ require (github.com/aws/aws-sdk-go-v2/credentials v1.19.7github.com/aws/aws-sdk-go-v2/feature/rds/auth v1.6.17github.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.0github.com/blang/semver/v4 v4.0.0github.com/bmatcuk/doublestar/v4 v4.9.2github.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 // indirectgithub.com/go-logr/logr v1.4.3 // indirectgithub.com/go-logr/stdr v1.2.2 // indirect- github.com/go-zookeeper/zk v1.0.4 // indirectgithub.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 // indirectgithub.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirectgithub.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-87cf24d45689github.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.sumindex 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+iNdMDXrh3z3nPngithub.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:scJ4ycKuUAaAgithub.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=