github.com/goravel/framework@v1.13.9/database/gorm/test_utils.go (about)

     1  package gorm
     2  
     3  import (
     4  	"context"
     5  
     6  	"github.com/ory/dockertest/v3"
     7  	"github.com/spf13/cast"
     8  
     9  	configmock "github.com/goravel/framework/contracts/config/mocks"
    10  	"github.com/goravel/framework/contracts/database"
    11  	"github.com/goravel/framework/contracts/database/orm"
    12  	testingdocker "github.com/goravel/framework/support/docker"
    13  )
    14  
    15  const (
    16  	DbPassword     = "Goravel(!)"
    17  	DbUser         = "root"
    18  	dbDatabase     = "goravel"
    19  	dbDatabase1    = "goravel1"
    20  	dbUser1        = "sa"
    21  	resourceExpire = 1200
    22  )
    23  
    24  var testContext context.Context
    25  
    26  type MysqlDocker struct {
    27  	MockConfig *configmock.Config
    28  	Port       int
    29  	pool       *dockertest.Pool
    30  }
    31  
    32  func NewMysqlDocker() *MysqlDocker {
    33  	return &MysqlDocker{MockConfig: &configmock.Config{}}
    34  }
    35  
    36  func (r *MysqlDocker) New() (*dockertest.Pool, *dockertest.Resource, orm.Query, error) {
    37  	pool, resource, err := r.Init()
    38  	if err != nil {
    39  		return nil, nil, nil, err
    40  	}
    41  
    42  	r.mock()
    43  
    44  	db, err := r.Query(true)
    45  	if err != nil {
    46  		return nil, nil, nil, err
    47  	}
    48  
    49  	return pool, resource, db, nil
    50  }
    51  
    52  func (r *MysqlDocker) Init() (*dockertest.Pool, *dockertest.Resource, error) {
    53  	pool, err := testingdocker.Pool()
    54  	if err != nil {
    55  		return nil, nil, err
    56  	}
    57  	resource, err := testingdocker.Resource(pool, &dockertest.RunOptions{
    58  		Repository: "mysql",
    59  		Tag:        "latest",
    60  		Env: []string{
    61  			"MYSQL_ROOT_PASSWORD=" + DbPassword,
    62  			"MYSQL_DATABASE=" + dbDatabase,
    63  		},
    64  	})
    65  	if err != nil {
    66  		return nil, nil, err
    67  	}
    68  
    69  	_ = resource.Expire(resourceExpire)
    70  	r.pool = pool
    71  	r.Port = cast.ToInt(resource.GetPort("3306/tcp"))
    72  
    73  	return pool, resource, nil
    74  }
    75  
    76  func (r *MysqlDocker) Query(createTable bool) (orm.Query, error) {
    77  	db, err := r.query()
    78  	if err != nil {
    79  		return nil, err
    80  	}
    81  
    82  	if createTable {
    83  		err = Tables{}.Create(orm.DriverMysql, db)
    84  		if err != nil {
    85  			return nil, err
    86  		}
    87  	}
    88  
    89  	return db, nil
    90  }
    91  
    92  func (r *MysqlDocker) QueryWithPrefixAndSingular() (orm.Query, error) {
    93  	db, err := r.query()
    94  	if err != nil {
    95  		return nil, err
    96  	}
    97  
    98  	err = Tables{}.CreateWithPrefixAndSingular(orm.DriverMysql, db)
    99  	if err != nil {
   100  		return nil, err
   101  	}
   102  
   103  	return db, nil
   104  }
   105  
   106  func (r *MysqlDocker) MockReadWrite(readPort, writePort int) {
   107  	r.MockConfig = &configmock.Config{}
   108  	r.MockConfig.On("Get", "database.connections.mysql.read").Return([]database.Config{
   109  		{Host: "127.0.0.1", Port: readPort, Username: DbUser, Password: DbPassword},
   110  	})
   111  	r.MockConfig.On("Get", "database.connections.mysql.write").Return([]database.Config{
   112  		{Host: "127.0.0.1", Port: writePort, Username: DbUser, Password: DbPassword},
   113  	})
   114  	r.MockConfig.On("GetString", "database.connections.mysql.prefix").Return("")
   115  	r.MockConfig.On("GetBool", "database.connections.mysql.singular").Return(false)
   116  	r.mockOfCommon()
   117  }
   118  
   119  func (r *MysqlDocker) mock() {
   120  	r.MockConfig.On("GetString", "database.default").Return("mysql")
   121  	r.MockConfig.On("GetString", "database.migrations").Return("migrations")
   122  	r.MockConfig.On("GetString", "database.connections.mysql.prefix").Return("")
   123  	r.MockConfig.On("GetBool", "database.connections.mysql.singular").Return(false)
   124  	r.mockSingleOfCommon()
   125  	r.mockOfCommon()
   126  }
   127  
   128  func (r *MysqlDocker) mockWithPrefixAndSingular() {
   129  	r.MockConfig.On("GetString", "database.connections.mysql.prefix").Return("goravel_")
   130  	r.MockConfig.On("GetBool", "database.connections.mysql.singular").Return(true)
   131  	r.mockSingleOfCommon()
   132  	r.mockOfCommon()
   133  }
   134  
   135  func (r *MysqlDocker) mockSingleOfCommon() {
   136  	r.MockConfig.On("Get", "database.connections.mysql.read").Return(nil)
   137  	r.MockConfig.On("Get", "database.connections.mysql.write").Return(nil)
   138  	r.MockConfig.On("GetBool", "app.debug").Return(true)
   139  	r.MockConfig.On("GetString", "database.connections.mysql.host").Return("127.0.0.1")
   140  	r.MockConfig.On("GetString", "database.connections.mysql.username").Return(DbUser)
   141  	r.MockConfig.On("GetString", "database.connections.mysql.password").Return(DbPassword)
   142  	r.MockConfig.On("GetInt", "database.connections.mysql.port").Return(r.Port)
   143  }
   144  
   145  func (r *MysqlDocker) mockOfCommon() {
   146  	r.MockConfig.On("GetBool", "app.debug").Return(true)
   147  	r.MockConfig.On("GetString", "database.connections.mysql.driver").Return(orm.DriverMysql.String())
   148  	r.MockConfig.On("GetString", "database.connections.mysql.charset").Return("utf8mb4")
   149  	r.MockConfig.On("GetString", "database.connections.mysql.loc").Return("Local")
   150  	r.MockConfig.On("GetString", "database.connections.mysql.database").Return(dbDatabase)
   151  
   152  	mockPool(r.MockConfig)
   153  }
   154  
   155  func (r *MysqlDocker) query() (orm.Query, error) {
   156  	var db orm.Query
   157  	if err := r.pool.Retry(func() error {
   158  		var err error
   159  		db, err = InitializeQuery(testContext, r.MockConfig, orm.DriverMysql.String())
   160  		if err != nil {
   161  			return err
   162  		}
   163  
   164  		return nil
   165  	}); err != nil {
   166  		return nil, err
   167  	}
   168  
   169  	return db, nil
   170  }
   171  
   172  type PostgresqlDocker struct {
   173  	pool       *dockertest.Pool
   174  	MockConfig *configmock.Config
   175  	Port       int
   176  }
   177  
   178  func NewPostgresqlDocker() *PostgresqlDocker {
   179  	return &PostgresqlDocker{MockConfig: &configmock.Config{}}
   180  }
   181  
   182  func (r *PostgresqlDocker) New() (*dockertest.Pool, *dockertest.Resource, orm.Query, error) {
   183  	pool, resource, err := r.Init()
   184  	if err != nil {
   185  		return nil, nil, nil, err
   186  	}
   187  
   188  	r.mock()
   189  
   190  	db, err := r.Query(true)
   191  	if err != nil {
   192  		return nil, nil, nil, err
   193  	}
   194  
   195  	return pool, resource, db, nil
   196  }
   197  
   198  func (r *PostgresqlDocker) Init() (*dockertest.Pool, *dockertest.Resource, error) {
   199  	pool, err := testingdocker.Pool()
   200  	if err != nil {
   201  		return nil, nil, err
   202  	}
   203  	resource, err := testingdocker.Resource(pool, &dockertest.RunOptions{
   204  		Repository: "postgres",
   205  		Tag:        "latest",
   206  		Env: []string{
   207  			"POSTGRES_USER=" + DbUser,
   208  			"POSTGRES_PASSWORD=" + DbPassword,
   209  			"listen_addresses = '*'",
   210  		},
   211  	})
   212  	if err != nil {
   213  		return nil, nil, err
   214  	}
   215  
   216  	_ = resource.Expire(resourceExpire)
   217  	r.pool = pool
   218  	r.Port = cast.ToInt(resource.GetPort("5432/tcp"))
   219  
   220  	return pool, resource, nil
   221  }
   222  
   223  func (r *PostgresqlDocker) Query(createTable bool) (orm.Query, error) {
   224  	db, err := r.query()
   225  	if err != nil {
   226  		return nil, err
   227  	}
   228  
   229  	if createTable {
   230  		err = Tables{}.Create(orm.DriverPostgresql, db)
   231  		if err != nil {
   232  			return nil, err
   233  		}
   234  	}
   235  
   236  	return db, nil
   237  }
   238  
   239  func (r *PostgresqlDocker) QueryWithPrefixAndSingular() (orm.Query, error) {
   240  	db, err := r.query()
   241  	if err != nil {
   242  		return nil, err
   243  	}
   244  
   245  	err = Tables{}.CreateWithPrefixAndSingular(orm.DriverPostgresql, db)
   246  	if err != nil {
   247  		return nil, err
   248  	}
   249  
   250  	return db, nil
   251  }
   252  
   253  func (r *PostgresqlDocker) MockReadWrite(readPort, writePort int) {
   254  	r.MockConfig = &configmock.Config{}
   255  	r.MockConfig.On("Get", "database.connections.postgresql.read").Return([]database.Config{
   256  		{Host: "127.0.0.1", Port: readPort, Username: DbUser, Password: DbPassword},
   257  	})
   258  	r.MockConfig.On("Get", "database.connections.postgresql.write").Return([]database.Config{
   259  		{Host: "127.0.0.1", Port: writePort, Username: DbUser, Password: DbPassword},
   260  	})
   261  	r.MockConfig.On("GetString", "database.connections.postgresql.prefix").Return("")
   262  	r.MockConfig.On("GetBool", "database.connections.postgresql.singular").Return(false)
   263  	r.mockOfCommon()
   264  }
   265  
   266  func (r *PostgresqlDocker) mock() {
   267  	r.MockConfig.On("GetString", "database.default").Return("postgresql")
   268  	r.MockConfig.On("GetString", "database.migrations").Return("migrations")
   269  	r.MockConfig.On("GetString", "database.connections.postgresql.prefix").Return("")
   270  	r.MockConfig.On("GetBool", "database.connections.postgresql.singular").Return(false)
   271  	r.mockSingleOfCommon()
   272  	r.mockOfCommon()
   273  }
   274  
   275  func (r *PostgresqlDocker) mockWithPrefixAndSingular() {
   276  	r.MockConfig.On("GetString", "database.connections.postgresql.prefix").Return("goravel_")
   277  	r.MockConfig.On("GetBool", "database.connections.postgresql.singular").Return(true)
   278  	r.mockSingleOfCommon()
   279  	r.mockOfCommon()
   280  }
   281  
   282  func (r *PostgresqlDocker) mockSingleOfCommon() {
   283  	r.MockConfig.On("Get", "database.connections.postgresql.read").Return(nil)
   284  	r.MockConfig.On("Get", "database.connections.postgresql.write").Return(nil)
   285  	r.MockConfig.On("GetString", "database.connections.postgresql.host").Return("127.0.0.1")
   286  	r.MockConfig.On("GetString", "database.connections.postgresql.username").Return(DbUser)
   287  	r.MockConfig.On("GetString", "database.connections.postgresql.password").Return(DbPassword)
   288  	r.MockConfig.On("GetInt", "database.connections.postgresql.port").Return(r.Port)
   289  }
   290  
   291  func (r *PostgresqlDocker) mockOfCommon() {
   292  	r.MockConfig.On("GetBool", "app.debug").Return(true)
   293  	r.MockConfig.On("GetString", "database.connections.postgresql.driver").Return(orm.DriverPostgresql.String())
   294  	r.MockConfig.On("GetString", "database.connections.postgresql.sslmode").Return("disable")
   295  	r.MockConfig.On("GetString", "database.connections.postgresql.timezone").Return("UTC")
   296  	r.MockConfig.On("GetString", "database.connections.postgresql.database").Return("postgres")
   297  
   298  	mockPool(r.MockConfig)
   299  }
   300  
   301  func (r *PostgresqlDocker) query() (orm.Query, error) {
   302  	var db orm.Query
   303  	if err := r.pool.Retry(func() error {
   304  		var err error
   305  		db, err = InitializeQuery(testContext, r.MockConfig, orm.DriverPostgresql.String())
   306  		if err != nil {
   307  			return err
   308  		}
   309  
   310  		return nil
   311  	}); err != nil {
   312  		return nil, err
   313  	}
   314  
   315  	return db, nil
   316  }
   317  
   318  type SqliteDocker struct {
   319  	name       string
   320  	MockConfig *configmock.Config
   321  	pool       *dockertest.Pool
   322  }
   323  
   324  func NewSqliteDocker(dbName string) *SqliteDocker {
   325  	return &SqliteDocker{MockConfig: &configmock.Config{}, name: dbName}
   326  }
   327  
   328  func (r *SqliteDocker) New() (*dockertest.Pool, *dockertest.Resource, orm.Query, error) {
   329  	pool, resource, err := r.Init()
   330  	if err != nil {
   331  		return nil, nil, nil, err
   332  	}
   333  
   334  	r.mock()
   335  
   336  	db, err := r.Query(true)
   337  	if err != nil {
   338  		return nil, nil, nil, err
   339  	}
   340  
   341  	return pool, resource, db, nil
   342  }
   343  
   344  func (r *SqliteDocker) Init() (*dockertest.Pool, *dockertest.Resource, error) {
   345  	pool, err := testingdocker.Pool()
   346  	if err != nil {
   347  		return nil, nil, err
   348  	}
   349  	resource, err := testingdocker.Resource(pool, &dockertest.RunOptions{
   350  		Repository: "nouchka/sqlite3",
   351  		Tag:        "latest",
   352  		Env:        []string{},
   353  	})
   354  	if err != nil {
   355  		return nil, nil, err
   356  	}
   357  
   358  	_ = resource.Expire(resourceExpire)
   359  	r.pool = pool
   360  
   361  	return pool, resource, nil
   362  }
   363  
   364  func (r *SqliteDocker) Query(createTable bool) (orm.Query, error) {
   365  	db, err := r.query()
   366  	if err != nil {
   367  		return nil, err
   368  	}
   369  
   370  	if createTable {
   371  		err = Tables{}.Create(orm.DriverSqlite, db)
   372  		if err != nil {
   373  			return nil, err
   374  		}
   375  	}
   376  
   377  	return db, nil
   378  }
   379  
   380  func (r *SqliteDocker) QueryWithPrefixAndSingular() (orm.Query, error) {
   381  	db, err := r.query()
   382  	if err != nil {
   383  		return nil, err
   384  	}
   385  
   386  	err = Tables{}.CreateWithPrefixAndSingular(orm.DriverSqlite, db)
   387  	if err != nil {
   388  		return nil, err
   389  	}
   390  
   391  	return db, nil
   392  }
   393  
   394  func (r *SqliteDocker) MockReadWrite() {
   395  	r.MockConfig = &configmock.Config{}
   396  	r.MockConfig.On("Get", "database.connections.sqlite.read").Return([]database.Config{
   397  		{Database: dbDatabase},
   398  	})
   399  	r.MockConfig.On("Get", "database.connections.sqlite.write").Return([]database.Config{
   400  		{Database: dbDatabase1},
   401  	})
   402  	r.MockConfig.On("GetString", "database.connections.sqlite.prefix").Return("")
   403  	r.MockConfig.On("GetBool", "database.connections.sqlite.singular").Return(false)
   404  	r.mockOfCommon()
   405  }
   406  
   407  func (r *SqliteDocker) mock() {
   408  	r.MockConfig.On("GetString", "database.default").Return("sqlite")
   409  	r.MockConfig.On("GetString", "database.migrations").Return("migrations")
   410  	r.MockConfig.On("GetString", "database.connections.sqlite.prefix").Return("")
   411  	r.MockConfig.On("GetBool", "database.connections.sqlite.singular").Return(false)
   412  	r.mockSingleOfCommon()
   413  	r.mockOfCommon()
   414  }
   415  
   416  func (r *SqliteDocker) mockWithPrefixAndSingular() {
   417  	r.MockConfig.On("GetString", "database.connections.sqlite.prefix").Return("goravel_")
   418  	r.MockConfig.On("GetBool", "database.connections.sqlite.singular").Return(true)
   419  	r.mockSingleOfCommon()
   420  	r.mockOfCommon()
   421  }
   422  
   423  func (r *SqliteDocker) mockSingleOfCommon() {
   424  	r.MockConfig.On("Get", "database.connections.sqlite.read").Return(nil)
   425  	r.MockConfig.On("Get", "database.connections.sqlite.write").Return(nil)
   426  	r.MockConfig.On("GetString", "database.connections.sqlite.database").Return(r.name)
   427  }
   428  
   429  func (r *SqliteDocker) mockOfCommon() {
   430  	r.MockConfig.On("GetBool", "app.debug").Return(true)
   431  	r.MockConfig.On("GetString", "database.connections.sqlite.driver").Return(orm.DriverSqlite.String())
   432  	mockPool(r.MockConfig)
   433  }
   434  
   435  func (r *SqliteDocker) query() (orm.Query, error) {
   436  	var db orm.Query
   437  	if err := r.pool.Retry(func() error {
   438  		var err error
   439  		db, err = InitializeQuery(testContext, r.MockConfig, orm.DriverSqlite.String())
   440  
   441  		return err
   442  	}); err != nil {
   443  		return nil, err
   444  	}
   445  
   446  	return db, nil
   447  }
   448  
   449  type SqlserverDocker struct {
   450  	pool       *dockertest.Pool
   451  	MockConfig *configmock.Config
   452  	Port       int
   453  }
   454  
   455  func NewSqlserverDocker() *SqlserverDocker {
   456  	return &SqlserverDocker{MockConfig: &configmock.Config{}}
   457  }
   458  
   459  func (r *SqlserverDocker) New() (*dockertest.Pool, *dockertest.Resource, orm.Query, error) {
   460  	pool, resource, err := r.Init()
   461  	if err != nil {
   462  		return nil, nil, nil, err
   463  	}
   464  
   465  	r.mock()
   466  
   467  	db, err := r.Query(true)
   468  	if err != nil {
   469  		return nil, nil, nil, err
   470  	}
   471  
   472  	return pool, resource, db, nil
   473  }
   474  
   475  func (r *SqlserverDocker) Init() (*dockertest.Pool, *dockertest.Resource, error) {
   476  	pool, err := testingdocker.Pool()
   477  	if err != nil {
   478  		return nil, nil, err
   479  	}
   480  	resource, err := testingdocker.Resource(pool, &dockertest.RunOptions{
   481  		Repository: "mcr.microsoft.com/mssql/server",
   482  		Tag:        "latest",
   483  		Env: []string{
   484  			"MSSQL_SA_PASSWORD=" + DbPassword,
   485  			"ACCEPT_EULA=Y",
   486  		},
   487  	})
   488  	if err != nil {
   489  		return nil, nil, err
   490  	}
   491  
   492  	_ = resource.Expire(resourceExpire)
   493  	r.pool = pool
   494  	r.Port = cast.ToInt(resource.GetPort("1433/tcp"))
   495  
   496  	return pool, resource, nil
   497  }
   498  
   499  func (r *SqlserverDocker) Query(createTable bool) (orm.Query, error) {
   500  	db, err := r.query()
   501  	if err != nil {
   502  		return nil, err
   503  	}
   504  
   505  	if createTable {
   506  		err = Tables{}.Create(orm.DriverSqlserver, db)
   507  		if err != nil {
   508  			return nil, err
   509  		}
   510  	}
   511  
   512  	return db, nil
   513  }
   514  
   515  func (r *SqlserverDocker) QueryWithPrefixAndSingular() (orm.Query, error) {
   516  	db, err := r.query()
   517  	if err != nil {
   518  		return nil, err
   519  	}
   520  
   521  	err = Tables{}.CreateWithPrefixAndSingular(orm.DriverSqlserver, db)
   522  	if err != nil {
   523  		return nil, err
   524  	}
   525  
   526  	return db, nil
   527  }
   528  
   529  func (r *SqlserverDocker) mock() {
   530  	r.MockConfig.On("GetString", "database.default").Return("sqlserver")
   531  	r.MockConfig.On("GetString", "database.migrations").Return("migrations")
   532  	r.MockConfig.On("GetString", "database.connections.sqlserver.prefix").Return("")
   533  	r.MockConfig.On("GetBool", "database.connections.sqlserver.singular").Return(false)
   534  	r.mockSingleOfCommon()
   535  	r.mockOfCommon()
   536  }
   537  
   538  func (r *SqlserverDocker) MockReadWrite(readPort, writePort int) {
   539  	r.MockConfig = &configmock.Config{}
   540  	r.MockConfig.On("Get", "database.connections.sqlserver.read").Return([]database.Config{
   541  		{Host: "127.0.0.1", Port: readPort, Username: dbUser1, Password: DbPassword},
   542  	})
   543  	r.MockConfig.On("Get", "database.connections.sqlserver.write").Return([]database.Config{
   544  		{Host: "127.0.0.1", Port: writePort, Username: dbUser1, Password: DbPassword},
   545  	})
   546  	r.MockConfig.On("GetString", "database.connections.sqlserver.prefix").Return("")
   547  	r.MockConfig.On("GetBool", "database.connections.sqlserver.singular").Return(false)
   548  	r.mockOfCommon()
   549  }
   550  
   551  func (r *SqlserverDocker) mockWithPrefixAndSingular() {
   552  	r.MockConfig.On("GetString", "database.connections.sqlserver.prefix").Return("goravel_")
   553  	r.MockConfig.On("GetBool", "database.connections.sqlserver.singular").Return(true)
   554  	r.mockSingleOfCommon()
   555  	r.mockOfCommon()
   556  }
   557  
   558  func (r *SqlserverDocker) mockSingleOfCommon() {
   559  	r.MockConfig.On("Get", "database.connections.sqlserver.read").Return(nil)
   560  	r.MockConfig.On("Get", "database.connections.sqlserver.write").Return(nil)
   561  	r.MockConfig.On("GetString", "database.connections.sqlserver.host").Return("127.0.0.1")
   562  	r.MockConfig.On("GetString", "database.connections.sqlserver.username").Return(dbUser1)
   563  	r.MockConfig.On("GetString", "database.connections.sqlserver.password").Return(DbPassword)
   564  	r.MockConfig.On("GetInt", "database.connections.sqlserver.port").Return(r.Port)
   565  }
   566  
   567  func (r *SqlserverDocker) mockOfCommon() {
   568  	r.MockConfig.On("GetBool", "app.debug").Return(true)
   569  	r.MockConfig.On("GetString", "database.connections.sqlserver.driver").Return(orm.DriverSqlserver.String())
   570  	r.MockConfig.On("GetString", "database.connections.sqlserver.database").Return("msdb")
   571  	r.MockConfig.On("GetString", "database.connections.sqlserver.charset").Return("utf8mb4")
   572  	mockPool(r.MockConfig)
   573  }
   574  
   575  func (r *SqlserverDocker) query() (orm.Query, error) {
   576  	var db orm.Query
   577  	if err := r.pool.Retry(func() error {
   578  		var err error
   579  		db, err = InitializeQuery(testContext, r.MockConfig, orm.DriverSqlserver.String())
   580  		if err != nil {
   581  			return err
   582  		}
   583  
   584  		return nil
   585  	}); err != nil {
   586  		return nil, err
   587  	}
   588  
   589  	return db, nil
   590  }
   591  
   592  type Tables struct {
   593  }
   594  
   595  func (r Tables) Create(driver orm.Driver, db orm.Query) error {
   596  	_, err := db.Exec(r.createPeopleTable(driver))
   597  	if err != nil {
   598  		return err
   599  	}
   600  	_, err = db.Exec(r.createReviewTable(driver))
   601  	if err != nil {
   602  		return err
   603  	}
   604  	_, err = db.Exec(r.createUserTable(driver))
   605  	if err != nil {
   606  		return err
   607  	}
   608  	_, err = db.Exec(r.createProductTable(driver))
   609  	if err != nil {
   610  		return err
   611  	}
   612  	_, err = db.Exec(r.createAddressTable(driver))
   613  	if err != nil {
   614  		return err
   615  	}
   616  	_, err = db.Exec(r.createBookTable(driver))
   617  	if err != nil {
   618  		return err
   619  	}
   620  	_, err = db.Exec(r.createRoleTable(driver))
   621  	if err != nil {
   622  		return err
   623  	}
   624  	_, err = db.Exec(r.createHouseTable(driver))
   625  	if err != nil {
   626  		return err
   627  	}
   628  	_, err = db.Exec(r.createPhoneTable(driver))
   629  	if err != nil {
   630  		return err
   631  	}
   632  	_, err = db.Exec(r.createRoleUserTable(driver))
   633  	if err != nil {
   634  		return err
   635  	}
   636  	_, err = db.Exec(r.createAuthorTable(driver))
   637  	if err != nil {
   638  		return err
   639  	}
   640  
   641  	return nil
   642  }
   643  
   644  func (r Tables) CreateWithPrefixAndSingular(driver orm.Driver, db orm.Query) error {
   645  	_, err := db.Exec(r.createUserTableWithPrefixAndSingular(driver))
   646  	if err != nil {
   647  		return err
   648  	}
   649  
   650  	return nil
   651  }
   652  
   653  func (r Tables) createPeopleTable(driver orm.Driver) string {
   654  	switch driver {
   655  	case orm.DriverMysql:
   656  		return `
   657  CREATE TABLE peoples (
   658    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
   659    body varchar(255) NOT NULL,
   660    created_at datetime(3) NOT NULL,
   661    updated_at datetime(3) NOT NULL,
   662    deleted_at datetime(3) DEFAULT NULL,
   663    PRIMARY KEY (id),
   664    KEY idx_users_created_at (created_at),
   665    KEY idx_users_updated_at (updated_at)
   666  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
   667  `
   668  	case orm.DriverPostgresql:
   669  		return `
   670  CREATE TABLE peoples (
   671    id SERIAL PRIMARY KEY NOT NULL,
   672    body varchar(255) NOT NULL,
   673    created_at timestamp NOT NULL,
   674    updated_at timestamp NOT NULL,
   675    deleted_at timestamp DEFAULT NULL
   676  );
   677  `
   678  	case orm.DriverSqlite:
   679  		return `
   680  CREATE TABLE peoples (
   681    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
   682    body varchar(255) NOT NULL,
   683    created_at datetime NOT NULL,
   684    updated_at datetime NOT NULL,
   685    deleted_at datetime DEFAULT NULL
   686  );
   687  `
   688  	case orm.DriverSqlserver:
   689  		return `
   690  CREATE TABLE peoples (
   691    id bigint NOT NULL IDENTITY(1,1),
   692    body varchar(255) NOT NULL,
   693    created_at datetime NOT NULL,
   694    updated_at datetime NOT NULL,
   695    deleted_at datetime DEFAULT NULL,
   696    PRIMARY KEY (id)
   697  );
   698  `
   699  	default:
   700  		return ""
   701  	}
   702  }
   703  
   704  func (r Tables) createReviewTable(driver orm.Driver) string {
   705  	switch driver {
   706  	case orm.DriverMysql:
   707  		return `
   708  CREATE TABLE reviews (
   709    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
   710    body varchar(255) NOT NULL,
   711    created_at datetime(3) NOT NULL,
   712    updated_at datetime(3) NOT NULL,
   713    deleted_at datetime(3) DEFAULT NULL,
   714    PRIMARY KEY (id),
   715    KEY idx_users_created_at (created_at),
   716    KEY idx_users_updated_at (updated_at)
   717  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
   718  `
   719  	case orm.DriverPostgresql:
   720  		return `
   721  CREATE TABLE reviews (
   722    id SERIAL PRIMARY KEY NOT NULL,
   723    body varchar(255) NOT NULL,
   724    created_at timestamp NOT NULL,
   725    updated_at timestamp NOT NULL,
   726    deleted_at timestamp DEFAULT NULL
   727  );
   728  `
   729  	case orm.DriverSqlite:
   730  		return `
   731  CREATE TABLE reviews (
   732    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
   733    body varchar(255) NOT NULL,
   734    created_at datetime NOT NULL,
   735    updated_at datetime NOT NULL,
   736    deleted_at datetime DEFAULT NULL
   737  );
   738  `
   739  	case orm.DriverSqlserver:
   740  		return `
   741  CREATE TABLE reviews (
   742    id bigint NOT NULL IDENTITY(1,1),
   743    body varchar(255) NOT NULL,
   744    created_at datetime NOT NULL,
   745    updated_at datetime NOT NULL,
   746    deleted_at datetime DEFAULT NULL,
   747    PRIMARY KEY (id)
   748  );
   749  `
   750  	default:
   751  		return ""
   752  	}
   753  }
   754  
   755  func (r Tables) createProductTable(driver orm.Driver) string {
   756  	switch driver {
   757  	case orm.DriverMysql:
   758  		return `
   759  CREATE TABLE products (
   760    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
   761    name varchar(255) NOT NULL,
   762    created_at datetime(3) NOT NULL,
   763    updated_at datetime(3) NOT NULL,
   764    deleted_at datetime(3) DEFAULT NULL,
   765    PRIMARY KEY (id),
   766    KEY idx_users_created_at (created_at),
   767    KEY idx_users_updated_at (updated_at)
   768  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
   769  `
   770  	case orm.DriverPostgresql:
   771  		return `
   772  CREATE TABLE products (
   773    id SERIAL PRIMARY KEY NOT NULL,
   774    name varchar(255) NOT NULL,
   775    created_at timestamp NOT NULL,
   776    updated_at timestamp NOT NULL,
   777    deleted_at timestamp DEFAULT NULL
   778  );
   779  `
   780  	case orm.DriverSqlite:
   781  		return `
   782  CREATE TABLE products (
   783    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
   784    name varchar(255) NOT NULL,
   785    created_at datetime NOT NULL,
   786    updated_at datetime NOT NULL,
   787    deleted_at datetime DEFAULT NULL
   788  );
   789  `
   790  	case orm.DriverSqlserver:
   791  		return `
   792  CREATE TABLE products (
   793    id bigint NOT NULL IDENTITY(1,1),
   794    name varchar(255) NOT NULL,
   795    created_at datetime NOT NULL,
   796    updated_at datetime NOT NULL,
   797    deleted_at datetime DEFAULT NULL,
   798    PRIMARY KEY (id)
   799  );
   800  `
   801  	default:
   802  		return ""
   803  	}
   804  }
   805  
   806  func (r Tables) createUserTable(driver orm.Driver) string {
   807  	switch driver {
   808  	case orm.DriverMysql:
   809  		return `
   810  CREATE TABLE users (
   811    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
   812    name varchar(255) NOT NULL,
   813    avatar varchar(255) NOT NULL,
   814    created_at datetime(3) NOT NULL,
   815    updated_at datetime(3) NOT NULL,
   816    deleted_at datetime(3) DEFAULT NULL,
   817    PRIMARY KEY (id),
   818    KEY idx_users_created_at (created_at),
   819    KEY idx_users_updated_at (updated_at)
   820  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
   821  `
   822  	case orm.DriverPostgresql:
   823  		return `
   824  CREATE TABLE users (
   825    id SERIAL PRIMARY KEY NOT NULL,
   826    name varchar(255) NOT NULL,
   827    avatar varchar(255) NOT NULL,
   828    created_at timestamp NOT NULL,
   829    updated_at timestamp NOT NULL,
   830    deleted_at timestamp DEFAULT NULL
   831  );
   832  `
   833  	case orm.DriverSqlite:
   834  		return `
   835  CREATE TABLE users (
   836    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
   837    name varchar(255) NOT NULL,
   838    avatar varchar(255) NOT NULL,
   839    created_at datetime NOT NULL,
   840    updated_at datetime NOT NULL,
   841    deleted_at datetime DEFAULT NULL
   842  );
   843  `
   844  	case orm.DriverSqlserver:
   845  		return `
   846  CREATE TABLE users (
   847    id bigint NOT NULL IDENTITY(1,1),
   848    name varchar(255) NOT NULL,
   849    avatar varchar(255) NOT NULL,
   850    created_at datetime NOT NULL,
   851    updated_at datetime NOT NULL,
   852    deleted_at datetime DEFAULT NULL,
   853    PRIMARY KEY (id)
   854  );
   855  `
   856  	default:
   857  		return ""
   858  	}
   859  }
   860  
   861  func (r Tables) createUserTableWithPrefixAndSingular(driver orm.Driver) string {
   862  	switch driver {
   863  	case orm.DriverMysql:
   864  		return `
   865  CREATE TABLE goravel_user (
   866    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
   867    name varchar(255) NOT NULL,
   868    avatar varchar(255) NOT NULL,
   869    created_at datetime(3) NOT NULL,
   870    updated_at datetime(3) NOT NULL,
   871    deleted_at datetime(3) DEFAULT NULL,
   872    PRIMARY KEY (id),
   873    KEY idx_users_created_at (created_at),
   874    KEY idx_users_updated_at (updated_at)
   875  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
   876  `
   877  	case orm.DriverPostgresql:
   878  		return `
   879  CREATE TABLE goravel_user (
   880    id SERIAL PRIMARY KEY NOT NULL,
   881    name varchar(255) NOT NULL,
   882    avatar varchar(255) NOT NULL,
   883    created_at timestamp NOT NULL,
   884    updated_at timestamp NOT NULL,
   885    deleted_at timestamp DEFAULT NULL
   886  );
   887  `
   888  	case orm.DriverSqlite:
   889  		return `
   890  CREATE TABLE goravel_user (
   891    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
   892    name varchar(255) NOT NULL,
   893    avatar varchar(255) NOT NULL,
   894    created_at datetime NOT NULL,
   895    updated_at datetime NOT NULL,
   896    deleted_at datetime DEFAULT NULL
   897  );
   898  `
   899  	case orm.DriverSqlserver:
   900  		return `
   901  CREATE TABLE goravel_user (
   902    id bigint NOT NULL IDENTITY(1,1),
   903    name varchar(255) NOT NULL,
   904    avatar varchar(255) NOT NULL,
   905    created_at datetime NOT NULL,
   906    updated_at datetime NOT NULL,
   907    deleted_at datetime DEFAULT NULL,
   908    PRIMARY KEY (id)
   909  );
   910  `
   911  	default:
   912  		return ""
   913  	}
   914  }
   915  
   916  func (r Tables) createAddressTable(driver orm.Driver) string {
   917  	switch driver {
   918  	case orm.DriverMysql:
   919  		return `
   920  CREATE TABLE addresses (
   921    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
   922    user_id bigint(20) unsigned DEFAULT NULL,
   923    name varchar(255) NOT NULL,
   924    province varchar(255) NOT NULL,
   925    created_at datetime(3) NOT NULL,
   926    updated_at datetime(3) NOT NULL,
   927    PRIMARY KEY (id),
   928    KEY idx_addresses_created_at (created_at),
   929    KEY idx_addresses_updated_at (updated_at)
   930  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
   931  `
   932  	case orm.DriverPostgresql:
   933  		return `
   934  CREATE TABLE addresses (
   935    id SERIAL PRIMARY KEY NOT NULL,
   936    user_id int DEFAULT NULL,
   937    name varchar(255) NOT NULL,
   938    province varchar(255) NOT NULL,
   939    created_at timestamp NOT NULL,
   940    updated_at timestamp NOT NULL
   941  );
   942  `
   943  	case orm.DriverSqlite:
   944  		return `
   945  CREATE TABLE addresses (
   946    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
   947    user_id int DEFAULT NULL,
   948    name varchar(255) NOT NULL,
   949    province varchar(255) NOT NULL,
   950    created_at datetime NOT NULL,
   951    updated_at datetime NOT NULL
   952  );
   953  `
   954  	case orm.DriverSqlserver:
   955  		return `
   956  CREATE TABLE addresses (
   957    id bigint NOT NULL IDENTITY(1,1),
   958    user_id bigint DEFAULT NULL,
   959    name varchar(255) NOT NULL,
   960    province varchar(255) NOT NULL,
   961    created_at datetime NOT NULL,
   962    updated_at datetime NOT NULL,
   963    PRIMARY KEY (id)
   964  );
   965  `
   966  	default:
   967  		return ""
   968  	}
   969  }
   970  
   971  func (r Tables) createBookTable(driver orm.Driver) string {
   972  	switch driver {
   973  	case orm.DriverMysql:
   974  		return `
   975  CREATE TABLE books (
   976    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
   977    user_id bigint(20) unsigned DEFAULT NULL,
   978    name varchar(255) NOT NULL,
   979    created_at datetime(3) NOT NULL,
   980    updated_at datetime(3) NOT NULL,
   981    PRIMARY KEY (id),
   982    KEY idx_books_created_at (created_at),
   983    KEY idx_books_updated_at (updated_at)
   984  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
   985  `
   986  	case orm.DriverPostgresql:
   987  		return `
   988  CREATE TABLE books (
   989    id SERIAL PRIMARY KEY NOT NULL,
   990    user_id int DEFAULT NULL,
   991    name varchar(255) NOT NULL,
   992    created_at timestamp NOT NULL,
   993    updated_at timestamp NOT NULL
   994  );
   995  `
   996  	case orm.DriverSqlite:
   997  		return `
   998  CREATE TABLE books (
   999    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
  1000    user_id int DEFAULT NULL,
  1001    name varchar(255) NOT NULL,
  1002    created_at datetime NOT NULL,
  1003    updated_at datetime NOT NULL
  1004  );
  1005  `
  1006  	case orm.DriverSqlserver:
  1007  		return `
  1008  CREATE TABLE books (
  1009    id bigint NOT NULL IDENTITY(1,1),
  1010    user_id bigint DEFAULT NULL,
  1011    name varchar(255) NOT NULL,
  1012    created_at datetime NOT NULL,
  1013    updated_at datetime NOT NULL,
  1014    PRIMARY KEY (id)
  1015  );
  1016  `
  1017  	default:
  1018  		return ""
  1019  	}
  1020  }
  1021  
  1022  func (r Tables) createAuthorTable(driver orm.Driver) string {
  1023  	switch driver {
  1024  	case orm.DriverMysql:
  1025  		return `
  1026  CREATE TABLE authors (
  1027    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  1028    book_id bigint(20) unsigned DEFAULT NULL,
  1029    name varchar(255) NOT NULL,
  1030    created_at datetime(3) NOT NULL,
  1031    updated_at datetime(3) NOT NULL,
  1032    PRIMARY KEY (id),
  1033    KEY idx_books_created_at (created_at),
  1034    KEY idx_books_updated_at (updated_at)
  1035  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
  1036  `
  1037  	case orm.DriverPostgresql:
  1038  		return `
  1039  CREATE TABLE authors (
  1040    id SERIAL PRIMARY KEY NOT NULL,
  1041    book_id int DEFAULT NULL,
  1042    name varchar(255) NOT NULL,
  1043    created_at timestamp NOT NULL,
  1044    updated_at timestamp NOT NULL
  1045  );
  1046  `
  1047  	case orm.DriverSqlite:
  1048  		return `
  1049  CREATE TABLE authors (
  1050    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
  1051    book_id int DEFAULT NULL,
  1052    name varchar(255) NOT NULL,
  1053    created_at datetime NOT NULL,
  1054    updated_at datetime NOT NULL
  1055  );
  1056  `
  1057  	case orm.DriverSqlserver:
  1058  		return `
  1059  CREATE TABLE authors (
  1060    id bigint NOT NULL IDENTITY(1,1),
  1061    book_id bigint DEFAULT NULL,
  1062    name varchar(255) NOT NULL,
  1063    created_at datetime NOT NULL,
  1064    updated_at datetime NOT NULL,
  1065    PRIMARY KEY (id)
  1066  );
  1067  `
  1068  	default:
  1069  		return ""
  1070  	}
  1071  }
  1072  
  1073  func (r Tables) createRoleTable(driver orm.Driver) string {
  1074  	switch driver {
  1075  	case orm.DriverMysql:
  1076  		return `
  1077  CREATE TABLE roles (
  1078    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  1079    name varchar(255) NOT NULL,
  1080    created_at datetime(3) NOT NULL,
  1081    updated_at datetime(3) NOT NULL,
  1082    PRIMARY KEY (id),
  1083    KEY idx_roles_created_at (created_at),
  1084    KEY idx_roles_updated_at (updated_at)
  1085  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
  1086  `
  1087  	case orm.DriverPostgresql:
  1088  		return `
  1089  CREATE TABLE roles (
  1090    id SERIAL PRIMARY KEY NOT NULL,
  1091    name varchar(255) NOT NULL,
  1092    created_at timestamp NOT NULL,
  1093    updated_at timestamp NOT NULL
  1094  );
  1095  `
  1096  	case orm.DriverSqlite:
  1097  		return `
  1098  CREATE TABLE roles (
  1099    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
  1100    name varchar(255) NOT NULL,
  1101    created_at datetime NOT NULL,
  1102    updated_at datetime NOT NULL
  1103  );
  1104  `
  1105  	case orm.DriverSqlserver:
  1106  		return `
  1107  CREATE TABLE roles (
  1108    id bigint NOT NULL IDENTITY(1,1),
  1109    name varchar(255) NOT NULL,
  1110    created_at datetime NOT NULL,
  1111    updated_at datetime NOT NULL,
  1112    PRIMARY KEY (id)
  1113  );
  1114  `
  1115  	default:
  1116  		return ""
  1117  	}
  1118  }
  1119  
  1120  func (r Tables) createHouseTable(driver orm.Driver) string {
  1121  	switch driver {
  1122  	case orm.DriverMysql:
  1123  		return `
  1124  CREATE TABLE houses (
  1125    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  1126    name varchar(255) NOT NULL,
  1127    houseable_id bigint(20) unsigned NOT NULL,
  1128    houseable_type varchar(255) NOT NULL,
  1129    created_at datetime(3) NOT NULL,
  1130    updated_at datetime(3) NOT NULL,
  1131    PRIMARY KEY (id),
  1132    KEY idx_houses_created_at (created_at),
  1133    KEY idx_houses_updated_at (updated_at)
  1134  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
  1135  `
  1136  	case orm.DriverPostgresql:
  1137  		return `
  1138  CREATE TABLE houses (
  1139    id SERIAL PRIMARY KEY NOT NULL,
  1140    name varchar(255) NOT NULL,
  1141    houseable_id int NOT NULL,
  1142    houseable_type varchar(255) NOT NULL,
  1143    created_at timestamp NOT NULL,
  1144    updated_at timestamp NOT NULL
  1145  );
  1146  `
  1147  	case orm.DriverSqlite:
  1148  		return `
  1149  CREATE TABLE houses (
  1150    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
  1151    name varchar(255) NOT NULL,
  1152    houseable_id int NOT NULL,
  1153    houseable_type varchar(255) NOT NULL,
  1154    created_at datetime NOT NULL,
  1155    updated_at datetime NOT NULL
  1156  );
  1157  `
  1158  	case orm.DriverSqlserver:
  1159  		return `
  1160  CREATE TABLE houses (
  1161    id bigint NOT NULL IDENTITY(1,1),
  1162    name varchar(255) NOT NULL,
  1163    houseable_id bigint NOT NULL,
  1164    houseable_type varchar(255) NOT NULL,
  1165    created_at datetime NOT NULL,
  1166    updated_at datetime NOT NULL,
  1167    PRIMARY KEY (id)
  1168  );
  1169  `
  1170  	default:
  1171  		return ""
  1172  	}
  1173  }
  1174  
  1175  func (r Tables) createPhoneTable(driver orm.Driver) string {
  1176  	switch driver {
  1177  	case orm.DriverMysql:
  1178  		return `
  1179  CREATE TABLE phones (
  1180    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  1181    name varchar(255) NOT NULL,
  1182    phoneable_id bigint(20) unsigned NOT NULL,
  1183    phoneable_type varchar(255) NOT NULL,
  1184    created_at datetime(3) NOT NULL,
  1185    updated_at datetime(3) NOT NULL,
  1186    PRIMARY KEY (id),
  1187    KEY idx_phones_created_at (created_at),
  1188    KEY idx_phones_updated_at (updated_at)
  1189  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
  1190  `
  1191  	case orm.DriverPostgresql:
  1192  		return `
  1193  CREATE TABLE phones (
  1194    id SERIAL PRIMARY KEY NOT NULL,
  1195    name varchar(255) NOT NULL,
  1196    phoneable_id int NOT NULL,
  1197    phoneable_type varchar(255) NOT NULL,
  1198    created_at timestamp NOT NULL,
  1199    updated_at timestamp NOT NULL
  1200  );
  1201  `
  1202  	case orm.DriverSqlite:
  1203  		return `
  1204  CREATE TABLE phones (
  1205    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
  1206    name varchar(255) NOT NULL,
  1207    phoneable_id int NOT NULL,
  1208    phoneable_type varchar(255) NOT NULL,
  1209    created_at datetime NOT NULL,
  1210    updated_at datetime NOT NULL
  1211  );
  1212  `
  1213  	case orm.DriverSqlserver:
  1214  		return `
  1215  CREATE TABLE phones (
  1216    id bigint NOT NULL IDENTITY(1,1),
  1217    name varchar(255) NOT NULL,
  1218    phoneable_id bigint NOT NULL,
  1219    phoneable_type varchar(255) NOT NULL,
  1220    created_at datetime NOT NULL,
  1221    updated_at datetime NOT NULL,
  1222    PRIMARY KEY (id)
  1223  );
  1224  `
  1225  	default:
  1226  		return ""
  1227  	}
  1228  }
  1229  
  1230  func (r Tables) createRoleUserTable(driver orm.Driver) string {
  1231  	switch driver {
  1232  	case orm.DriverMysql:
  1233  		return `
  1234  CREATE TABLE role_user (
  1235    id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  1236    role_id bigint(20) unsigned NOT NULL,
  1237    user_id bigint(20) unsigned NOT NULL,
  1238    PRIMARY KEY (id)
  1239  ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
  1240  `
  1241  	case orm.DriverPostgresql:
  1242  		return `
  1243  CREATE TABLE role_user (
  1244    id SERIAL PRIMARY KEY NOT NULL,
  1245    role_id int NOT NULL,
  1246    user_id int NOT NULL
  1247  );
  1248  `
  1249  	case orm.DriverSqlite:
  1250  		return `
  1251  CREATE TABLE role_user (
  1252    id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
  1253    role_id int NOT NULL,
  1254    user_id int NOT NULL
  1255  );
  1256  `
  1257  	case orm.DriverSqlserver:
  1258  		return `
  1259  CREATE TABLE role_user (
  1260    id bigint NOT NULL IDENTITY(1,1),
  1261    role_id bigint NOT NULL,
  1262    user_id bigint NOT NULL,
  1263    PRIMARY KEY (id)
  1264  );
  1265  `
  1266  	default:
  1267  		return ""
  1268  	}
  1269  }
  1270  
  1271  func mockPool(mockConfig *configmock.Config) {
  1272  	mockConfig.On("GetInt", "database.pool.max_idle_conns", 10).Return(10)
  1273  	mockConfig.On("GetInt", "database.pool.max_open_conns", 100).Return(100)
  1274  	mockConfig.On("GetInt", "database.pool.conn_max_idletime", 3600).Return(3600)
  1275  	mockConfig.On("GetInt", "database.pool.conn_max_lifetime", 3600).Return(3600)
  1276  }