* Merged internal/xsql/conn.{GetTables,GetAllTables} methods for DRY

* Replaced `internal/xsql.Connector.PathNormalizer` default from `nopPathNormalizer` to `bind.TablePathPrefix` with database name as path prefix

Author: asmyasnikov

CHANGELOG.md

@@ -1,3 +1,5 @@
+* Merged `internal/xsql/conn.{GetTables,GetAllTables}` methods for `DRY`
+* Replaced `internal/xsql.Connector.PathNormalizer` default from `nopPathNormalizer` to `bind.TablePathPrefix` with database name as path prefix
 * Supported placeholder "_" for ignored column names in `database/sql` result sets
 
 ## v3.52.0

internal/xsql/conn.go

@@ -613,108 +613,91 @@ func (c *conn) IsPrimaryKey(ctx context.Context, tableName, columnName string) (
 }
 
 func (c *conn) normalizePath(folderOrTable string) (absPath string) {
-	return c.connector.PathNormalizer.NormalizePath(folderOrTable)
+	return c.connector.pathNormalizer.NormalizePath(folderOrTable)
 }
 
-func (c *conn) GetTables(ctx context.Context, folder string) (tables []string, err error) {
-	absPath := c.normalizePath(folder)
-	var e scheme.Entry
+func isSysDir(databaseName, dirAbsPath string) bool {
+	for _, sysDir := range [...]string{
+		path.Join(databaseName, ".sys"),
+		path.Join(databaseName, ".sys_health"),
+	} {
+		if strings.HasPrefix(dirAbsPath, sysDir) {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *conn) getTables(ctx context.Context, absPath string, recursive, excludeSysDirs bool) (
+	tables []string, err error,
+) {
+	if excludeSysDirs && isSysDir(c.connector.parent.Name(), absPath) {
+		return nil, nil
+	}
+
+	var d scheme.Directory
 	err = retry.Retry(ctx, func(ctx context.Context) (err error) {
-		e, err = c.connector.parent.Scheme().DescribePath(ctx, absPath)
+		d, err = c.connector.parent.Scheme().ListDirectory(ctx, absPath)
 		return err
 	}, retry.WithIdempotent(true))
-
 	if err != nil {
 		return nil, xerrors.WithStackTrace(err)
 	}
 
-	switch {
-	case e.IsTable():
-		_, table := path.Split(absPath)
-		tables = append(tables, table)
-		return tables, nil
-	case e.IsDirectory():
-		var d scheme.Directory
-		err = retry.Retry(ctx, func(ctx context.Context) (err error) {
-			d, err = c.connector.parent.Scheme().ListDirectory(ctx, absPath)
-			return err
-		}, retry.WithIdempotent(true))
-
-		if err != nil {
-			return nil, xerrors.WithStackTrace(err)
-		}
+	if !d.IsDirectory() && !d.IsDatabase() {
+		return nil, xerrors.WithStackTrace(fmt.Errorf("'%s' is not a folder", absPath))
+	}
 
-		for i := range d.Children {
-			if d.Children[i].IsTable() {
-				tables = append(tables, d.Children[i].Name)
+	for i := range d.Children {
+		switch d.Children[i].Type {
+		case scheme.EntryTable, scheme.EntryColumnTable:
+			tables = append(tables, path.Join(absPath, d.Children[i].Name))
+		case scheme.EntryDirectory, scheme.EntryDatabase:
+			if recursive {
+				childTables, err := c.getTables(ctx, path.Join(absPath, d.Children[i].Name), recursive, excludeSysDirs)
+				if err != nil {
+					return nil, xerrors.WithStackTrace(err)
+				}
+				tables = append(tables, childTables...)
 			}
 		}
-		return tables, nil
-	default:
-		return nil, xerrors.WithStackTrace(fmt.Errorf("path '%s' should be a table or directory", folder))
 	}
+
+	return tables, nil
 }
 
-func (c *conn) GetAllTables(ctx context.Context, folder string) (tables []string, err error) {
-	folder = c.normalizePath(folder)
-	ignoreDirs := map[string]bool{
-		".sys":        true,
-		".sys_health": true,
-	}
+func (c *conn) GetTables(ctx context.Context, folder string, recursive, excludeSysDirs bool) (
+	tables []string, err error,
+) {
+	absPath := c.normalizePath(folder)
 
-	canEnter := func(dir string) bool {
-		if _, ignore := ignoreDirs[dir]; ignore {
-			return false
-		}
-		return true
+	var e scheme.Entry
+	err = retry.Retry(ctx, func(ctx context.Context) (err error) {
+		e, err = c.connector.parent.Scheme().DescribePath(ctx, absPath)
+		return err
+	}, retry.WithIdempotent(true))
+	if err != nil {
+		return nil, xerrors.WithStackTrace(err)
 	}
 
-	queue := make([]string, 0)
-	queue = append(queue, folder)
-
-	for st := 0; st < len(queue); st++ {
-		curPath := queue[st]
-
-		var e scheme.Entry
-		err = retry.Retry(ctx, func(ctx context.Context) (err error) {
-			e, err = c.connector.parent.Scheme().DescribePath(ctx, curPath)
-			return err
-		}, retry.WithIdempotent(true))
-
-		if err != nil {
-			return nil, xerrors.WithStackTrace(err)
-		}
-
-		if e.IsTable() {
-			switch curPath {
-			case folder:
-				_, table := path.Split(curPath)
-				tables = append(tables, table)
-			default:
-				tables = append(tables, strings.TrimPrefix(curPath, folder+"/"))
-			}
-			continue
-		}
-
-		var d scheme.Directory
-		err = retry.Retry(ctx, func(ctx context.Context) (err error) {
-			d, err = c.connector.parent.Scheme().ListDirectory(ctx, curPath)
-			return err
-		}, retry.WithIdempotent(true))
-
+	switch e.Type {
+	case scheme.EntryTable, scheme.EntryColumnTable:
+		return []string{e.Name}, err
+	case scheme.EntryDirectory, scheme.EntryDatabase:
+		tables, err = c.getTables(ctx, absPath, recursive, excludeSysDirs)
 		if err != nil {
 			return nil, xerrors.WithStackTrace(err)
 		}
 
-		for i := range d.Children {
-			if d.Children[i].IsDirectory() || d.Children[i].IsTable() {
-				if canEnter(d.Children[i].Name) {
-					queue = append(queue, path.Join(curPath, d.Children[i].Name))
-				}
-			}
+		for i := range tables {
+			tables[i] = strings.TrimPrefix(tables[i], absPath+"/")
 		}
+		return tables, nil
+	default:
+		return nil, xerrors.WithStackTrace(
+			fmt.Errorf("'%s' is not a table or directory (%s)", folder, e.Type.String()),
+		)
 	}
-	return tables, nil
 }
 
 func (c *conn) GetIndexes(ctx context.Context, tableName string) (indexes []string, err error) {

internal/xsql/conn_test.go

@@ -38,11 +38,7 @@ var (
 	} = (*conn)(nil)
 
 	_ interface {
-		GetTables(ctx context.Context, absPath string) (tables []string, err error)
-	} = (*conn)(nil)
-
-	_ interface {
-		GetAllTables(ctx context.Context, absPath string) (tables []string, err error)
+		GetTables(ctx context.Context, folder string, recursive bool, excludeSysDirs bool) (tables []string, err error)
 	} = (*conn)(nil)
 
 	_ interface {

internal/xsql/connector.go

@@ -52,7 +52,7 @@ type tablePathPrefixConnectorOption struct {
 
 func (o tablePathPrefixConnectorOption) Apply(c *Connector) error {
 	c.Bindings = bind.Sort(append(c.Bindings, o.TablePathPrefix))
-	c.PathNormalizer = o.TablePathPrefix
+	c.pathNormalizer = o.TablePathPrefix
 	return nil
 }
 
@@ -169,20 +169,14 @@ type ydbDriver interface {
 	Scheme() scheme.Client
 }
 
-type nopPathNormalizer struct{}
-
-func (nopPathNormalizer) NormalizePath(_ string) string {
-	return tablePathPrefixTransformer
-}
-
 func Open(parent ydbDriver, opts ...ConnectorOption) (_ *Connector, err error) {
 	c := &Connector{
 		parent:           parent,
 		clock:            clockwork.NewRealClock(),
 		conns:            make(map[*conn]struct{}),
 		defaultTxControl: table.DefaultTxControl(),
 		defaultQueryMode: DefaultQueryMode,
-		PathNormalizer:   nopPathNormalizer{},
+		pathNormalizer:   bind.TablePathPrefix(parent.Name()),
 		trace:            &trace.DatabaseSQL{},
 	}
 	for _, opt := range opts {
@@ -209,7 +203,7 @@ type Connector struct {
 	clock clockwork.Clock
 
 	Bindings       bind.Bindings
-	PathNormalizer pathNormalizer
+	pathNormalizer pathNormalizer
 
 	fakeTxModes []QueryMode