github.com/ydb-platform/ydb-go-sdk/v3@v3.89.2/tests/integration/database_sql_get_tables_test.go (about)

     1  //go:build integration
     2  // +build integration
     3  
     4  package integration
     5  
     6  import (
     7  	"context"
     8  	"database/sql"
     9  	"errors"
    10  	"path"
    11  	"sort"
    12  	"testing"
    13  
    14  	"github.com/stretchr/testify/require"
    15  
    16  	"github.com/ydb-platform/ydb-go-sdk/v3"
    17  	"github.com/ydb-platform/ydb-go-sdk/v3/retry"
    18  	"github.com/ydb-platform/ydb-go-sdk/v3/sugar"
    19  )
    20  
    21  func TestDatabaseSqlGetTables(t *testing.T) {
    22  	var (
    23  		scope  = newScope(t)
    24  		db     = scope.SQLDriverWithFolder()
    25  		folder = t.Name()
    26  	)
    27  
    28  	defer func() {
    29  		_ = db.Close()
    30  	}()
    31  
    32  	t.Run("prepare-sub-folder", func(t *testing.T) {
    33  		cc, err := ydb.Unwrap(db)
    34  		require.NoError(t, err)
    35  
    36  		err = sugar.MakeRecursive(scope.Ctx, cc, path.Join(folder, "subdir"))
    37  		require.NoError(t, err)
    38  	})
    39  
    40  	t.Run("create-tables", func(t *testing.T) {
    41  		err := retry.Do(scope.Ctx, db, func(ctx context.Context, cc *sql.Conn) (err error) {
    42  			_, err = cc.ExecContext(
    43  				ydb.WithQueryMode(ctx, ydb.SchemeQueryMode),
    44  				`CREATE TABLE episodes (
    45  				series_id Uint64,
    46  				season_id Uint64,
    47  				episode_id Uint64,
    48  				title UTF8,
    49  				air_date Date,
    50  				views Uint64,
    51  				PRIMARY KEY (
    52  					series_id,
    53  					season_id,
    54  					episode_id
    55  				)
    56  			)`,
    57  			)
    58  			if err != nil {
    59  				return err
    60  			}
    61  
    62  			_, err = cc.ExecContext(
    63  				ydb.WithQueryMode(ctx, ydb.SchemeQueryMode),
    64  				`
    65  			CREATE TABLE series (
    66  				series_id Uint64,
    67  				title UTF8,
    68  				series_info UTF8,
    69  				release_date Date,
    70  				comment UTF8,
    71  				PRIMARY KEY (
    72  					series_id
    73  				)
    74  			);`,
    75  			)
    76  			if err != nil {
    77  				return err
    78  			}
    79  
    80  			_, err = cc.ExecContext(
    81  				ydb.WithQueryMode(ctx, ydb.SchemeQueryMode),
    82  				`CREATE TABLE `+"`./subdir/seasons`"+` (
    83  				series_id Uint64,
    84  				season_id Uint64,
    85  				title UTF8,
    86  				first_aired Date,
    87  				last_aired Date,
    88  				PRIMARY KEY (
    89  					series_id,
    90  					season_id
    91  				)
    92  			)`,
    93  			)
    94  			if err != nil {
    95  				return err
    96  			}
    97  
    98  			return nil
    99  		}, retry.WithIdempotent(true))
   100  
   101  		require.NoError(t, err)
   102  	})
   103  
   104  	t.Run("get-tables-at-current-folder", func(t *testing.T) {
   105  		err := retry.Do(scope.Ctx, db, func(ctx context.Context, cc *sql.Conn) (err error) {
   106  			tables := make([]string, 0)
   107  			err = cc.Raw(func(drvConn interface{}) (err error) {
   108  				q, ok := drvConn.(interface {
   109  					GetTables(ctx context.Context, folder string, recursive bool, excludeSysDirs bool) ([]string, error)
   110  				})
   111  
   112  				if !ok {
   113  					return errors.New("drvConn does not implement extended API")
   114  				}
   115  
   116  				tables, err = q.GetTables(ctx, ".", false, true)
   117  				return err
   118  			})
   119  			if err != nil {
   120  				return err
   121  			}
   122  
   123  			require.Equal(t,
   124  				[]string{"episodes", "series"},
   125  				tables)
   126  			return nil
   127  		}, retry.WithIdempotent(true))
   128  
   129  		require.NoError(t, err)
   130  	})
   131  
   132  	t.Run("get-tables-at-relative-sub-folder", func(t *testing.T) {
   133  		err := retry.Do(scope.Ctx, db, func(ctx context.Context, cc *sql.Conn) (err error) {
   134  			tables := make([]string, 0)
   135  			err = cc.Raw(func(drvConn interface{}) (err error) {
   136  				q, ok := drvConn.(interface {
   137  					GetTables(ctx context.Context, folder string, recursive bool, excludeSysDirs bool) ([]string, error)
   138  				})
   139  
   140  				if !ok {
   141  					return errors.New("drvConn does not implement extended API")
   142  				}
   143  
   144  				tables, err = q.GetTables(ctx, "./subdir", false, true)
   145  				return err
   146  			})
   147  			if err != nil {
   148  				return err
   149  			}
   150  
   151  			require.Equal(t,
   152  				[]string{"seasons"},
   153  				tables)
   154  			return nil
   155  		}, retry.WithIdempotent(true))
   156  
   157  		require.NoError(t, err)
   158  	})
   159  
   160  	t.Run("get-tables-at-path-represent-a-table", func(t *testing.T) {
   161  		err := retry.Do(scope.Ctx, db, func(ctx context.Context, cc *sql.Conn) (err error) {
   162  			tables := make([]string, 0)
   163  			err = cc.Raw(func(drvConn interface{}) (err error) {
   164  				q, ok := drvConn.(interface {
   165  					GetTables(ctx context.Context, folder string, recursive bool, excludeSysDirs bool) ([]string, error)
   166  				})
   167  
   168  				if !ok {
   169  					return errors.New("drvConn does not implement extended API")
   170  				}
   171  
   172  				tables, err = q.GetTables(ctx, "./subdir/seasons", false, true)
   173  				return err
   174  			})
   175  			if err != nil {
   176  				return err
   177  			}
   178  
   179  			require.Equal(t,
   180  				[]string{"seasons"},
   181  				tables)
   182  			return nil
   183  		}, retry.WithIdempotent(true))
   184  
   185  		require.NoError(t, err)
   186  	})
   187  }
   188  
   189  func TestDatabaseSqlGetTablesRecursive(t *testing.T) {
   190  	var (
   191  		scope  = newScope(t)
   192  		db     = scope.SQLDriverWithFolder()
   193  		folder = t.Name()
   194  	)
   195  
   196  	defer func() {
   197  		_ = db.Close()
   198  	}()
   199  
   200  	t.Run("prepare-sub-folder", func(t *testing.T) {
   201  		cc, err := ydb.Unwrap(db)
   202  		require.NoError(t, err)
   203  
   204  		err = sugar.MakeRecursive(scope.Ctx, cc, path.Join(folder, "subdir"))
   205  		require.NoError(t, err)
   206  	})
   207  
   208  	t.Run("create-tables", func(t *testing.T) {
   209  		err := retry.Do(scope.Ctx, db, func(ctx context.Context, cc *sql.Conn) (err error) {
   210  			_, err = cc.ExecContext(
   211  				ydb.WithQueryMode(ctx, ydb.SchemeQueryMode),
   212  				`CREATE TABLE episodes (
   213  				series_id Uint64,
   214  				season_id Uint64,
   215  				episode_id Uint64,
   216  				title UTF8,
   217  				air_date Date,
   218  				views Uint64,
   219  				PRIMARY KEY (
   220  					series_id,
   221  					season_id,
   222  					episode_id
   223  				)
   224  			)`,
   225  			)
   226  			if err != nil {
   227  				return err
   228  			}
   229  
   230  			_, err = cc.ExecContext(
   231  				ydb.WithQueryMode(ctx, ydb.SchemeQueryMode),
   232  				`
   233  			CREATE TABLE series (
   234  				series_id Uint64,
   235  				title UTF8,
   236  				series_info UTF8,
   237  				release_date Date,
   238  				comment UTF8,
   239  				PRIMARY KEY (
   240  					series_id
   241  				)
   242  			);`,
   243  			)
   244  			if err != nil {
   245  				return err
   246  			}
   247  
   248  			_, err = cc.ExecContext(
   249  				ydb.WithQueryMode(ctx, ydb.SchemeQueryMode),
   250  				`CREATE TABLE `+"`./subdir/seasons`"+` (
   251  				series_id Uint64,
   252  				season_id Uint64,
   253  				title UTF8,
   254  				first_aired Date,
   255  				last_aired Date,
   256  				PRIMARY KEY (
   257  					series_id,
   258  					season_id
   259  				)
   260  			)`,
   261  			)
   262  			if err != nil {
   263  				return err
   264  			}
   265  
   266  			return nil
   267  		}, retry.WithIdempotent(true))
   268  
   269  		require.NoError(t, err)
   270  	})
   271  
   272  	t.Run("get-all-tables-at-current-folder", func(t *testing.T) {
   273  		err := retry.Do(scope.Ctx, db, func(ctx context.Context, cc *sql.Conn) (err error) {
   274  			tables := make([]string, 0)
   275  			err = cc.Raw(func(drvConn interface{}) (err error) {
   276  				q, ok := drvConn.(interface {
   277  					GetTables(ctx context.Context, folder string, recursive bool, excludeSysDirs bool) ([]string, error)
   278  				})
   279  
   280  				if !ok {
   281  					return errors.New("drvConn does not implement extended API")
   282  				}
   283  
   284  				tables, err = q.GetTables(ctx, ".", true, true)
   285  				return err
   286  			})
   287  			if err != nil {
   288  				return err
   289  			}
   290  
   291  			sort.Strings(tables)
   292  
   293  			require.Equal(t,
   294  				[]string{"episodes", "series", "subdir/seasons"},
   295  				tables)
   296  			return nil
   297  		}, retry.WithIdempotent(true))
   298  
   299  		require.NoError(t, err)
   300  	})
   301  
   302  	t.Run("get-all-tables-at-relative-sub-folder", func(t *testing.T) {
   303  		err := retry.Do(scope.Ctx, db, func(ctx context.Context, cc *sql.Conn) (err error) {
   304  			tables := make([]string, 0)
   305  			err = cc.Raw(func(drvConn interface{}) (err error) {
   306  				q, ok := drvConn.(interface {
   307  					GetTables(ctx context.Context, folder string, recursive bool, excludeSysDirs bool) ([]string, error)
   308  				})
   309  
   310  				if !ok {
   311  					return errors.New("drvConn does not implement extended API")
   312  				}
   313  
   314  				tables, err = q.GetTables(ctx, "./subdir", true, true)
   315  				return err
   316  			})
   317  			if err != nil {
   318  				return err
   319  			}
   320  
   321  			sort.Strings(tables)
   322  
   323  			require.Equal(t,
   324  				[]string{"seasons"},
   325  				tables)
   326  			return nil
   327  		}, retry.WithIdempotent(true))
   328  
   329  		require.NoError(t, err)
   330  	})
   331  
   332  	t.Run("get-all-tables-at-path-represent-a-table", func(t *testing.T) {
   333  		err := retry.Do(scope.Ctx, db, func(ctx context.Context, cc *sql.Conn) (err error) {
   334  			tables := make([]string, 0)
   335  			err = cc.Raw(func(drvConn interface{}) (err error) {
   336  				q, ok := drvConn.(interface {
   337  					GetTables(ctx context.Context, folder string, recursive bool, excludeSysDirs bool) ([]string, error)
   338  				})
   339  
   340  				if !ok {
   341  					return errors.New("drvConn does not implement extended API")
   342  				}
   343  
   344  				tables, err = q.GetTables(ctx, "./subdir/seasons", true, true)
   345  				return err
   346  			})
   347  			if err != nil {
   348  				return err
   349  			}
   350  
   351  			sort.Strings(tables)
   352  
   353  			require.Equal(t,
   354  				[]string{"seasons"},
   355  				tables)
   356  			return nil
   357  		}, retry.WithIdempotent(true))
   358  
   359  		require.NoError(t, err)
   360  	})
   361  }