refactor: get views info from DESC SCHEMA instead of driver output

This changes the way information about views is obtained - it's more
reliable to use DESC SCHEMA output, then information from the gocql
driver.

Author: VAveryanov8

pkg/service/one2onerestore/worker_tgc.go

@@ -43,13 +43,9 @@ func (w *worker) setTombstoneGCModeRepair(ctx context.Context, workload []hostWo
 		return errors.Wrap(err, "get views")
 	}
 	for _, view := range views {
-		viewName := view.View
-		if view.Type == SecondaryIndex {
-			viewName += "_index"
-		}
 		targets = append(targets, alterTGCTarget{
 			keyspace: view.Keyspace,
-			name:     viewName,
+			name:     view.View,
 			isView:   true,
 		})
 	}

pkg/service/one2onerestore/worker_views.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	"github.com/scylladb/gocqlx/v2/qb"
 	"github.com/scylladb/scylla-manager/v3/pkg/metrics"
 	"github.com/scylladb/scylla-manager/v3/pkg/scyllaclient"
 	"github.com/scylladb/scylla-manager/v3/pkg/util/query"
@@ -71,71 +72,35 @@ func (w *worker) dropView(ctx context.Context, view View) error {
 }
 
 func (w *worker) getViews(ctx context.Context, workload []hostWorkload) ([]View, error) {
-	keyspaces, err := w.client.Keyspaces(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "get keyspaces")
-	}
-
-	describedViews, err := w.viewsSchemaByName(ctx, workload)
+	tablesToRestore := getTablesToRestore(workload)
+	views, err := w.viewsFromSchema(ctx, workload)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "get views from schema")
 	}
-
-	tablesToRestore := getTablesToRestore(workload)
-
-	var views []View
-	for _, ks := range keyspaces {
-		meta, err := w.clusterSession.KeyspaceMetadata(ks)
-		if err != nil {
-			return nil, errors.Wrapf(err, "get keyspace %s metadata", ks)
-		}
-
-		for _, index := range meta.Indexes {
-			if _, ok := tablesToRestore[scyllaTable{keyspace: index.KeyspaceName, table: index.TableName}]; !ok {
-				continue
-			}
-			stmt, ok := describedViews[scyllaTable{keyspace: index.KeyspaceName, table: index.Name + "_index"}]
-			if !ok {
-				continue
-			}
-			stmt, err = addIfNotExists(stmt, SecondaryIndex)
-			if err != nil {
-				return nil, err
-			}
-
-			views = append(views, View{
-				Keyspace:   index.KeyspaceName,
-				View:       index.Name,
-				Type:       SecondaryIndex,
-				BaseTable:  index.TableName,
-				CreateStmt: stmt,
-			})
+	result := make([]View, 0, len(views))
+	for _, view := range views {
+		if _, ok := tablesToRestore[scyllaTable{keyspace: view.Keyspace, table: view.BaseTable}]; !ok {
+			continue
 		}
+		result = append(result, view)
+	}
 
-		for _, view := range meta.Views {
-			if _, ok := tablesToRestore[scyllaTable{keyspace: view.KeyspaceName, table: view.BaseTableName}]; !ok {
-				continue
-			}
-			stmt, ok := describedViews[scyllaTable{keyspace: view.KeyspaceName, table: view.ViewName}]
-			if !ok {
-				continue
-			}
-			stmt, err = addIfNotExists(stmt, MaterializedView)
-			if err != nil {
-				return nil, err
-			}
+	return result, nil
+}
 
-			views = append(views, View{
-				Keyspace:   view.KeyspaceName,
-				View:       view.ViewName,
-				Type:       MaterializedView,
-				BaseTable:  view.BaseTableName,
-				CreateStmt: stmt,
-			})
-		}
+func (w *worker) getBaseTableName(keyspace, name string) (string, error) {
+	q := qb.Select("system_schema.views").
+		Columns("base_table_name").
+		Where(qb.Eq("keyspace_name"), qb.Eq("view_name")).
+		Query(w.clusterSession).
+		Bind(keyspace, name)
+	defer q.Release()
+	var baseTableName string
+	err := q.Scan(&baseTableName)
+	if err != nil {
+		return "", errors.Wrapf(err, "scan base table name for view %s.%s", keyspace, name)
 	}
-
-	return views, nil
+	return baseTableName, nil
 }
 
 var (
@@ -206,24 +171,19 @@ func (w *worker) createView(ctx context.Context, view View) error {
 // Scylla operation might take a really long (and difficult to estimate) time.
 // This func exits ONLY on: success, context cancel or error.
 func (w *worker) waitForViewBuilding(ctx context.Context, view View, pr *RunViewProgress) error {
-	viewTableName := view.View
-	if view.Type == SecondaryIndex {
-		viewTableName += "_index"
-	}
-
-	status, err := w.client.ViewBuildStatus(ctx, view.Keyspace, viewTableName)
+	status, err := w.client.ViewBuildStatus(ctx, view.Keyspace, view.View)
 	if err != nil {
 		return err
 	}
 
 	w.updateReCreateViewProgress(ctx, pr, status)
 	switch status {
 	case scyllaclient.StatusUnknown:
-		w.metrics.SetViewBuildStatus(w.runInfo.ClusterID, view.Keyspace, viewTableName, metrics.BuildStatusUnknown)
+		w.metrics.SetViewBuildStatus(w.runInfo.ClusterID, view.Keyspace, view.View, metrics.BuildStatusUnknown)
 	case scyllaclient.StatusStarted:
-		w.metrics.SetViewBuildStatus(w.runInfo.ClusterID, view.Keyspace, viewTableName, metrics.BuildStatusStarted)
+		w.metrics.SetViewBuildStatus(w.runInfo.ClusterID, view.Keyspace, view.View, metrics.BuildStatusStarted)
 	case scyllaclient.StatusSuccess:
-		w.metrics.SetViewBuildStatus(w.runInfo.ClusterID, view.Keyspace, viewTableName, metrics.BuildStatusSuccess)
+		w.metrics.SetViewBuildStatus(w.runInfo.ClusterID, view.Keyspace, view.View, metrics.BuildStatusSuccess)
 		return nil
 	}
 
@@ -245,7 +205,7 @@ func (w *worker) waitForViewBuilding(ctx context.Context, view View, pr *RunView
 	return nil
 }
 
-func (w *worker) viewsSchemaByName(ctx context.Context, workload []hostWorkload) (map[scyllaTable]string, error) {
+func (w *worker) viewsFromSchema(ctx context.Context, workload []hostWorkload) ([]View, error) {
 	// In order to ensure schema consistency, we need to call raft read barrier on a host
 	// from which we are going to read the schema.
 	host := workload[0].host
@@ -272,7 +232,7 @@ func (w *worker) viewsSchemaByName(ctx context.Context, workload []hostWorkload)
 	if err != nil {
 		return nil, errors.Wrap(err, "describe schema")
 	}
-	result := map[scyllaTable]string{}
+	var result []View
 	for _, stmt := range describedSchema {
 		if stmt.Keyspace == "" {
 			continue
@@ -281,7 +241,26 @@ func (w *worker) viewsSchemaByName(ctx context.Context, workload []hostWorkload)
 			continue
 		}
 
-		result[scyllaTable{keyspace: stmt.Keyspace, table: stmt.Name}] = stmt.CQLStmt
+		viewType := MaterializedView
+		if stmt.Type == "index" {
+			viewType = SecondaryIndex
+		}
+		baseTableName, err := w.getBaseTableName(stmt.Keyspace, stmt.Name)
+		if err != nil {
+			return nil, errors.Wrapf(err, "get base table name for view %s.%s", stmt.Keyspace, stmt.Name)
+		}
+		createStmt, err := addIfNotExists(stmt.CQLStmt, viewType)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, View{
+			Keyspace:    stmt.Keyspace,
+			View:        stmt.Name,
+			Type:        viewType,
+			BaseTable:   baseTableName,
+			CreateStmt:  createStmt,
+			BuildStatus: scyllaclient.StatusUnknown, // We don't know the build status yet.
+		})
 	}
 	return result, nil
 }