add visible to index

Author: chenhuiyeh

schema/schema.go

@@ -60,6 +60,7 @@ type Index struct {
 	Columns     []string
 	Cardinality []uint64
 	NoneUnique  uint64
+	Visible     bool
 }
 
 type Table struct {
@@ -209,7 +210,7 @@ func (ta *Table) AddIndex(name string) (index *Index) {
 }
 
 func NewIndex(name string) *Index {
-	return &Index{name, make([]string, 0, 8), make([]uint64, 0, 8), 0}
+	return &Index{name, make([]string, 0, 8), make([]uint64, 0, 8), 0, true}
 }
 
 func (idx *Index) AddColumn(name string, cardinality uint64) {
@@ -319,6 +320,23 @@ func (ta *Table) fetchColumnsViaSqlDB(conn *sql.DB) error {
 	return r.Err()
 }
 
+func hasInvisibleIndexSupport(conn mysql.Executer) bool {
+	if eq, err := conn.CompareServerVersion("8.0.0"); err == nil && eq >= 0 {
+		return true
+	}
+	return false
+}
+
+func hasInvisibleIndexSupportSqlDB(conn *sql.DB) bool {
+	versionQuery := "SELECT VERSION()"
+	var version string
+	err := conn.QueryRow(versionQuery).Scan(&version)
+	if err == nil && strings.HasPrefix(version, "8.") {
+		return true
+	}
+	return false
+}
+
 func (ta *Table) fetchIndexes(conn mysql.Executer) error {
 	r, err := conn.Execute(fmt.Sprintf("show index from `%s`.`%s`", ta.Schema, ta.Name))
 	if err != nil {
@@ -327,6 +345,8 @@ func (ta *Table) fetchIndexes(conn mysql.Executer) error {
 	var currentIndex *Index
 	currentName := ""
 
+	hasInvisibleIndex := hasInvisibleIndexSupport(conn)
+
 	for i := 0; i < r.RowNumber(); i++ {
 		indexName, _ := r.GetString(i, 2)
 		if currentName != indexName {
@@ -337,6 +357,14 @@ func (ta *Table) fetchIndexes(conn mysql.Executer) error {
 		colName, _ := r.GetString(i, 4)
 		currentIndex.AddColumn(colName, cardinality)
 		currentIndex.NoneUnique, _ = r.GetUint(i, 1)
+
+		// Only set to false if explicitly marked as invisible
+		if hasInvisibleIndex {
+			visible, _ := r.GetString(i, 10)
+			if visible == "NO" {
+				currentIndex.Visible = false
+			}
+		}
 	}
 
 	return ta.fetchPrimaryKeyColumns()
@@ -355,11 +383,14 @@ func (ta *Table) fetchIndexesViaSqlDB(conn *sql.DB) error {
 
 	var unusedVal interface{}
 
+	hasInvisibleIndex := hasInvisibleIndexSupportSqlDB(conn)
+
 	for r.Next() {
 		var indexName string
 		var colName sql.NullString
 		var noneUnique uint64
 		var cardinality interface{}
+		var visible sql.NullString
 		cols, err := r.Columns()
 		if err != nil {
 			return errors.Trace(err)
@@ -375,6 +406,8 @@ func (ta *Table) fetchIndexesViaSqlDB(conn *sql.DB) error {
 				values[i] = &colName
 			case 6:
 				values[i] = &cardinality
+			case 10:
+				values[i] = &visible
 			default:
 				values[i] = &unusedVal
 			}
@@ -397,6 +430,11 @@ func (ta *Table) fetchIndexesViaSqlDB(conn *sql.DB) error {
 			currentIndex.AddColumn("", c)
 		}
 		currentIndex.NoneUnique = noneUnique
+
+		// Only set to false if explicitly marked as invisible
+		if hasInvisibleIndex && visible.Valid && visible.String == "NO" {
+			currentIndex.Visible = false
+		}
 	}
 
 	return ta.fetchPrimaryKeyColumns()

schema/schema_test.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"flag"
 	"fmt"
+	"strings"
 	"testing"
 
 	"github.com/go-mysql-org/go-mysql/client"
@@ -174,3 +175,50 @@ func (s *schemaTestSuite) TestSchemaWithMultiValueIndex() {
 
 	require.Equal(s.T(), ta, taSqlDb)
 }
+
+// func (s *schemaTestSuite) TestSchemaWithInvisibleIndex() {
+// 	_, err := s.conn.Execute(`DROP TABLE IF EXISTS invisible_idx_test`)
+// 	require.NoError(s.T(), err)
+
+// 	// Check MySQL version
+// 	hasInvisibleIndex := false
+// 	if eq, err := s.conn.CompareServerVersion("8.0.0"); err == nil && eq >= 0 {
+// 		hasInvisibleIndex = true
+// 	}
+
+// 	str := `
+//         CREATE TABLE IF NOT EXISTS invisible_idx_test (
+//             id INT,
+//             name VARCHAR(256),
+//             PRIMARY KEY(id),
+//             INDEX name_idx (name)
+//         ) ENGINE = INNODB;
+//     `
+
+// 	// Add INVISIBLE keyword only for MySQL 8.0+
+// 	if hasInvisibleIndex {
+// 		str = strings.Replace(str, "INDEX name_idx (name)", "INDEX name_idx (name) INVISIBLE", 1)
+// 	}
+
+// 	_, err = s.conn.Execute(str)
+// 	require.NoError(s.T(), err)
+
+// 	ta, err := NewTable(s.conn, *schema, "invisible_idx_test")
+// 	require.NoError(s.T(), err)
+
+// 	require.Len(s.T(), ta.Indexes, 2)
+// 	require.Equal(s.T(), "PRIMARY", ta.Indexes[0].Name)
+// 	require.True(s.T(), ta.Indexes[0].Visible)
+// 	require.Equal(s.T(), "name_idx", ta.Indexes[1].Name)
+
+// 	if hasInvisibleIndex {
+// 		require.False(s.T(), ta.Indexes[1].Visible)
+// 	} else {
+// 		require.True(s.T(), ta.Indexes[1].Visible)
+// 	}
+
+// 	taSqlDb, err := NewTableFromSqlDB(s.sqlDB, *schema, "invisible_idx_test")
+// 	require.NoError(s.T(), err)
+
+// 	require.Equal(s.T(), ta, taSqlDb)
+// }