diff --git a/README.md b/README.md
index fb46ca2..f2f1fff 100644
--- a/README.md
+++ b/README.md
@@ -227,12 +227,12 @@ func (m M0001CreateUserTable) Up(migrator *migrations.Migrator) error {
 
 func (m M0001CreateUserTable) Down(migrator *migrations.Migrator) error {
 	db := migrator.Database()
-	tableName := "user"
-	if !db.DBSchema().HasTable(tableName) {
+	table := "user"
+	if !db.DBSchema().HasTable(table) {
 		// if the table already doesn't exist, nothing to do here
 		return nil
 	}
-	_, err := db.SQLExecutor().Exec(db.SQLBuilder().DropTable(tableName))
+	_, err := db.SQLExecutor().Exec(db.SQLBuilder().DropTable(table))
 	return err
 }
 ```
@@ -245,28 +245,28 @@ type M0002AddUpdatedAtColumn struct{}
 
 func (m M0002AddUpdatedAtColumn) Up(migrator *migrations.Migrator) error {
 	db := migrator.Database()
-	tableName := "user"
+	table := "user"
 	col := schema.NewColumn(schema.NewColumnParams{Name: "updated_at", Type: schema.DateTime})
 
-	if db.DBSchema().HasColumn(tableName, col.Name()) {
+	if db.DBSchema().HasColumn(table, col.Name()) {
 		// if the column already exists, nothing to do here
 		return nil
 	}
 	
-	_, err := db.SQLExecutor().Exec(db.SQLBuilder().AlterTableAddColumn(tableName, col))
+	_, err := db.SQLExecutor().Exec(db.SQLBuilder().AlterTableAddColumn(table, col))
 	return err
 }
 
 func (m M0002AddUpdatedAtColumn) Down(migrator *migrations.Migrator) error {
 	db := migrator.Database()
-	tableName := "user"
+	table := "user"
 	colName := "updated_at"
 
-	if !db.DBSchema().HasColumn(tableName, colName) {
+	if !db.DBSchema().HasColumn(table, colName) {
 		// if the column already doesn't exist, nothing to do here
 		return nil
 	}
-	_, err := db.SQLExecutor().Exec(db.SQLBuilder().AlterTableDropColumn(tableName, colName))
+	_, err := db.SQLExecutor().Exec(db.SQLBuilder().AlterTableDropColumn(table, colName))
 	return err
 }
 ```
diff --git a/builder.go b/builder.go
index 95ff114..767d5c2 100644
--- a/builder.go
+++ b/builder.go
@@ -7,13 +7,13 @@ import (
 	"github.com/ordershift/ormshift/schema"
 )
 
-// DDSQLBuilder creates DDL (Data Definition Language) SQL commands for defining schema in DBMS.
+// DDLSQLBuilder creates DDL (Data Definition Language) SQL commands for defining schema in DBMS.
 type DDLSQLBuilder interface {
-	CreateTable(pTable schema.Table) string
-	DropTable(pTableName string) string
-	AlterTableAddColumn(pTableName string, pColumn schema.Column) string
-	AlterTableDropColumn(pTableName, pColumnName string) string
-	ColumnTypeAsString(pColumnType schema.ColumnType) string
+	CreateTable(table schema.Table) string
+	DropTable(table string) string
+	AlterTableAddColumn(table string, column schema.Column) string
+	AlterTableDropColumn(table, column string) string
+	ColumnTypeAsString(columnType schema.ColumnType) string
 }
 
 // ColumnsValues represents a mapping between column names and their corresponding values.
@@ -21,75 +21,75 @@ type ColumnsValues map[string]any
 
 // ToNamedArgs transforms ColumnsValues to a sql.NamedArg array ordered by name, e.g.:
 //
-//	lColumnsValues := ColumnsValues{"id": 5, "sku": "ZTX-9000", "is_simple": true}
-//	lNamedArgs := lColumnsValues.ToNamedArgs()
-//	//lNamedArgs == []sql.NamedArg{{Name: "id", Value: 5},{Name: "is_simple", Value: true},{Name: "sku", Value: "ZTX-9000"}}
+//	values := ColumnsValues{"id": 5, "sku": "ZTX-9000", "is_simple": true}
+//	args := values.ToNamedArgs()
+//	//args == []sql.NamedArg{{Name: "id", Value: 5},{Name: "is_simple", Value: true},{Name: "sku", Value: "ZTX-9000"}}
 func (cv *ColumnsValues) ToNamedArgs() []sql.NamedArg {
-	lNamedArgs := []sql.NamedArg{}
+	args := []sql.NamedArg{}
 	for c, v := range *cv {
-		lNamedArgs = append(lNamedArgs, sql.Named(c, v))
+		args = append(args, sql.Named(c, v))
 	}
-	slices.SortFunc(lNamedArgs, func(a, b sql.NamedArg) int {
+	slices.SortFunc(args, func(a, b sql.NamedArg) int {
 		if a.Name < b.Name {
 			return -1
 		}
 		return 1
 	})
-	return lNamedArgs
+	return args
 }
 
 // ToColumns returns the column names from ColumnsValues as a string array ordered by name, e.g.:
 func (cv *ColumnsValues) ToColumns() []string {
-	lColumns := []string{}
+	columns := []string{}
 	for c := range *cv {
-		lColumns = append(lColumns, c)
+		columns = append(columns, c)
 	}
-	slices.Sort(lColumns)
-	return lColumns
+	slices.Sort(columns)
+	return columns
 }
 
 // DMLSQLBuilder creates DML (Data Manipulation Language) SQL commands for manipulating data in DBMS.
 type DMLSQLBuilder interface {
-	Insert(pTableName string, pColumns []string) string
-	InsertWithValues(pTableName string, pColumnsValues ColumnsValues) (string, []any)
-	Update(pTableName string, pColumns, pColumnsWhere []string) string
-	UpdateWithValues(pTableName string, pColumns, pColumnsWhere []string, pValues ColumnsValues) (string, []any)
-	Delete(pTableName string, pColumnsWhere []string) string
-	DeleteWithValues(pTableName string, pWhereColumnsValues ColumnsValues) (string, []any)
-	Select(pTableName string, pColumns, pColumnsWhere []string) string
-	SelectWithValues(pTableName string, pColumns []string, pWhereColumnsValues ColumnsValues) (string, []any)
-	SelectWithPagination(pSQLSelectCommand string, pRowsPerPage, pPageNumber uint) string
+	Insert(table string, columns []string) string
+	InsertWithValues(table string, values ColumnsValues) (string, []any)
+	Update(table string, columns, where []string) string
+	UpdateWithValues(table string, columns, where []string, values ColumnsValues) (string, []any)
+	Delete(table string, where []string) string
+	DeleteWithValues(table string, where ColumnsValues) (string, []any)
+	Select(table string, columns, where []string) string
+	SelectWithValues(table string, columns []string, where ColumnsValues) (string, []any)
+	SelectWithPagination(sql string, size, number uint) string
 
 	// InteroperateSQLCommandWithNamedArgs acts as a SQL command translator that standardizes SQL commands according to the database driver being used e.g.,
 	//
-	//	pSQLCommand := "select * from user where id = @id"
-	//	pNamedArg := sql.Named("id", 123)
+	//	sql := "select * from user where id = @id"
+	//	namedArg := sql.Named("id", 123)
 	//
 	// PostgreSQL:
-	//	q, p := sqlbuilder.InteroperateSQLCommandWithNamedArgs(pSQLCommand, pNamedArg)
+	//	q, p := sqlbuilder.InteroperateSQLCommandWithNamedArgs(sql, namedArg)
 	//	//q == "select * from user where id = $1"
 	//	//p == 123
 	//
 	// SQLite:
-	//	q, p = sqlbuilder.InteroperateSQLCommandWithNamedArgs(pSQLCommand, pNamedArg)
+	//	q, p = sqlbuilder.InteroperateSQLCommandWithNamedArgs(sql, namedArg)
 	//	//q == "select * from user where id = @id"
 	//	//p == sql.Named("id", 123)
 	//
 	// SQL Server:
-	//	q, p = sqlbuilder.InteroperateSQLCommandWithNamedArgs(pSQLCommand, pNamedArg)
+	//	q, p = sqlbuilder.InteroperateSQLCommandWithNamedArgs(sql, namedArg)
 	//	//q == "select * from user where id = @id"
 	//	//p == sql.Named("id", 123)
 	//
 	// MySQL (not yet supported, expects question marks in parameters):
 	//
-	//	q, p = sqlbuilder.InteroperateSQLCommandWithNamedArgs(pSQLCommand, pNamedArg)
+	//	q, p = sqlbuilder.InteroperateSQLCommandWithNamedArgs(sql, namedArg)
 	//	//q == "select * from user where id = ?"
 	//	//p == 123
-	InteroperateSQLCommandWithNamedArgs(pSQLCommand string, pNamedArgs ...sql.NamedArg) (string, []any)
+	InteroperateSQLCommandWithNamedArgs(sql string, args ...sql.NamedArg) (string, []any)
 }
 
 type SQLBuilder interface {
 	DDLSQLBuilder
 	DMLSQLBuilder
-	QuoteIdentifier(pIdentifier string) string
+	QuoteIdentifier(identifier string) string
 }
diff --git a/builder_test.go b/builder_test.go
index f65c5f0..f83d5a5 100644
--- a/builder_test.go
+++ b/builder_test.go
@@ -8,21 +8,21 @@ import (
 )
 
 func TestColumnsValuesToNamedArgs(t *testing.T) {
-	lColumnsValues := ormshift.ColumnsValues{"id": 1, "sku": "ABC1234", "active": true}
-	lNamedArgs := lColumnsValues.ToNamedArgs()
-	testutils.AssertEqualWithLabel(t, 3, len(lNamedArgs), "ColumnsValues.ToNamedArgs")
-	testutils.AssertEqualWithLabel(t, lNamedArgs[0].Name, "active", "ColumnsValues.ToNamedArgs[0].Name")
-	testutils.AssertEqualWithLabel(t, lNamedArgs[0].Value, true, "ColumnsValues.ToNamedArgs[0].Value")
-	testutils.AssertEqualWithLabel(t, lNamedArgs[1].Name, "id", "ColumnsValues.ToNamedArgs[1].Name")
-	testutils.AssertEqualWithLabel(t, lNamedArgs[1].Value, 1, "ColumnsValues.ToNamedArgs[1].Value")
-	testutils.AssertEqualWithLabel(t, lNamedArgs[2].Name, "sku", "ColumnsValues.ToNamedArgs[2].Name")
-	testutils.AssertEqualWithLabel(t, lNamedArgs[2].Value, "ABC1234", "ColumnsValues.ToNamedArgs[2].Value")
+	values := ormshift.ColumnsValues{"id": 1, "sku": "ABC1234", "active": true}
+	args := values.ToNamedArgs()
+	testutils.AssertEqualWithLabel(t, 3, len(args), "ColumnsValues.ToNamedArgs")
+	testutils.AssertEqualWithLabel(t, args[0].Name, "active", "ColumnsValues.ToNamedArgs[0].Name")
+	testutils.AssertEqualWithLabel(t, args[0].Value, true, "ColumnsValues.ToNamedArgs[0].Value")
+	testutils.AssertEqualWithLabel(t, args[1].Name, "id", "ColumnsValues.ToNamedArgs[1].Name")
+	testutils.AssertEqualWithLabel(t, args[1].Value, 1, "ColumnsValues.ToNamedArgs[1].Value")
+	testutils.AssertEqualWithLabel(t, args[2].Name, "sku", "ColumnsValues.ToNamedArgs[2].Name")
+	testutils.AssertEqualWithLabel(t, args[2].Value, "ABC1234", "ColumnsValues.ToNamedArgs[2].Value")
 }
 
 func TestColumnsValuesToColumns(t *testing.T) {
-	lColumnsValues := ormshift.ColumnsValues{"id": 1, "sku": "ABC1234"}
-	lColumns := lColumnsValues.ToColumns()
-	testutils.AssertEqualWithLabel(t, 2, len(lColumns), "ColumnsValues.ToColumns")
-	testutils.AssertEqualWithLabel(t, lColumns[0], "id", "ColumnsValues.ToColumns[0]")
-	testutils.AssertEqualWithLabel(t, lColumns[1], "sku", "ColumnsValues.ToColumns[1]")
+	values := ormshift.ColumnsValues{"id": 1, "sku": "ABC1234"}
+	columns := values.ToColumns()
+	testutils.AssertEqualWithLabel(t, 2, len(columns), "ColumnsValues.ToColumns")
+	testutils.AssertEqualWithLabel(t, columns[0], "id", "ColumnsValues.ToColumns[0]")
+	testutils.AssertEqualWithLabel(t, columns[1], "sku", "ColumnsValues.ToColumns[1]")
 }
diff --git a/database.go b/database.go
index 29b3bff..180de03 100644
--- a/database.go
+++ b/database.go
@@ -20,9 +20,9 @@ type ConnectionParams struct {
 
 type DatabaseDriver interface {
 	Name() string
-	ConnectionString(pParams ConnectionParams) string
+	ConnectionString(params ConnectionParams) string
 	SQLBuilder() SQLBuilder
-	DBSchema(pDB *sql.DB) (*schema.DBSchema, error)
+	DBSchema(db *sql.DB) (*schema.DBSchema, error)
 }
 
 type Database struct {
@@ -33,26 +33,26 @@ type Database struct {
 	dbSchema         *schema.DBSchema
 }
 
-func OpenDatabase(pDriver DatabaseDriver, pParams ConnectionParams) (*Database, error) {
-	if pDriver == nil {
+func OpenDatabase(driver DatabaseDriver, params ConnectionParams) (*Database, error) {
+	if driver == nil {
 		return nil, errors.New("DatabaseDriver cannot be nil")
 	}
-	lConnectionString := pDriver.ConnectionString(pParams)
-	lDB, lError := sql.Open(pDriver.Name(), lConnectionString)
-	if lError != nil {
-		return nil, fmt.Errorf("sql.Open failed: %w", lError)
+	connectionString := driver.ConnectionString(params)
+	db, err := sql.Open(driver.Name(), connectionString)
+	if err != nil {
+		return nil, fmt.Errorf("sql.Open failed: %w", err)
 	}
-	lDBSchema, lError := pDriver.DBSchema(lDB)
-	if lError != nil {
-		return nil, fmt.Errorf("failed to get DB schema: %w", lError)
+	dbSchema, err := driver.DBSchema(db)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get DB schema: %w", err)
 	}
 
 	return &Database{
-		driver:           pDriver,
-		db:               lDB,
-		connectionString: lConnectionString,
-		sqlBuilder:       pDriver.SQLBuilder(),
-		dbSchema:         lDBSchema,
+		driver:           driver,
+		db:               db,
+		connectionString: connectionString,
+		sqlBuilder:       driver.SQLBuilder(),
+		dbSchema:         dbSchema,
 	}, nil
 }
 
diff --git a/database_test.go b/database_test.go
index 852b163..557a552 100644
--- a/database_test.go
+++ b/database_test.go
@@ -12,93 +12,93 @@ import (
 )
 
 func TestOpenDatabase(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	testutils.AssertNotNilResultAndNilError(t, lDB.DB(), nil, "Database.DB")
-	testutils.AssertEqualWithLabel(t, ":memory:", lDB.ConnectionString(), "Database.ConnectionString")
-	testutils.AssertEqualWithLabel(t, "sqlite", lDB.DriverName(), "Database.ConnectionString")
+	testutils.AssertNotNilResultAndNilError(t, db.DB(), nil, "Database.DB")
+	testutils.AssertEqualWithLabel(t, ":memory:", db.ConnectionString(), "Database.ConnectionString")
+	testutils.AssertEqualWithLabel(t, "sqlite", db.DriverName(), "Database.ConnectionString")
 
-	lUnderlyingDB := lDB.DB()
-	if !testutils.AssertNotNilResultAndNilError(t, lUnderlyingDB, nil, "Database.DB") {
+	underlyingDB := db.DB()
+	if !testutils.AssertNotNilResultAndNilError(t, underlyingDB, nil, "Database.DB") {
 		return
 	}
 }
 
 func TestOpenDatabaseWithNilDriver(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(nil, ormshift.ConnectionParams{})
-	if !testutils.AssertNilResultAndNotNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(nil, ormshift.ConnectionParams{})
+	if !testutils.AssertNilResultAndNotNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "DatabaseDriver cannot be nil", lError, "ormshift.OpenDatabase")
+	testutils.AssertErrorMessage(t, "DatabaseDriver cannot be nil", err, "ormshift.OpenDatabase")
 }
 
 func TestOpenDatabaseWithBadDriver(t *testing.T) {
-	lDriver := testutils.NewFakeDriverBadName(sqlite.Driver())
-	lDB, lError := ormshift.OpenDatabase(lDriver, ormshift.ConnectionParams{})
-	if !testutils.AssertNilResultAndNotNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	driver := testutils.NewFakeDriverBadName(sqlite.Driver())
+	db, err := ormshift.OpenDatabase(driver, ormshift.ConnectionParams{})
+	if !testutils.AssertNilResultAndNotNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "sql.Open failed: sql: unknown driver \"bad-driver-name\" (forgotten import?)", lError, "ormshift.OpenDatabase")
+	testutils.AssertErrorMessage(t, "sql.Open failed: sql: unknown driver \"bad-driver-name\" (forgotten import?)", err, "ormshift.OpenDatabase")
 }
 
 func TestOpenDatabaseWithBadSchema(t *testing.T) {
-	lDriver := testutils.NewFakeDriverBadSchema(sqlite.Driver())
-	lDB, lError := ormshift.OpenDatabase(lDriver, ormshift.ConnectionParams{})
-	if !testutils.AssertNilResultAndNotNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	driver := testutils.NewFakeDriverBadSchema(sqlite.Driver())
+	db, err := ormshift.OpenDatabase(driver, ormshift.ConnectionParams{})
+	if !testutils.AssertNilResultAndNotNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "failed to get DB schema: intentionally bad schema", lError, "ormshift.OpenDatabase")
+	testutils.AssertErrorMessage(t, "failed to get DB schema: intentionally bad schema", err, "ormshift.OpenDatabase")
 }
 
 func TestClose(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
 
-	lError = lDB.DB().Ping()
-	if !testutils.AssertNilError(t, lError, "Database.DB.Ping") {
-		_ = lDB.Close()
+	err = db.DB().Ping()
+	if !testutils.AssertNilError(t, err, "Database.DB.Ping") {
+		_ = db.Close()
 		return
 	}
 
-	lError = lDB.Close()
-	testutils.AssertNilError(t, lError, "Database.Close")
+	err = db.Close()
+	testutils.AssertNilError(t, err, "Database.Close")
 
-	lError = lDB.DB().Ping()
-	testutils.AssertErrorMessage(t, "sql: database is closed", lError, "Database.DB.Ping")
+	err = db.DB().Ping()
+	testutils.AssertErrorMessage(t, "sql: database is closed", err, "Database.DB.Ping")
 }
 
 func TestConnectionStringWithNoParams(t *testing.T) {
-	lConnectionParams := ormshift.ConnectionParams{InMemory: true}
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), lConnectionParams)
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	connectionParams := ormshift.ConnectionParams{InMemory: true}
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), connectionParams)
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lExpectedConnectionString := ":memory:"
-	lReturnedConnectionString := lDB.ConnectionString()
-	testutils.AssertEqualWithLabel(t, lExpectedConnectionString, lReturnedConnectionString, "Database.ConnectionString")
+	expectedConnectionString := ":memory:"
+	returnedConnectionString := db.ConnectionString()
+	testutils.AssertEqualWithLabel(t, expectedConnectionString, returnedConnectionString, "Database.ConnectionString")
 
 	// Connection string should not be modified if the connection params is changed
-	lConnectionParams.InMemory = false
-	lReturnedConnectionString = lDB.ConnectionString()
-	testutils.AssertEqualWithLabel(t, lExpectedConnectionString, lReturnedConnectionString, "Database.ConnectionString")
+	connectionParams.InMemory = false
+	returnedConnectionString = db.ConnectionString()
+	testutils.AssertEqualWithLabel(t, expectedConnectionString, returnedConnectionString, "Database.ConnectionString")
 }
 
 func TestDriverName(t *testing.T) {
-	lDriver := testutils.NewFakeDriver(sqlite.Driver())
-	testutils.AssertEqualWithLabel(t, "sqlite", lDriver.Name(), "FakeDriver.Name")
+	driver := testutils.NewFakeDriver(sqlite.Driver())
+	testutils.AssertEqualWithLabel(t, "sqlite", driver.Name(), "FakeDriver.Name")
 }
 
 func TestDriverConnectionString(t *testing.T) {
-	lDriver := testutils.NewFakeDriver(sqlserver.Driver())
-	lConnectionParams := ormshift.ConnectionParams{
+	driver := testutils.NewFakeDriver(sqlserver.Driver())
+	connectionParams := ormshift.ConnectionParams{
 		Host:     "localhost",
 		Port:     1433,
 		User:     "sa",
@@ -106,37 +106,37 @@ func TestDriverConnectionString(t *testing.T) {
 		Database: "testdb",
 	}
 
-	lReturnedConnectionString := lDriver.ConnectionString(lConnectionParams)
-	lExpectedConnectionString := "server=localhost;port=1433;user id=sa;password=your_password;database=testdb"
-	testutils.AssertEqualWithLabel(t, lExpectedConnectionString, lReturnedConnectionString, "FakeDriver.ConnectionString")
+	returnedConnectionString := driver.ConnectionString(connectionParams)
+	expectedConnectionString := "server=localhost;port=1433;user id=sa;password=your_password;database=testdb"
+	testutils.AssertEqualWithLabel(t, expectedConnectionString, returnedConnectionString, "FakeDriver.ConnectionString")
 
-	lConnectionParams = ormshift.ConnectionParams{
+	connectionParams = ormshift.ConnectionParams{
 		Instance: "myServerName\\myInstanceName",
 		User:     "sa",
 		Password: "your_password",
 		Database: "testdb",
 	}
-	lReturnedConnectionString = lDriver.ConnectionString(lConnectionParams)
-	lExpectedConnectionString = "server=\\myServerName\\myInstanceName;user id=sa;password=your_password;database=testdb"
-	testutils.AssertEqualWithLabel(t, lExpectedConnectionString, lReturnedConnectionString, "FakeDriver.ConnectionString")
+	returnedConnectionString = driver.ConnectionString(connectionParams)
+	expectedConnectionString = "server=\\myServerName\\myInstanceName;user id=sa;password=your_password;database=testdb"
+	testutils.AssertEqualWithLabel(t, expectedConnectionString, returnedConnectionString, "FakeDriver.ConnectionString")
 }
 
 func TestDriverSQLBuilder(t *testing.T) {
-	lDriver := testutils.NewFakeDriver(sqlite.Driver())
-	lSQLBuilder := lDriver.SQLBuilder()
-	testutils.AssertEqualWithLabel(t, "sqliteBuilder", reflect.TypeOf(lSQLBuilder).Elem().Name(), "FakeDriver.SQLBuilder")
+	driver := testutils.NewFakeDriver(sqlite.Driver())
+	sqlBuilder := driver.SQLBuilder()
+	testutils.AssertEqualWithLabel(t, "sqliteBuilder", reflect.TypeOf(sqlBuilder).Elem().Name(), "FakeDriver.SQLBuilder")
 }
 
 func TestDriverDBSchema(t *testing.T) {
-	lDriver := testutils.NewFakeDriver(sqlite.Driver())
-	lDB, lError := sql.Open(lDriver.Name(), lDriver.ConnectionString(ormshift.ConnectionParams{InMemory: true}))
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "sql.Open") {
+	driver := testutils.NewFakeDriver(sqlite.Driver())
+	db, err := sql.Open(driver.Name(), driver.ConnectionString(ormshift.ConnectionParams{InMemory: true}))
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "sql.Open") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lSchema, lError := lDriver.DBSchema(lDB)
-	if !testutils.AssertNotNilResultAndNilError(t, lSchema, lError, "FakeDriver.DBSchema") {
+	schema, err := driver.DBSchema(db)
+	if !testutils.AssertNotNilResultAndNilError(t, schema, err, "FakeDriver.DBSchema") {
 		return
 	}
 }
diff --git a/dialects/postgresql/builder.go b/dialects/postgresql/builder.go
index ba0fd99..9d16d68 100644
--- a/dialects/postgresql/builder.go
+++ b/dialects/postgresql/builder.go
@@ -21,24 +21,24 @@ func newPostgreSQLBuilder() ormshift.SQLBuilder {
 	return &sb
 }
 
-func (sb *postgresqlBuilder) CreateTable(pTable schema.Table) string {
-	return sb.generic.CreateTable(pTable)
+func (sb *postgresqlBuilder) CreateTable(table schema.Table) string {
+	return sb.generic.CreateTable(table)
 }
 
-func (sb *postgresqlBuilder) DropTable(pTableName string) string {
-	return sb.generic.DropTable(pTableName)
+func (sb *postgresqlBuilder) DropTable(table string) string {
+	return sb.generic.DropTable(table)
 }
 
-func (sb *postgresqlBuilder) AlterTableAddColumn(pTableName string, pColumn schema.Column) string {
-	return sb.generic.AlterTableAddColumn(pTableName, pColumn)
+func (sb *postgresqlBuilder) AlterTableAddColumn(table string, column schema.Column) string {
+	return sb.generic.AlterTableAddColumn(table, column)
 }
 
-func (sb *postgresqlBuilder) AlterTableDropColumn(pTableName, pColumnName string) string {
-	return sb.generic.AlterTableDropColumn(pTableName, pColumnName)
+func (sb *postgresqlBuilder) AlterTableDropColumn(table, column string) string {
+	return sb.generic.AlterTableDropColumn(table, column)
 }
 
-func (sb *postgresqlBuilder) ColumnTypeAsString(pColumnType schema.ColumnType) string {
-	switch pColumnType {
+func (sb *postgresqlBuilder) ColumnTypeAsString(columnType schema.ColumnType) string {
+	switch columnType {
 	case schema.Varchar:
 		return "VARCHAR"
 	case schema.Boolean:
@@ -58,87 +58,86 @@ func (sb *postgresqlBuilder) ColumnTypeAsString(pColumnType schema.ColumnType) s
 	}
 }
 
-func (sb *postgresqlBuilder) columnDefinition(pColumn schema.Column) string {
-	lColumnDef := sb.QuoteIdentifier(pColumn.Name())
-	if pColumn.AutoIncrement() {
-		lColumnDef += " BIGSERIAL"
+func (sb *postgresqlBuilder) columnDefinition(column schema.Column) string {
+	columnDef := sb.QuoteIdentifier(column.Name())
+	if column.AutoIncrement() {
+		columnDef += " BIGSERIAL"
 	} else {
-		if pColumn.Type() == schema.Varchar {
-			lColumnDef += fmt.Sprintf(" %s(%d)", sb.ColumnTypeAsString(pColumn.Type()), pColumn.Size())
+		if column.Type() == schema.Varchar {
+			columnDef += fmt.Sprintf(" %s(%d)", sb.ColumnTypeAsString(column.Type()), column.Size())
 		} else {
-			lColumnDef += fmt.Sprintf(" %s", sb.ColumnTypeAsString(pColumn.Type()))
+			columnDef += fmt.Sprintf(" %s", sb.ColumnTypeAsString(column.Type()))
 		}
 	}
-	if pColumn.NotNull() {
-		lColumnDef += " NOT NULL"
+	if column.NotNull() {
+		columnDef += " NOT NULL"
 	}
-	return lColumnDef
+	return columnDef
 }
 
-func (sb *postgresqlBuilder) Insert(pTableName string, pColumns []string) string {
-	return sb.generic.Insert(pTableName, pColumns)
+func (sb *postgresqlBuilder) Insert(table string, columns []string) string {
+	return sb.generic.Insert(table, columns)
 }
 
-func (sb *postgresqlBuilder) InsertWithValues(pTableName string, pColumnsValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.InsertWithValues(pTableName, pColumnsValues)
+func (sb *postgresqlBuilder) InsertWithValues(table string, values ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.InsertWithValues(table, values)
 }
 
-func (sb *postgresqlBuilder) Update(pTableName string, pColumns, pColumnsWhere []string) string {
-	return sb.generic.Update(pTableName, pColumns, pColumnsWhere)
+func (sb *postgresqlBuilder) Update(table string, columns, where []string) string {
+	return sb.generic.Update(table, columns, where)
 }
 
-func (sb *postgresqlBuilder) UpdateWithValues(pTableName string, pColumns, pColumnsWhere []string, pValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.UpdateWithValues(pTableName, pColumns, pColumnsWhere, pValues)
+func (sb *postgresqlBuilder) UpdateWithValues(table string, columns, where []string, values ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.UpdateWithValues(table, columns, where, values)
 }
 
-func (sb *postgresqlBuilder) Delete(pTableName string, pColumnsWhere []string) string {
-	return sb.generic.Delete(pTableName, pColumnsWhere)
+func (sb *postgresqlBuilder) Delete(table string, where []string) string {
+	return sb.generic.Delete(table, where)
 }
 
-func (sb *postgresqlBuilder) DeleteWithValues(pTableName string, pWhereColumnsValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.DeleteWithValues(pTableName, pWhereColumnsValues)
+func (sb *postgresqlBuilder) DeleteWithValues(table string, where ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.DeleteWithValues(table, where)
 }
 
-func (sb *postgresqlBuilder) Select(pTableName string, pColumns, pColumnsWhere []string) string {
-	return sb.generic.Select(pTableName, pColumns, pColumnsWhere)
+func (sb *postgresqlBuilder) Select(table string, columns, where []string) string {
+	return sb.generic.Select(table, columns, where)
 }
 
-func (sb *postgresqlBuilder) SelectWithValues(pTableName string, pColumns []string, pWhereColumnsValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.SelectWithValues(pTableName, pColumns, pWhereColumnsValues)
+func (sb *postgresqlBuilder) SelectWithValues(table string, columns []string, where ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.SelectWithValues(table, columns, where)
 }
 
-func (sb *postgresqlBuilder) SelectWithPagination(pSQLSelectCommand string, pRowsPerPage, pPageNumber uint) string {
-	return sb.generic.SelectWithPagination(pSQLSelectCommand, pRowsPerPage, pPageNumber)
+func (sb *postgresqlBuilder) SelectWithPagination(sql string, size, number uint) string {
+	return sb.generic.SelectWithPagination(sql, size, number)
 }
 
-func (sb *postgresqlBuilder) QuoteIdentifier(pIdentifier string) string {
-	return sb.generic.QuoteIdentifier(pIdentifier)
+func (sb *postgresqlBuilder) QuoteIdentifier(identifier string) string {
+	return sb.generic.QuoteIdentifier(identifier)
 }
 
-func (sb *postgresqlBuilder) InteroperateSQLCommandWithNamedArgs(pSQLCommand string, pNamedArgs ...sql.NamedArg) (string, []any) {
-	lSQLCommand := pSQLCommand
-	lArgs := []any{}
-	lIndexes := map[string]int{}
-	for i, lParam := range pNamedArgs {
-		lIndexes[strings.ToLower(lParam.Name)] = i + 1
-		lBooleanValue, lIsBoolean := lParam.Value.(bool)
-		if lIsBoolean {
-			if lBooleanValue {
-				lArgs = append(lArgs, int(1))
+func (sb *postgresqlBuilder) InteroperateSQLCommandWithNamedArgs(sql string, args ...sql.NamedArg) (string, []any) {
+	a := []any{}
+	indexes := map[string]int{}
+	for i, param := range args {
+		indexes[strings.ToLower(param.Name)] = i + 1
+		booleanValue, isBoolean := param.Value.(bool)
+		if isBoolean {
+			if booleanValue {
+				a = append(a, int(1))
 			} else {
-				lArgs = append(lArgs, int(0))
+				a = append(a, int(0))
 			}
 		} else {
-			lArgs = append(lArgs, lParam.Value)
+			a = append(a, param.Value)
 		}
 	}
-	lRegex := regexp.MustCompile(`@([a-zA-Z_][a-zA-Z0-9_]*)`)
-	lSQLCommand = lRegex.ReplaceAllStringFunc(lSQLCommand, func(m string) string {
-		lName := m[1:]
-		if idx, ok := lIndexes[strings.ToLower(lName)]; ok {
+	regex := regexp.MustCompile(`@([a-zA-Z_][a-zA-Z0-9_]*)`)
+	sql = regex.ReplaceAllStringFunc(sql, func(m string) string {
+		name := m[1:]
+		if idx, ok := indexes[strings.ToLower(name)]; ok {
 			return fmt.Sprintf("$%d", idx)
 		}
 		return m
 	})
-	return lSQLCommand, lArgs
+	return sql, a
 }
diff --git a/dialects/postgresql/builder_test.go b/dialects/postgresql/builder_test.go
index 62a838f..6a18f44 100644
--- a/dialects/postgresql/builder_test.go
+++ b/dialects/postgresql/builder_test.go
@@ -10,160 +10,160 @@ import (
 )
 
 func TestInteroperateSQLCommandWithNamedArgs(t *testing.T) {
-	lDriver := postgresql.Driver()
-	lReturnedSQL, lReturnedValue := lDriver.SQLBuilder().InteroperateSQLCommandWithNamedArgs(
+	driver := postgresql.Driver()
+	returnedSQL, returnedValue := driver.SQLBuilder().InteroperateSQLCommandWithNamedArgs(
 		"select * from user where role = @role and active = @active and master = @master",
 		sql.Named("role", "admin"),
 		sql.Named("active", true),
 		sql.Named("master", false),
 	)
-	lExpectedSQL := "select * from user where role = $1 and active = $2 and master = $3"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.SQL")
-	testutils.AssertEqualWithLabel(t, "admin", lReturnedValue[0].(string), "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.Value.1")
-	testutils.AssertEqualWithLabel(t, 1, lReturnedValue[1].(int), "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.Value.2")
-	testutils.AssertEqualWithLabel(t, 0, lReturnedValue[2].(int), "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.Value.3")
-	lReturnedSQL, lReturnedValue = lDriver.SQLBuilder().InteroperateSQLCommandWithNamedArgs(
+	expectedSQL := "select * from user where role = $1 and active = $2 and master = $3"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.SQL")
+	testutils.AssertEqualWithLabel(t, "admin", returnedValue[0].(string), "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.Value.1")
+	testutils.AssertEqualWithLabel(t, 1, returnedValue[1].(int), "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.Value.2")
+	testutils.AssertEqualWithLabel(t, 0, returnedValue[2].(int), "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.Value.3")
+	returnedSQL, returnedValue = driver.SQLBuilder().InteroperateSQLCommandWithNamedArgs(
 		"update user set role = @role where role = @role",
 		sql.Named("role", "admin"),
 	)
-	lExpectedSQL = "update user set role = $1 where role = $1"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.SQL")
-	testutils.AssertEqualWithLabel(t, "admin", lReturnedValue[0].(string), "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.Value.1")
-	lReturnedSQL, lReturnedValue = lDriver.SQLBuilder().InteroperateSQLCommandWithNamedArgs(
+	expectedSQL = "update user set role = $1 where role = $1"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.SQL")
+	testutils.AssertEqualWithLabel(t, "admin", returnedValue[0].(string), "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.Value.1")
+	returnedSQL, returnedValue = driver.SQLBuilder().InteroperateSQLCommandWithNamedArgs(
 		"delete from user where id = @id",
 		sql.Named("role", "admin"),
 	)
-	lExpectedSQL = "delete from user where id = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.SQL")
-	testutils.AssertEqualWithLabel(t, "admin", lReturnedValue[0].(string), "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.Value.1")
+	expectedSQL = "delete from user where id = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.SQL")
+	testutils.AssertEqualWithLabel(t, "admin", returnedValue[0].(string), "DriverPostgresql.InteroperateSQLCommandWithNamedArgs.Value.1")
 }
 
 func TestCreateTable(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
+	sqlBuilder := postgresql.Driver().SQLBuilder()
 
-	lUserTable := testutils.FakeUserTable(t)
-	lExpectedSQL := "CREATE TABLE \"user\" (\"id\" BIGSERIAL NOT NULL,\"email\" VARCHAR(80) NOT NULL,\"name\" VARCHAR(50) NOT NULL," +
+	userTable := testutils.FakeUserTable(t)
+	expectedSQL := "CREATE TABLE \"user\" (\"id\" BIGSERIAL NOT NULL,\"email\" VARCHAR(80) NOT NULL,\"name\" VARCHAR(50) NOT NULL," +
 		"\"password_hash\" VARCHAR(256),\"active\" SMALLINT,\"created_at\" TIMESTAMP(6),\"user_master\" BIGINT,\"master_user_id\" BIGINT," +
 		"\"licence_price\" NUMERIC(17,2),\"relevance\" DOUBLE PRECISION,\"photo\" BYTEA,\"any\" VARCHAR,PRIMARY KEY (\"id\",\"email\"));"
-	lReturnedSQL := lSQLBuilder.CreateTable(lUserTable)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.CreateTable")
+	returnedSQL := sqlBuilder.CreateTable(userTable)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.CreateTable")
 
-	lProductAttributeTable := testutils.FakeProductAttributeTable(t)
-	lExpectedSQL = "CREATE TABLE \"product_attribute\" (\"product_id\" BIGINT NOT NULL,\"attribute_id\" BIGINT NOT NULL,\"value\" VARCHAR(75),\"position\" BIGINT,PRIMARY KEY (\"product_id\",\"attribute_id\"));"
-	lReturnedSQL = lSQLBuilder.CreateTable(lProductAttributeTable)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.CreateTable")
+	productAttributeTable := testutils.FakeProductAttributeTable(t)
+	expectedSQL = "CREATE TABLE \"product_attribute\" (\"product_id\" BIGINT NOT NULL,\"attribute_id\" BIGINT NOT NULL,\"value\" VARCHAR(75),\"position\" BIGINT,PRIMARY KEY (\"product_id\",\"attribute_id\"));"
+	returnedSQL = sqlBuilder.CreateTable(productAttributeTable)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.CreateTable")
 }
 
 func TestDropTable(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
+	sqlBuilder := postgresql.Driver().SQLBuilder()
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lExpectedSQL := "DROP TABLE \"user\";"
-	lReturnedSQL := lSQLBuilder.DropTable(lUserTableName)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.DropTable")
+	userTableName := testutils.FakeUserTableName(t)
+	expectedSQL := "DROP TABLE \"user\";"
+	returnedSQL := sqlBuilder.DropTable(userTableName)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.DropTable")
 }
 
 func TestAlterTableAddColumn(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
+	sqlBuilder := postgresql.Driver().SQLBuilder()
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lUpdatedAtColumn := testutils.FakeUpdatedAtColumn(t)
-	lExpectedSQL := "ALTER TABLE \"user\" ADD COLUMN \"updated_at\" TIMESTAMP(6);"
-	lReturnedSQL := lSQLBuilder.AlterTableAddColumn(lUserTableName, lUpdatedAtColumn)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.AlterTableAddColumn")
+	userTableName := testutils.FakeUserTableName(t)
+	updatedAtColumn := testutils.FakeUpdatedAtColumn(t)
+	expectedSQL := "ALTER TABLE \"user\" ADD COLUMN \"updated_at\" TIMESTAMP(6);"
+	returnedSQL := sqlBuilder.AlterTableAddColumn(userTableName, updatedAtColumn)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.AlterTableAddColumn")
 }
 
 func TestAlterTableDropColumn(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
+	sqlBuilder := postgresql.Driver().SQLBuilder()
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lUpdatedAtColumnName := testutils.FakeUpdatedAtColumnName(t)
-	lExpectedSQL := "ALTER TABLE \"user\" DROP COLUMN \"updated_at\";"
-	lReturnedSQL := lSQLBuilder.AlterTableDropColumn(lUserTableName, lUpdatedAtColumnName)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.AlterTableDropColumn")
+	userTableName := testutils.FakeUserTableName(t)
+	updatedAtColumnName := testutils.FakeUpdatedAtColumnName(t)
+	expectedSQL := "ALTER TABLE \"user\" DROP COLUMN \"updated_at\";"
+	returnedSQL := sqlBuilder.AlterTableDropColumn(userTableName, updatedAtColumnName)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.AlterTableDropColumn")
 }
 
 func TestInsert(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
+	sqlBuilder := postgresql.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Insert("product", []string{"id", "sku", "name", "description"})
-	lExpectedSQL := "insert into \"product\" (\"id\",\"sku\",\"name\",\"description\") values (@id,@sku,@name,@description)"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Insert")
+	returnedSQL := sqlBuilder.Insert("product", []string{"id", "sku", "name", "description"})
+	expectedSQL := "insert into \"product\" (\"id\",\"sku\",\"name\",\"description\") values (@id,@sku,@name,@description)"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Insert")
 }
 
 func TestInsertWithValues(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
-
-	lReturnedSQL, lReturnedValues := lSQLBuilder.InsertWithValues("product", ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.9", "name": "Trufa Sabor Amarula 30g Cacaushow"})
-	lExpectedSQL := "insert into \"product\" (\"id\",\"name\",\"sku\") values ($1,$2,$3)"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.InsertWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 3, len(lReturnedValues), "SQLBuilder.InsertWithValues.Values")
-	testutils.AssertEqualWithLabel(t, 1, lReturnedValues[0], "SQLBuilder.InsertWithValues.Values[0]")
-	testutils.AssertEqualWithLabel(t, "Trufa Sabor Amarula 30g Cacaushow", lReturnedValues[1], "SQLBuilder.InsertWithValues.Values[1]")
-	testutils.AssertEqualWithLabel(t, "1.005.12.9", lReturnedValues[2], "SQLBuilder.InsertWithValues.Values[2]")
+	sqlBuilder := postgresql.Driver().SQLBuilder()
+
+	returnedSQL, returnedValues := sqlBuilder.InsertWithValues("product", ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.9", "name": "Trufa Sabor Amarula 30g Cacaushow"})
+	expectedSQL := "insert into \"product\" (\"id\",\"name\",\"sku\") values ($1,$2,$3)"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.InsertWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 3, len(returnedValues), "SQLBuilder.InsertWithValues.Values")
+	testutils.AssertEqualWithLabel(t, 1, returnedValues[0], "SQLBuilder.InsertWithValues.Values[0]")
+	testutils.AssertEqualWithLabel(t, "Trufa Sabor Amarula 30g Cacaushow", returnedValues[1], "SQLBuilder.InsertWithValues.Values[1]")
+	testutils.AssertEqualWithLabel(t, "1.005.12.9", returnedValues[2], "SQLBuilder.InsertWithValues.Values[2]")
 }
 
 func TestUpdate(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
+	sqlBuilder := postgresql.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Update("product", []string{"sku", "name", "description"}, []string{"id"})
-	lExpectedSQL := "update \"product\" set \"sku\" = @sku,\"name\" = @name,\"description\" = @description where \"id\" = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Update")
+	returnedSQL := sqlBuilder.Update("product", []string{"sku", "name", "description"}, []string{"id"})
+	expectedSQL := "update \"product\" set \"sku\" = @sku,\"name\" = @name,\"description\" = @description where \"id\" = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Update")
 }
 
 func TestUpdateWithValues(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
-
-	lReturnedSQL, lReturnedValues := lSQLBuilder.UpdateWithValues("product", []string{"sku", "name"}, []string{"id"}, ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.5", "name": "Trufa Sabor Amarula 18g Cacaushow"})
-	lExpectedSQL := "update \"product\" set \"sku\" = $3,\"name\" = $2 where \"id\" = $1"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.UpdateWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 3, len(lReturnedValues), "SQLBuilder.UpdateWithValues.Values")
-	testutils.AssertEqualWithLabel(t, 1, lReturnedValues[0], "SQLBuilder.UpdateWithValues.Values[0]")
-	testutils.AssertEqualWithLabel(t, "Trufa Sabor Amarula 18g Cacaushow", lReturnedValues[1], "SQLBuilder.UpdateWithValues.Values[1]")
-	testutils.AssertEqualWithLabel(t, "1.005.12.5", lReturnedValues[2], "SQLBuilder.UpdateWithValues.Values[2]")
+	sqlBuilder := postgresql.Driver().SQLBuilder()
+
+	returnedSQL, returnedValues := sqlBuilder.UpdateWithValues("product", []string{"sku", "name"}, []string{"id"}, ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.5", "name": "Trufa Sabor Amarula 18g Cacaushow"})
+	expectedSQL := "update \"product\" set \"sku\" = $3,\"name\" = $2 where \"id\" = $1"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.UpdateWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 3, len(returnedValues), "SQLBuilder.UpdateWithValues.Values")
+	testutils.AssertEqualWithLabel(t, 1, returnedValues[0], "SQLBuilder.UpdateWithValues.Values[0]")
+	testutils.AssertEqualWithLabel(t, "Trufa Sabor Amarula 18g Cacaushow", returnedValues[1], "SQLBuilder.UpdateWithValues.Values[1]")
+	testutils.AssertEqualWithLabel(t, "1.005.12.5", returnedValues[2], "SQLBuilder.UpdateWithValues.Values[2]")
 }
 
 func TestDelete(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
+	sqlBuilder := postgresql.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Delete("product", []string{"id"})
-	lExpectedSQL := "delete from \"product\" where \"id\" = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Delete")
+	returnedSQL := sqlBuilder.Delete("product", []string{"id"})
+	expectedSQL := "delete from \"product\" where \"id\" = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Delete")
 }
 
 func TestDeleteWithValues(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
+	sqlBuilder := postgresql.Driver().SQLBuilder()
 
-	lReturnedSQL, lReturnedValues := lSQLBuilder.DeleteWithValues("product", ormshift.ColumnsValues{"id": 1})
-	lExpectedSQL := "delete from \"product\" where \"id\" = $1"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.DeleteWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 1, len(lReturnedValues), "SQLBuilder.DeleteWithValues.Values")
-	testutils.AssertEqualWithLabel(t, 1, lReturnedValues[0], "SQLBuilder.DeleteWithValues.Values[0]")
+	returnedSQL, returnedValues := sqlBuilder.DeleteWithValues("product", ormshift.ColumnsValues{"id": 1})
+	expectedSQL := "delete from \"product\" where \"id\" = $1"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.DeleteWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 1, len(returnedValues), "SQLBuilder.DeleteWithValues.Values")
+	testutils.AssertEqualWithLabel(t, 1, returnedValues[0], "SQLBuilder.DeleteWithValues.Values[0]")
 }
 
 func TestSelect(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
+	sqlBuilder := postgresql.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Select("product", []string{"id", "name", "description"}, []string{"sku", "active"})
-	lExpectedSQL := "select \"id\",\"name\",\"description\" from \"product\" where \"sku\" = @sku and \"active\" = @active"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Select")
+	returnedSQL := sqlBuilder.Select("product", []string{"id", "name", "description"}, []string{"sku", "active"})
+	expectedSQL := "select \"id\",\"name\",\"description\" from \"product\" where \"sku\" = @sku and \"active\" = @active"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Select")
 }
 
 func TestSelectWithValues(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
-
-	lReturnedSQL, lReturnedValues := lSQLBuilder.SelectWithValues("product", []string{"id", "sku", "name", "description"}, ormshift.ColumnsValues{"category_id": 1, "active": true})
-	lExpectedSQL := "select \"id\",\"sku\",\"name\",\"description\" from \"product\" where \"active\" = $1 and \"category_id\" = $2"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.SelectWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 2, len(lReturnedValues), "SQLBuilder.SelectWithValues.Values")
-	testutils.AssertEqualWithLabel(t, 1, lReturnedValues[0], "SQLBuilder.SelectWithValues.Values[0]")
-	testutils.AssertEqualWithLabel(t, 1, lReturnedValues[1], "SQLBuilder.SelectWithValues.Values[1]")
+	sqlBuilder := postgresql.Driver().SQLBuilder()
+
+	returnedSQL, returnedValues := sqlBuilder.SelectWithValues("product", []string{"id", "sku", "name", "description"}, ormshift.ColumnsValues{"category_id": 1, "active": true})
+	expectedSQL := "select \"id\",\"sku\",\"name\",\"description\" from \"product\" where \"active\" = $1 and \"category_id\" = $2"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.SelectWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 2, len(returnedValues), "SQLBuilder.SelectWithValues.Values")
+	testutils.AssertEqualWithLabel(t, 1, returnedValues[0], "SQLBuilder.SelectWithValues.Values[0]")
+	testutils.AssertEqualWithLabel(t, 1, returnedValues[1], "SQLBuilder.SelectWithValues.Values[1]")
 }
 
 func TestSelectWithPagination(t *testing.T) {
-	lSQLBuilder := postgresql.Driver().SQLBuilder()
+	sqlBuilder := postgresql.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.SelectWithPagination("select * from product", 10, 5)
-	lExpectedSQL := "select * from product LIMIT 10 OFFSET 40"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.SelectWithPagination")
+	returnedSQL := sqlBuilder.SelectWithPagination("select * from product", 10, 5)
+	expectedSQL := "select * from product LIMIT 10 OFFSET 40"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.SelectWithPagination")
 }
diff --git a/dialects/postgresql/driver.go b/dialects/postgresql/driver.go
index 1123ac7..35e6fc4 100644
--- a/dialects/postgresql/driver.go
+++ b/dialects/postgresql/driver.go
@@ -25,22 +25,22 @@ func (d *postgresqlDriver) Name() string {
 	return "postgres"
 }
 
-func (d *postgresqlDriver) ConnectionString(pParams ormshift.ConnectionParams) string {
-	lHost := pParams.Host
-	if lHost == "" {
-		lHost = "localhost"
+func (d *postgresqlDriver) ConnectionString(params ormshift.ConnectionParams) string {
+	host := params.Host
+	if host == "" {
+		host = "localhost"
 	}
-	lPort := pParams.Port
-	if lPort == 0 {
-		lPort = 5432
+	port := params.Port
+	if port == 0 {
+		port = 5432
 	}
-	return fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", lHost, lPort, pParams.User, pParams.Password, pParams.Database)
+	return fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, params.User, params.Password, params.Database)
 }
 
 func (d *postgresqlDriver) SQLBuilder() ormshift.SQLBuilder {
 	return d.sqlBuilder
 }
 
-func (d *postgresqlDriver) DBSchema(pDB *sql.DB) (*schema.DBSchema, error) {
-	return schema.NewDBSchema(pDB, tableNamesQuery, columnTypesQueryFunc(d.sqlBuilder))
+func (d *postgresqlDriver) DBSchema(db *sql.DB) (*schema.DBSchema, error) {
+	return schema.NewDBSchema(db, tableNamesQuery, columnTypesQueryFunc(d.sqlBuilder))
 }
diff --git a/dialects/postgresql/driver_test.go b/dialects/postgresql/driver_test.go
index e8401ae..42e7aef 100644
--- a/dialects/postgresql/driver_test.go
+++ b/dialects/postgresql/driver_test.go
@@ -10,40 +10,40 @@ import (
 )
 
 func TestName(t *testing.T) {
-	lDriver := postgresql.Driver()
-	testutils.AssertEqualWithLabel(t, "postgres", lDriver.Name(), "lDriver.Name")
+	driver := postgresql.Driver()
+	testutils.AssertEqualWithLabel(t, "postgres", driver.Name(), "driver.Name")
 }
 
 func TestConnectionString(t *testing.T) {
-	lDriver := postgresql.Driver()
-	lReturnedConnectionString := lDriver.ConnectionString(ormshift.ConnectionParams{
+	driver := postgresql.Driver()
+	returnedConnectionString := driver.ConnectionString(ormshift.ConnectionParams{
 		User:     "pg",
 		Password: "123456",
 		Database: "my-db",
 	})
-	lExpectedConnectionString := "host=localhost port=5432 user=pg password=123456 dbname=my-db sslmode=disable"
-	testutils.AssertEqualWithLabel(t, lExpectedConnectionString, lReturnedConnectionString, "lDriver.ConnectionString")
+	expectedConnectionString := "host=localhost port=5432 user=pg password=123456 dbname=my-db sslmode=disable"
+	testutils.AssertEqualWithLabel(t, expectedConnectionString, returnedConnectionString, "driver.ConnectionString")
 }
 
 func TestDBSchema(t *testing.T) {
-	lDriver := postgresql.Driver()
-	lDB, lError := sql.Open(lDriver.Name(), "host=localhost port=5432 user=pg password=123456 dbname=my-db sslmode=disable")
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "sql.Open") {
+	driver := postgresql.Driver()
+	db, err := sql.Open(driver.Name(), "host=localhost port=5432 user=pg password=123456 dbname=my-db sslmode=disable")
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "sql.Open") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lSchema, lError := lDriver.DBSchema(lDB)
-	if !testutils.AssertNotNilResultAndNilError(t, lSchema, lError, "lDriver.DBSchema") {
+	schema, err := driver.DBSchema(db)
+	if !testutils.AssertNotNilResultAndNilError(t, schema, err, "driver.DBSchema") {
 		return
 	}
 }
 
 func TestDBSchemaFailsWhenDBIsNil(t *testing.T) {
-	lDriver := postgresql.Driver()
-	lSchema, lError := lDriver.DBSchema(nil)
-	if !testutils.AssertNilResultAndNotNilError(t, lSchema, lError, "lDriver.DBSchema") {
+	driver := postgresql.Driver()
+	schema, err := driver.DBSchema(nil)
+	if !testutils.AssertNilResultAndNotNilError(t, schema, err, "driver.DBSchema") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "sql.DB cannot be nil", lError, "lDriver.DBSchema")
+	testutils.AssertErrorMessage(t, "sql.DB cannot be nil", err, "driver.DBSchema")
 }
diff --git a/dialects/postgresql/schema.go b/dialects/postgresql/schema.go
index 722d04c..8056489 100644
--- a/dialects/postgresql/schema.go
+++ b/dialects/postgresql/schema.go
@@ -18,8 +18,8 @@ const tableNamesQuery = `
 			table_name
 	`
 
-func columnTypesQueryFunc(pSQLBuilder ormshift.SQLBuilder) func(string) string {
-	return func(pTableName string) string {
-		return fmt.Sprintf("SELECT * FROM %s WHERE 1=0", pSQLBuilder.QuoteIdentifier(pTableName))
+func columnTypesQueryFunc(sqlBuilder ormshift.SQLBuilder) func(string) string {
+	return func(table string) string {
+		return fmt.Sprintf("SELECT * FROM %s WHERE 1=0", sqlBuilder.QuoteIdentifier(table))
 	}
 }
diff --git a/dialects/postgresql/schema_test.go b/dialects/postgresql/schema_test.go
index 4c44cd1..6f297b8 100644
--- a/dialects/postgresql/schema_test.go
+++ b/dialects/postgresql/schema_test.go
@@ -9,25 +9,25 @@ import (
 )
 
 func TestHasTable(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(postgresql.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(postgresql.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	if lDB.DBSchema().HasTable("user") {
+	if db.DBSchema().HasTable("user") {
 		t.Errorf("Expected HasTable('user') to be false")
 	}
 }
 
 func TestHasColumn(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(postgresql.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(postgresql.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	if lDB.DBSchema().HasColumn("user", "id") {
+	if db.DBSchema().HasColumn("user", "id") {
 		t.Errorf("Expected HasColumn('user', 'id') to be false")
 	}
 }
diff --git a/dialects/sqlite/builder.go b/dialects/sqlite/builder.go
index d158670..8c2093c 100644
--- a/dialects/sqlite/builder.go
+++ b/dialects/sqlite/builder.go
@@ -19,52 +19,52 @@ func newSQLiteBuilder() ormshift.SQLBuilder {
 	return &sb
 }
 
-func (sb *sqliteBuilder) CreateTable(pTable schema.Table) string {
-	lColumns := ""
-	lPKColumns := ""
-	lHasAutoIncrementColumn := false
-	for _, lColumn := range pTable.Columns() {
-		if lColumns != "" {
-			lColumns += ","
+func (sb *sqliteBuilder) CreateTable(table schema.Table) string {
+	columns := ""
+	pkColumns := ""
+	autoInc := false
+	for _, column := range table.Columns() {
+		if columns != "" {
+			columns += ","
 		}
-		lColumns += sb.columnDefinition(lColumn)
+		columns += sb.columnDefinition(column)
 
-		if lColumn.PrimaryKey() {
-			if lPKColumns != "" {
-				lPKColumns += ","
+		if column.PrimaryKey() {
+			if pkColumns != "" {
+				pkColumns += ","
 			}
-			lPKColumns += sb.QuoteIdentifier(lColumn.Name())
+			pkColumns += sb.QuoteIdentifier(column.Name())
 		}
 
-		if !lHasAutoIncrementColumn {
-			lHasAutoIncrementColumn = lColumn.AutoIncrement()
+		if !autoInc {
+			autoInc = column.AutoIncrement()
 		}
 	}
 
-	if !lHasAutoIncrementColumn && lPKColumns != "" {
-		if lColumns != "" {
-			lColumns += ","
+	if !autoInc && pkColumns != "" {
+		if columns != "" {
+			columns += ","
 		}
-		lPKConstraintName := sb.QuoteIdentifier("PK_" + pTable.Name())
-		lColumns += fmt.Sprintf("CONSTRAINT %s PRIMARY KEY (%s)", lPKConstraintName, lPKColumns)
+		pkConstraintName := sb.QuoteIdentifier("PK_" + table.Name())
+		columns += fmt.Sprintf("CONSTRAINT %s PRIMARY KEY (%s)", pkConstraintName, pkColumns)
 	}
-	return fmt.Sprintf("CREATE TABLE %s (%s);", sb.QuoteIdentifier(pTable.Name()), lColumns)
+	return fmt.Sprintf("CREATE TABLE %s (%s);", sb.QuoteIdentifier(table.Name()), columns)
 }
 
-func (sb *sqliteBuilder) DropTable(pTableName string) string {
-	return sb.generic.DropTable(pTableName)
+func (sb *sqliteBuilder) DropTable(table string) string {
+	return sb.generic.DropTable(table)
 }
 
-func (sb *sqliteBuilder) AlterTableAddColumn(pTableName string, pColumn schema.Column) string {
-	return sb.generic.AlterTableAddColumn(pTableName, pColumn)
+func (sb *sqliteBuilder) AlterTableAddColumn(table string, column schema.Column) string {
+	return sb.generic.AlterTableAddColumn(table, column)
 }
 
-func (sb *sqliteBuilder) AlterTableDropColumn(pTableName, pColumnName string) string {
-	return sb.generic.AlterTableDropColumn(pTableName, pColumnName)
+func (sb *sqliteBuilder) AlterTableDropColumn(table, column string) string {
+	return sb.generic.AlterTableDropColumn(table, column)
 }
 
-func (sb *sqliteBuilder) ColumnTypeAsString(pColumnType schema.ColumnType) string {
-	switch pColumnType {
+func (sb *sqliteBuilder) ColumnTypeAsString(columnType schema.ColumnType) string {
+	switch columnType {
 	case schema.Varchar:
 		return "TEXT"
 	case schema.Boolean:
@@ -84,57 +84,57 @@ func (sb *sqliteBuilder) ColumnTypeAsString(pColumnType schema.ColumnType) strin
 	}
 }
 
-func (sb *sqliteBuilder) columnDefinition(pColumn schema.Column) string {
-	lColumnDef := fmt.Sprintf("%s %s", sb.QuoteIdentifier(pColumn.Name()), sb.ColumnTypeAsString(pColumn.Type()))
-	if pColumn.NotNull() {
-		lColumnDef += " NOT NULL"
+func (sb *sqliteBuilder) columnDefinition(column schema.Column) string {
+	columnDef := fmt.Sprintf("%s %s", sb.QuoteIdentifier(column.Name()), sb.ColumnTypeAsString(column.Type()))
+	if column.NotNull() {
+		columnDef += " NOT NULL"
 	}
-	if pColumn.AutoIncrement() {
-		lColumnDef += " PRIMARY KEY AUTOINCREMENT"
+	if column.AutoIncrement() {
+		columnDef += " PRIMARY KEY AUTOINCREMENT"
 	}
-	return lColumnDef
+	return columnDef
 }
 
-func (sb *sqliteBuilder) Insert(pTableName string, pColumns []string) string {
-	return sb.generic.Insert(pTableName, pColumns)
+func (sb *sqliteBuilder) Insert(table string, columns []string) string {
+	return sb.generic.Insert(table, columns)
 }
 
-func (sb *sqliteBuilder) InsertWithValues(pTableName string, pColumnsValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.InsertWithValues(pTableName, pColumnsValues)
+func (sb *sqliteBuilder) InsertWithValues(table string, values ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.InsertWithValues(table, values)
 }
 
-func (sb *sqliteBuilder) Update(pTableName string, pColumns, pColumnsWhere []string) string {
-	return sb.generic.Update(pTableName, pColumns, pColumnsWhere)
+func (sb *sqliteBuilder) Update(table string, columns, where []string) string {
+	return sb.generic.Update(table, columns, where)
 }
 
-func (sb *sqliteBuilder) UpdateWithValues(pTableName string, pColumns, pColumnsWhere []string, pValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.UpdateWithValues(pTableName, pColumns, pColumnsWhere, pValues)
+func (sb *sqliteBuilder) UpdateWithValues(table string, columns, where []string, values ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.UpdateWithValues(table, columns, where, values)
 }
 
-func (sb *sqliteBuilder) Delete(pTableName string, pColumnsWhere []string) string {
-	return sb.generic.Delete(pTableName, pColumnsWhere)
+func (sb *sqliteBuilder) Delete(table string, where []string) string {
+	return sb.generic.Delete(table, where)
 }
 
-func (sb *sqliteBuilder) DeleteWithValues(pTableName string, pWhereColumnsValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.DeleteWithValues(pTableName, pWhereColumnsValues)
+func (sb *sqliteBuilder) DeleteWithValues(table string, where ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.DeleteWithValues(table, where)
 }
 
-func (sb *sqliteBuilder) Select(pTableName string, pColumns, pColumnsWhere []string) string {
-	return sb.generic.Select(pTableName, pColumns, pColumnsWhere)
+func (sb *sqliteBuilder) Select(table string, columns, where []string) string {
+	return sb.generic.Select(table, columns, where)
 }
 
-func (sb *sqliteBuilder) SelectWithValues(pTableName string, pColumns []string, pWhereColumnsValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.SelectWithValues(pTableName, pColumns, pWhereColumnsValues)
+func (sb *sqliteBuilder) SelectWithValues(table string, columns []string, where ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.SelectWithValues(table, columns, where)
 }
 
-func (sb *sqliteBuilder) SelectWithPagination(pSQLSelectCommand string, pRowsPerPage, pPageNumber uint) string {
-	return sb.generic.SelectWithPagination(pSQLSelectCommand, pRowsPerPage, pPageNumber)
+func (sb *sqliteBuilder) SelectWithPagination(sql string, size, number uint) string {
+	return sb.generic.SelectWithPagination(sql, size, number)
 }
 
-func (sb *sqliteBuilder) QuoteIdentifier(pIdentifier string) string {
-	return sb.generic.QuoteIdentifier(pIdentifier)
+func (sb *sqliteBuilder) QuoteIdentifier(identifier string) string {
+	return sb.generic.QuoteIdentifier(identifier)
 }
 
-func (sb *sqliteBuilder) InteroperateSQLCommandWithNamedArgs(pSQLCommand string, pNamedArgs ...sql.NamedArg) (string, []any) {
-	return sb.generic.InteroperateSQLCommandWithNamedArgs(pSQLCommand, pNamedArgs...)
+func (sb *sqliteBuilder) InteroperateSQLCommandWithNamedArgs(sql string, args ...sql.NamedArg) (string, []any) {
+	return sb.generic.InteroperateSQLCommandWithNamedArgs(sql, args...)
 }
diff --git a/dialects/sqlite/builder_test.go b/dialects/sqlite/builder_test.go
index fb386c5..51aaff0 100644
--- a/dialects/sqlite/builder_test.go
+++ b/dialects/sqlite/builder_test.go
@@ -10,139 +10,139 @@ import (
 )
 
 func TestInteroperateSQLCommandWithNamedArgs(t *testing.T) {
-	lDriver := sqlite.Driver()
-	lReturnedSQL, lReturnedValue := lDriver.SQLBuilder().InteroperateSQLCommandWithNamedArgs("select * from table where id = @id", sql.Named("id", 1))
-	lExpectedSQL := "select * from table where id = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, lDriver.Name()+".InteroperateSQLCommandWithNamedArgs.SQL")
-	testutils.AssertEqualWithLabel(t, "id", lReturnedValue[0].(sql.NamedArg).Name, lDriver.Name()+".InteroperateSQLCommandWithNamedArgs.Name")
-	testutils.AssertEqualWithLabel(t, 1, lReturnedValue[0].(sql.NamedArg).Value.(int), lDriver.Name()+".InteroperateSQLCommandWithNamedArgs.Value")
+	driver := sqlite.Driver()
+	returnedSQL, returnedValue := driver.SQLBuilder().InteroperateSQLCommandWithNamedArgs("select * from table where id = @id", sql.Named("id", 1))
+	expectedSQL := "select * from table where id = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, driver.Name()+".InteroperateSQLCommandWithNamedArgs.SQL")
+	testutils.AssertEqualWithLabel(t, "id", returnedValue[0].(sql.NamedArg).Name, driver.Name()+".InteroperateSQLCommandWithNamedArgs.Name")
+	testutils.AssertEqualWithLabel(t, 1, returnedValue[0].(sql.NamedArg).Value.(int), driver.Name()+".InteroperateSQLCommandWithNamedArgs.Value")
 }
 
 func TestCreateTable(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
+	sqlBuilder := sqlite.Driver().SQLBuilder()
 
-	lUserTable := testutils.FakeUserTable(t)
-	lExpectedSQL := "CREATE TABLE \"user\" (\"id\" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,\"email\" TEXT NOT NULL,\"name\" TEXT NOT NULL," +
+	userTable := testutils.FakeUserTable(t)
+	expectedSQL := "CREATE TABLE \"user\" (\"id\" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,\"email\" TEXT NOT NULL,\"name\" TEXT NOT NULL," +
 		"\"password_hash\" TEXT,\"active\" INTEGER,\"created_at\" DATETIME,\"user_master\" INTEGER,\"master_user_id\" INTEGER,\"licence_price\" REAL,\"relevance\" REAL,\"photo\" BLOB,\"any\" TEXT);"
-	lReturnedSQL := lSQLBuilder.CreateTable(lUserTable)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.CreateTable")
+	returnedSQL := sqlBuilder.CreateTable(userTable)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.CreateTable")
 
-	lProductAttributeTable := testutils.FakeProductAttributeTable(t)
-	lExpectedSQL = "CREATE TABLE \"product_attribute\" (\"product_id\" INTEGER NOT NULL,\"attribute_id\" INTEGER NOT NULL,\"value\" TEXT,\"position\" INTEGER,CONSTRAINT \"PK_product_attribute\" PRIMARY KEY (\"product_id\",\"attribute_id\"));"
-	lReturnedSQL = lSQLBuilder.CreateTable(lProductAttributeTable)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.CreateTable")
+	productAttributeTable := testutils.FakeProductAttributeTable(t)
+	expectedSQL = "CREATE TABLE \"product_attribute\" (\"product_id\" INTEGER NOT NULL,\"attribute_id\" INTEGER NOT NULL,\"value\" TEXT,\"position\" INTEGER,CONSTRAINT \"PK_product_attribute\" PRIMARY KEY (\"product_id\",\"attribute_id\"));"
+	returnedSQL = sqlBuilder.CreateTable(productAttributeTable)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.CreateTable")
 }
 
 func TestDropTable(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
+	sqlBuilder := sqlite.Driver().SQLBuilder()
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lExpectedSQL := "DROP TABLE \"user\";"
-	lReturnedSQL := lSQLBuilder.DropTable(lUserTableName)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.DropTable")
+	userTableName := testutils.FakeUserTableName(t)
+	expectedSQL := "DROP TABLE \"user\";"
+	returnedSQL := sqlBuilder.DropTable(userTableName)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.DropTable")
 }
 
 func TestAlterTableAddColumn(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
+	sqlBuilder := sqlite.Driver().SQLBuilder()
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lUpdatedAtColumn := testutils.FakeUpdatedAtColumn(t)
-	lExpectedSQL := "ALTER TABLE \"user\" ADD COLUMN \"updated_at\" DATETIME;"
-	lReturnedSQL := lSQLBuilder.AlterTableAddColumn(lUserTableName, lUpdatedAtColumn)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.AlterTableAddColumn")
+	userTableName := testutils.FakeUserTableName(t)
+	updatedAtColumn := testutils.FakeUpdatedAtColumn(t)
+	expectedSQL := "ALTER TABLE \"user\" ADD COLUMN \"updated_at\" DATETIME;"
+	returnedSQL := sqlBuilder.AlterTableAddColumn(userTableName, updatedAtColumn)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.AlterTableAddColumn")
 }
 
 func TestAlterTableDropColumn(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
+	sqlBuilder := sqlite.Driver().SQLBuilder()
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lUpdatedAtColumnName := testutils.FakeUpdatedAtColumnName(t)
-	lExpectedSQL := "ALTER TABLE \"user\" DROP COLUMN \"updated_at\";"
-	lReturnedSQL := lSQLBuilder.AlterTableDropColumn(lUserTableName, lUpdatedAtColumnName)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.AlterTableDropColumn")
+	userTableName := testutils.FakeUserTableName(t)
+	updatedAtColumnName := testutils.FakeUpdatedAtColumnName(t)
+	expectedSQL := "ALTER TABLE \"user\" DROP COLUMN \"updated_at\";"
+	returnedSQL := sqlBuilder.AlterTableDropColumn(userTableName, updatedAtColumnName)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.AlterTableDropColumn")
 }
 
 func TestInsert(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
+	sqlBuilder := sqlite.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Insert("product", []string{"id", "sku", "name", "description"})
-	lExpectedSQL := "insert into \"product\" (\"id\",\"sku\",\"name\",\"description\") values (@id,@sku,@name,@description)"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Insert")
+	returnedSQL := sqlBuilder.Insert("product", []string{"id", "sku", "name", "description"})
+	expectedSQL := "insert into \"product\" (\"id\",\"sku\",\"name\",\"description\") values (@id,@sku,@name,@description)"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Insert")
 }
 
 func TestInsertWithValues(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
-
-	lReturnedSQL, lReturnedValues := lSQLBuilder.InsertWithValues("product", ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.9", "name": "Trufa Sabor Amarula 30g Cacaushow"})
-	lExpectedSQL := "insert into \"product\" (\"id\",\"name\",\"sku\") values (@id,@name,@sku)"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.InsertWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 3, len(lReturnedValues), "SQLBuilder.InsertWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.InsertWithValues.Values[0]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 30g Cacaushow"}, "SQLBuilder.InsertWithValues.Values[1]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.9"}, "SQLBuilder.InsertWithValues.Values[2]")
+	sqlBuilder := sqlite.Driver().SQLBuilder()
+
+	returnedSQL, returnedValues := sqlBuilder.InsertWithValues("product", ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.9", "name": "Trufa Sabor Amarula 30g Cacaushow"})
+	expectedSQL := "insert into \"product\" (\"id\",\"name\",\"sku\") values (@id,@name,@sku)"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.InsertWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 3, len(returnedValues), "SQLBuilder.InsertWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.InsertWithValues.Values[0]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 30g Cacaushow"}, "SQLBuilder.InsertWithValues.Values[1]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.9"}, "SQLBuilder.InsertWithValues.Values[2]")
 }
 
 func TestUpdate(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
+	sqlBuilder := sqlite.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Update("product", []string{"sku", "name", "description"}, []string{"id"})
-	lExpectedSQL := "update \"product\" set \"sku\" = @sku,\"name\" = @name,\"description\" = @description where \"id\" = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Update")
+	returnedSQL := sqlBuilder.Update("product", []string{"sku", "name", "description"}, []string{"id"})
+	expectedSQL := "update \"product\" set \"sku\" = @sku,\"name\" = @name,\"description\" = @description where \"id\" = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Update")
 }
 
 func TestUpdateWithValues(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
-
-	lReturnedSQL, lReturnedValues := lSQLBuilder.UpdateWithValues("product", []string{"sku", "name"}, []string{"id"}, ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.5", "name": "Trufa Sabor Amarula 18g Cacaushow"})
-	lExpectedSQL := "update \"product\" set \"sku\" = @sku,\"name\" = @name where \"id\" = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.UpdateWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 3, len(lReturnedValues), "SQLBuilder.UpdateWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.UpdateWithValues.Values[0]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 18g Cacaushow"}, "SQLBuilder.UpdateWithValues.Values[1]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.5"}, "SQLBuilder.UpdateWithValues.Values[2]")
+	sqlBuilder := sqlite.Driver().SQLBuilder()
+
+	returnedSQL, returnedValues := sqlBuilder.UpdateWithValues("product", []string{"sku", "name"}, []string{"id"}, ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.5", "name": "Trufa Sabor Amarula 18g Cacaushow"})
+	expectedSQL := "update \"product\" set \"sku\" = @sku,\"name\" = @name where \"id\" = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.UpdateWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 3, len(returnedValues), "SQLBuilder.UpdateWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.UpdateWithValues.Values[0]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 18g Cacaushow"}, "SQLBuilder.UpdateWithValues.Values[1]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.5"}, "SQLBuilder.UpdateWithValues.Values[2]")
 }
 
 func TestDelete(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
+	sqlBuilder := sqlite.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Delete("product", []string{"id"})
-	lExpectedSQL := "delete from \"product\" where \"id\" = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Delete")
+	returnedSQL := sqlBuilder.Delete("product", []string{"id"})
+	expectedSQL := "delete from \"product\" where \"id\" = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Delete")
 }
 
 func TestDeleteWithValues(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
+	sqlBuilder := sqlite.Driver().SQLBuilder()
 
-	lReturnedSQL, lReturnedValues := lSQLBuilder.DeleteWithValues("product", ormshift.ColumnsValues{"id": 1})
-	lExpectedSQL := "delete from \"product\" where \"id\" = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.DeleteWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 1, len(lReturnedValues), "SQLBuilder.DeleteWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.DeleteWithValues.Values[0]")
+	returnedSQL, returnedValues := sqlBuilder.DeleteWithValues("product", ormshift.ColumnsValues{"id": 1})
+	expectedSQL := "delete from \"product\" where \"id\" = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.DeleteWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 1, len(returnedValues), "SQLBuilder.DeleteWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.DeleteWithValues.Values[0]")
 }
 
 func TestSelect(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
+	sqlBuilder := sqlite.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Select("product", []string{"id", "name", "description"}, []string{"sku", "active"})
-	lExpectedSQL := "select \"id\",\"name\",\"description\" from \"product\" where \"sku\" = @sku and \"active\" = @active"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Select")
+	returnedSQL := sqlBuilder.Select("product", []string{"id", "name", "description"}, []string{"sku", "active"})
+	expectedSQL := "select \"id\",\"name\",\"description\" from \"product\" where \"sku\" = @sku and \"active\" = @active"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Select")
 }
 
 func TestSelectWithValues(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
-
-	lReturnedSQL, lReturnedValues := lSQLBuilder.SelectWithValues("product", []string{"id", "sku", "name", "description"}, ormshift.ColumnsValues{"category_id": 1, "active": true})
-	lExpectedSQL := "select \"id\",\"sku\",\"name\",\"description\" from \"product\" where \"active\" = @active and \"category_id\" = @category_id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.SelectWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 2, len(lReturnedValues), "SQLBuilder.SelectWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "active", Value: true}, "SQLBuilder.SelectWithValues.Values[0]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[1], sql.NamedArg{Name: "category_id", Value: 1}, "SQLBuilder.SelectWithValues.Values[1]")
+	sqlBuilder := sqlite.Driver().SQLBuilder()
+
+	returnedSQL, returnedValues := sqlBuilder.SelectWithValues("product", []string{"id", "sku", "name", "description"}, ormshift.ColumnsValues{"category_id": 1, "active": true})
+	expectedSQL := "select \"id\",\"sku\",\"name\",\"description\" from \"product\" where \"active\" = @active and \"category_id\" = @category_id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.SelectWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 2, len(returnedValues), "SQLBuilder.SelectWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "active", Value: true}, "SQLBuilder.SelectWithValues.Values[0]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[1], sql.NamedArg{Name: "category_id", Value: 1}, "SQLBuilder.SelectWithValues.Values[1]")
 }
 
 func TestSelectWithPagination(t *testing.T) {
-	lSQLBuilder := sqlite.Driver().SQLBuilder()
+	sqlBuilder := sqlite.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.SelectWithPagination("select * from product", 10, 5)
-	lExpectedSQL := "select * from product LIMIT 10 OFFSET 40"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.SelectWithPagination")
+	returnedSQL := sqlBuilder.SelectWithPagination("select * from product", 10, 5)
+	expectedSQL := "select * from product LIMIT 10 OFFSET 40"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.SelectWithPagination")
 }
diff --git a/dialects/sqlite/driver.go b/dialects/sqlite/driver.go
index 488aaa4..eedafe6 100644
--- a/dialects/sqlite/driver.go
+++ b/dialects/sqlite/driver.go
@@ -25,24 +25,24 @@ func (d *sqliteDriver) Name() string {
 	return "sqlite"
 }
 
-func (d *sqliteDriver) ConnectionString(pParams ormshift.ConnectionParams) string {
-	if pParams.InMemory {
+func (d *sqliteDriver) ConnectionString(params ormshift.ConnectionParams) string {
+	if params.InMemory {
 		return ":memory:"
 	}
-	lConnetionWithAuth := ""
-	if pParams.User != "" {
-		lConnetionWithAuth += fmt.Sprintf("_auth&_auth_user=%s&", pParams.User)
-		if pParams.Password != "" {
-			lConnetionWithAuth += fmt.Sprintf("_auth_pass=%s&", pParams.Password)
+	connectionWithAuth := ""
+	if params.User != "" {
+		connectionWithAuth += fmt.Sprintf("_auth&_auth_user=%s&", params.User)
+		if params.Password != "" {
+			connectionWithAuth += fmt.Sprintf("_auth_pass=%s&", params.Password)
 		}
 	}
-	return fmt.Sprintf("file:%s.db?%s_locking=NORMAL", pParams.Database, lConnetionWithAuth)
+	return fmt.Sprintf("file:%s.db?%s_locking=NORMAL", params.Database, connectionWithAuth)
 }
 
 func (d *sqliteDriver) SQLBuilder() ormshift.SQLBuilder {
 	return d.sqlBuilder
 }
 
-func (d *sqliteDriver) DBSchema(pDB *sql.DB) (*schema.DBSchema, error) {
-	return schema.NewDBSchema(pDB, tableNamesQuery, columnTypesQueryFunc(d.sqlBuilder))
+func (d *sqliteDriver) DBSchema(db *sql.DB) (*schema.DBSchema, error) {
+	return schema.NewDBSchema(db, tableNamesQuery, columnTypesQueryFunc(d.sqlBuilder))
 }
diff --git a/dialects/sqlite/driver_test.go b/dialects/sqlite/driver_test.go
index fac50dc..eca7c84 100644
--- a/dialects/sqlite/driver_test.go
+++ b/dialects/sqlite/driver_test.go
@@ -10,47 +10,47 @@ import (
 )
 
 func TestName(t *testing.T) {
-	lDriver := sqlite.Driver()
-	testutils.AssertEqualWithLabel(t, "sqlite", lDriver.Name(), "lDriver.Name")
+	driver := sqlite.Driver()
+	testutils.AssertEqualWithLabel(t, "sqlite", driver.Name(), "driver.Name")
 }
 
 func TestConnectionString(t *testing.T) {
-	lDriver := sqlite.Driver()
-	lReturnedConnectionString := lDriver.ConnectionString(ormshift.ConnectionParams{
+	driver := sqlite.Driver()
+	returnedConnectionString := driver.ConnectionString(ormshift.ConnectionParams{
 		User:     "user",
 		Password: "123456",
 		Database: "my-db",
 	})
-	lExpectedConnectionString := "file:my-db.db?_auth&_auth_user=user&_auth_pass=123456&_locking=NORMAL"
-	testutils.AssertEqualWithLabel(t, lExpectedConnectionString, lReturnedConnectionString, "lDriver.ConnectionString")
+	expectedConnectionString := "file:my-db.db?_auth&_auth_user=user&_auth_pass=123456&_locking=NORMAL"
+	testutils.AssertEqualWithLabel(t, expectedConnectionString, returnedConnectionString, "driver.ConnectionString")
 }
 
 func TestConnectionStringInMemory(t *testing.T) {
-	lDriver := sqlite.Driver()
-	lReturnedConnectionString := lDriver.ConnectionString(ormshift.ConnectionParams{InMemory: true})
-	lExpectedConnectionString := ":memory:"
-	testutils.AssertEqualWithLabel(t, lExpectedConnectionString, lReturnedConnectionString, "lDriver.ConnectionString")
+	driver := sqlite.Driver()
+	returnedConnectionString := driver.ConnectionString(ormshift.ConnectionParams{InMemory: true})
+	expectedConnectionString := ":memory:"
+	testutils.AssertEqualWithLabel(t, expectedConnectionString, returnedConnectionString, "driver.ConnectionString")
 }
 
 func TestDBSchema(t *testing.T) {
-	lDriver := sqlite.Driver()
-	lDB, lError := sql.Open(lDriver.Name(), lDriver.ConnectionString(ormshift.ConnectionParams{InMemory: true}))
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "sql.Open") {
+	driver := sqlite.Driver()
+	db, err := sql.Open(driver.Name(), driver.ConnectionString(ormshift.ConnectionParams{InMemory: true}))
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "sql.Open") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lSchema, lError := lDriver.DBSchema(lDB)
-	if !testutils.AssertNotNilResultAndNilError(t, lSchema, lError, "lDriver.DBSchema") {
+	schema, err := driver.DBSchema(db)
+	if !testutils.AssertNotNilResultAndNilError(t, schema, err, "driver.DBSchema") {
 		return
 	}
 }
 
 func TestDBSchemaFailsWhenDBIsNil(t *testing.T) {
-	lDriver := sqlite.Driver()
-	lSchema, lError := lDriver.DBSchema(nil)
-	if !testutils.AssertNilResultAndNotNilError(t, lSchema, lError, "lDriver.DBSchema") {
+	driver := sqlite.Driver()
+	schema, err := driver.DBSchema(nil)
+	if !testutils.AssertNilResultAndNotNilError(t, schema, err, "driver.DBSchema") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "sql.DB cannot be nil", lError, "lDriver.DBSchema")
+	testutils.AssertErrorMessage(t, "sql.DB cannot be nil", err, "driver.DBSchema")
 }
diff --git a/dialects/sqlite/schema.go b/dialects/sqlite/schema.go
index 9519537..ce4780d 100644
--- a/dialects/sqlite/schema.go
+++ b/dialects/sqlite/schema.go
@@ -17,8 +17,8 @@ const tableNamesQuery = `
 			name
 	`
 
-func columnTypesQueryFunc(pSQLBuilder ormshift.SQLBuilder) func(string) string {
-	return func(pTableName string) string {
-		return fmt.Sprintf("SELECT * FROM %s WHERE 1=0", pSQLBuilder.QuoteIdentifier(pTableName))
+func columnTypesQueryFunc(sqlBuilder ormshift.SQLBuilder) func(string) string {
+	return func(table string) string {
+		return fmt.Sprintf("SELECT * FROM %s WHERE 1=0", sqlBuilder.QuoteIdentifier(table))
 	}
 }
diff --git a/dialects/sqlite/schema_test.go b/dialects/sqlite/schema_test.go
index 2718ff7..8bb8a19 100644
--- a/dialects/sqlite/schema_test.go
+++ b/dialects/sqlite/schema_test.go
@@ -9,25 +9,25 @@ import (
 )
 
 func TestHasTable(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	if lDB.DBSchema().HasTable("user") {
+	if db.DBSchema().HasTable("user") {
 		t.Errorf("Expected HasTable('user') to be false")
 	}
 }
 
 func TestHasColumn(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	if lDB.DBSchema().HasColumn("user", "id") {
+	if db.DBSchema().HasColumn("user", "id") {
 		t.Errorf("Expected HasColumn('user', 'id') to be false")
 	}
 }
diff --git a/dialects/sqlserver/builder.go b/dialects/sqlserver/builder.go
index 12a9871..a0aa235 100644
--- a/dialects/sqlserver/builder.go
+++ b/dialects/sqlserver/builder.go
@@ -20,47 +20,47 @@ func newSQLServerBuilder() ormshift.SQLBuilder {
 	return &sb
 }
 
-func (sb *sqlserverBuilder) CreateTable(pTable schema.Table) string {
-	lColumns := ""
-	lPKColumns := ""
-	for _, lColumn := range pTable.Columns() {
-		if lColumns != "" {
-			lColumns += ","
+func (sb *sqlserverBuilder) CreateTable(table schema.Table) string {
+	columns := ""
+	pkColumns := ""
+	for _, column := range table.Columns() {
+		if columns != "" {
+			columns += ","
 		}
-		lColumns += sb.columnDefinition(lColumn)
+		columns += sb.columnDefinition(column)
 
-		if lColumn.PrimaryKey() {
-			if lPKColumns != "" {
-				lPKColumns += ","
+		if column.PrimaryKey() {
+			if pkColumns != "" {
+				pkColumns += ","
 			}
-			lPKColumns += sb.QuoteIdentifier(lColumn.Name())
+			pkColumns += sb.QuoteIdentifier(column.Name())
 		}
 	}
 
-	if lPKColumns != "" {
-		if lColumns != "" {
-			lColumns += ","
+	if pkColumns != "" {
+		if columns != "" {
+			columns += ","
 		}
-		lPKConstraintName := sb.QuoteIdentifier("PK_" + pTable.Name())
-		lColumns += fmt.Sprintf("CONSTRAINT %s PRIMARY KEY (%s)", lPKConstraintName, lPKColumns)
+		pkConstraintName := sb.QuoteIdentifier("PK_" + table.Name())
+		columns += fmt.Sprintf("CONSTRAINT %s PRIMARY KEY (%s)", pkConstraintName, pkColumns)
 	}
-	return fmt.Sprintf("CREATE TABLE %s (%s);", sb.QuoteIdentifier(pTable.Name()), lColumns)
+	return fmt.Sprintf("CREATE TABLE %s (%s);", sb.QuoteIdentifier(table.Name()), columns)
 }
 
-func (sb *sqlserverBuilder) DropTable(pTableName string) string {
-	return sb.generic.DropTable(pTableName)
+func (sb *sqlserverBuilder) DropTable(table string) string {
+	return sb.generic.DropTable(table)
 }
 
-func (sb *sqlserverBuilder) AlterTableAddColumn(pTableName string, pColumn schema.Column) string {
-	return sb.generic.AlterTableAddColumn(pTableName, pColumn)
+func (sb *sqlserverBuilder) AlterTableAddColumn(table string, column schema.Column) string {
+	return sb.generic.AlterTableAddColumn(table, column)
 }
 
-func (sb *sqlserverBuilder) AlterTableDropColumn(pTableName, pColumnName string) string {
-	return sb.generic.AlterTableDropColumn(pTableName, pColumnName)
+func (sb *sqlserverBuilder) AlterTableDropColumn(table, column string) string {
+	return sb.generic.AlterTableDropColumn(table, column)
 }
 
-func (sb *sqlserverBuilder) ColumnTypeAsString(pColumnType schema.ColumnType) string {
-	switch pColumnType {
+func (sb *sqlserverBuilder) ColumnTypeAsString(columnType schema.ColumnType) string {
+	switch columnType {
 	case schema.Varchar:
 		return "VARCHAR"
 	case schema.Boolean:
@@ -80,74 +80,74 @@ func (sb *sqlserverBuilder) ColumnTypeAsString(pColumnType schema.ColumnType) st
 	}
 }
 
-func (sb *sqlserverBuilder) columnDefinition(pColumn schema.Column) string {
-	lColumnDef := sb.QuoteIdentifier(pColumn.Name())
-	if pColumn.Type() == schema.Varchar {
-		lColumnDef += fmt.Sprintf(" %s(%d)", sb.ColumnTypeAsString(pColumn.Type()), pColumn.Size())
+func (sb *sqlserverBuilder) columnDefinition(column schema.Column) string {
+	columnDef := sb.QuoteIdentifier(column.Name())
+	if column.Type() == schema.Varchar {
+		columnDef += fmt.Sprintf(" %s(%d)", sb.ColumnTypeAsString(column.Type()), column.Size())
 	} else {
-		lColumnDef += fmt.Sprintf(" %s", sb.ColumnTypeAsString(pColumn.Type()))
+		columnDef += fmt.Sprintf(" %s", sb.ColumnTypeAsString(column.Type()))
 	}
-	if pColumn.NotNull() {
-		lColumnDef += " NOT NULL"
+	if column.NotNull() {
+		columnDef += " NOT NULL"
 	}
-	if pColumn.AutoIncrement() {
-		lColumnDef += " IDENTITY (1, 1)"
+	if column.AutoIncrement() {
+		columnDef += " IDENTITY (1, 1)"
 	}
-	return lColumnDef
+	return columnDef
 }
 
-func (sb *sqlserverBuilder) Insert(pTableName string, pColumns []string) string {
-	return sb.generic.Insert(pTableName, pColumns)
+func (sb *sqlserverBuilder) Insert(table string, columns []string) string {
+	return sb.generic.Insert(table, columns)
 }
 
-func (sb *sqlserverBuilder) InsertWithValues(pTableName string, pColumnsValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.InsertWithValues(pTableName, pColumnsValues)
+func (sb *sqlserverBuilder) InsertWithValues(table string, values ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.InsertWithValues(table, values)
 }
 
-func (sb *sqlserverBuilder) Update(pTableName string, pColumns, pColumnsWhere []string) string {
-	return sb.generic.Update(pTableName, pColumns, pColumnsWhere)
+func (sb *sqlserverBuilder) Update(table string, columns, where []string) string {
+	return sb.generic.Update(table, columns, where)
 }
 
-func (sb *sqlserverBuilder) UpdateWithValues(pTableName string, pColumns, pColumnsWhere []string, pValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.UpdateWithValues(pTableName, pColumns, pColumnsWhere, pValues)
+func (sb *sqlserverBuilder) UpdateWithValues(table string, columns, where []string, values ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.UpdateWithValues(table, columns, where, values)
 }
 
-func (sb *sqlserverBuilder) Delete(pTableName string, pColumnsWhere []string) string {
-	return sb.generic.Delete(pTableName, pColumnsWhere)
+func (sb *sqlserverBuilder) Delete(table string, where []string) string {
+	return sb.generic.Delete(table, where)
 }
 
-func (sb *sqlserverBuilder) DeleteWithValues(pTableName string, pWhereColumnsValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.DeleteWithValues(pTableName, pWhereColumnsValues)
+func (sb *sqlserverBuilder) DeleteWithValues(table string, where ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.DeleteWithValues(table, where)
 }
 
-func (sb *sqlserverBuilder) Select(pTableName string, pColumns, pColumnsWhere []string) string {
-	return sb.generic.Select(pTableName, pColumns, pColumnsWhere)
+func (sb *sqlserverBuilder) Select(table string, columns, where []string) string {
+	return sb.generic.Select(table, columns, where)
 }
 
-func (sb *sqlserverBuilder) SelectWithValues(pTableName string, pColumns []string, pWhereColumnsValues ormshift.ColumnsValues) (string, []any) {
-	return sb.generic.SelectWithValues(pTableName, pColumns, pWhereColumnsValues)
+func (sb *sqlserverBuilder) SelectWithValues(table string, columns []string, where ormshift.ColumnsValues) (string, []any) {
+	return sb.generic.SelectWithValues(table, columns, where)
 }
 
-func (sb *sqlserverBuilder) SelectWithPagination(pSQLSelectCommand string, pRowsPerPage, pPageNumber uint) string {
-	lSelectWithPagination := pSQLSelectCommand
-	if pRowsPerPage > 0 {
-		lOffSet := uint(0)
-		if pPageNumber > 1 {
-			lOffSet = pRowsPerPage * (pPageNumber - 1)
+func (sb *sqlserverBuilder) SelectWithPagination(sql string, size, number uint) string {
+	selectWithPagination := sql
+	if size > 0 {
+		offset := uint(0)
+		if number > 1 {
+			offset = size * (number - 1)
 		}
-		lSelectWithPagination += fmt.Sprintf(" OFFSET %d ROWS FETCH NEXT %d ROWS ONLY", lOffSet, pRowsPerPage)
+		selectWithPagination += fmt.Sprintf(" OFFSET %d ROWS FETCH NEXT %d ROWS ONLY", offset, size)
 	}
-	return lSelectWithPagination
+	return selectWithPagination
 }
 
-func (sb *sqlserverBuilder) QuoteIdentifier(pIdentifier string) string {
+func (sb *sqlserverBuilder) QuoteIdentifier(identifier string) string {
 	// SQL Server uses square brackets: [identifier]
 	// Escape rule: ] becomes ]]
 	// Example: users -> [users], table]name -> [table]]name]
-	pIdentifier = strings.ReplaceAll(pIdentifier, "]", "]]")
-	return fmt.Sprintf("[%s]", pIdentifier)
+	identifier = strings.ReplaceAll(identifier, "]", "]]")
+	return fmt.Sprintf("[%s]", identifier)
 }
 
-func (sb *sqlserverBuilder) InteroperateSQLCommandWithNamedArgs(pSQLCommand string, pNamedArgs ...sql.NamedArg) (string, []any) {
-	return sb.generic.InteroperateSQLCommandWithNamedArgs(pSQLCommand, pNamedArgs...)
+func (sb *sqlserverBuilder) InteroperateSQLCommandWithNamedArgs(sql string, args ...sql.NamedArg) (string, []any) {
+	return sb.generic.InteroperateSQLCommandWithNamedArgs(sql, args...)
 }
diff --git a/dialects/sqlserver/builder_test.go b/dialects/sqlserver/builder_test.go
index 37fe538..169a5a5 100644
--- a/dialects/sqlserver/builder_test.go
+++ b/dialects/sqlserver/builder_test.go
@@ -10,140 +10,140 @@ import (
 )
 
 func TestInteroperateSQLCommandWithNamedArgs(t *testing.T) {
-	lDriver := sqlserver.Driver()
-	lReturnedSQL, lReturnedValue := lDriver.SQLBuilder().InteroperateSQLCommandWithNamedArgs("select * from table where id = @id", sql.Named("id", 1))
-	lExpectedSQL := "select * from table where id = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, lDriver.Name()+".InteroperateSQLCommandWithNamedArgs.SQL")
-	testutils.AssertEqualWithLabel(t, "id", lReturnedValue[0].(sql.NamedArg).Name, lDriver.Name()+".InteroperateSQLCommandWithNamedArgs.Name")
-	testutils.AssertEqualWithLabel(t, 1, lReturnedValue[0].(sql.NamedArg).Value.(int), lDriver.Name()+".InteroperateSQLCommandWithNamedArgs.Value")
+	driver := sqlserver.Driver()
+	returnedSQL, returnedValue := driver.SQLBuilder().InteroperateSQLCommandWithNamedArgs("select * from table where id = @id", sql.Named("id", 1))
+	expectedSQL := "select * from table where id = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, driver.Name()+".InteroperateSQLCommandWithNamedArgs.SQL")
+	testutils.AssertEqualWithLabel(t, "id", returnedValue[0].(sql.NamedArg).Name, driver.Name()+".InteroperateSQLCommandWithNamedArgs.Name")
+	testutils.AssertEqualWithLabel(t, 1, returnedValue[0].(sql.NamedArg).Value.(int), driver.Name()+".InteroperateSQLCommandWithNamedArgs.Value")
 }
 
 func TestCreateTable(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
 
-	lUserTable := testutils.FakeUserTable(t)
-	lExpectedSQL := "CREATE TABLE [user] ([id] BIGINT NOT NULL IDENTITY (1, 1),[email] VARCHAR(80) NOT NULL,[name] VARCHAR(50) NOT NULL," +
+	userTable := testutils.FakeUserTable(t)
+	expectedSQL := "CREATE TABLE [user] ([id] BIGINT NOT NULL IDENTITY (1, 1),[email] VARCHAR(80) NOT NULL,[name] VARCHAR(50) NOT NULL," +
 		"[password_hash] VARCHAR(256),[active] BIT,[created_at] DATETIME2(6),[user_master] BIGINT,[master_user_id] BIGINT," +
 		"[licence_price] MONEY,[relevance] FLOAT,[photo] VARBINARY(MAX),[any] VARCHAR,CONSTRAINT [PK_user] PRIMARY KEY ([id],[email]));"
-	lReturnedSQL := lSQLBuilder.CreateTable(lUserTable)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.CreateTable")
+	returnedSQL := sqlBuilder.CreateTable(userTable)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.CreateTable")
 
-	lProductAttributeTable := testutils.FakeProductAttributeTable(t)
-	lExpectedSQL = "CREATE TABLE [product_attribute] ([product_id] BIGINT NOT NULL,[attribute_id] BIGINT NOT NULL,[value] VARCHAR(75),[position] BIGINT,CONSTRAINT [PK_product_attribute] PRIMARY KEY ([product_id],[attribute_id]));"
-	lReturnedSQL = lSQLBuilder.CreateTable(lProductAttributeTable)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.CreateTable")
+	productAttributeTable := testutils.FakeProductAttributeTable(t)
+	expectedSQL = "CREATE TABLE [product_attribute] ([product_id] BIGINT NOT NULL,[attribute_id] BIGINT NOT NULL,[value] VARCHAR(75),[position] BIGINT,CONSTRAINT [PK_product_attribute] PRIMARY KEY ([product_id],[attribute_id]));"
+	returnedSQL = sqlBuilder.CreateTable(productAttributeTable)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.CreateTable")
 }
 
 func TestDropTable(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lExpectedSQL := "DROP TABLE [user];"
-	lReturnedSQL := lSQLBuilder.DropTable(lUserTableName)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.DropTable")
+	userTableName := testutils.FakeUserTableName(t)
+	expectedSQL := "DROP TABLE [user];"
+	returnedSQL := sqlBuilder.DropTable(userTableName)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.DropTable")
 }
 
 func TestAlterTableAddColumn(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lUpdatedAtColumn := testutils.FakeUpdatedAtColumn(t)
-	lExpectedSQL := "ALTER TABLE [user] ADD COLUMN [updated_at] DATETIME2(6);"
-	lReturnedSQL := lSQLBuilder.AlterTableAddColumn(lUserTableName, lUpdatedAtColumn)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.AlterTableAddColumn")
+	userTableName := testutils.FakeUserTableName(t)
+	updatedAtColumn := testutils.FakeUpdatedAtColumn(t)
+	expectedSQL := "ALTER TABLE [user] ADD COLUMN [updated_at] DATETIME2(6);"
+	returnedSQL := sqlBuilder.AlterTableAddColumn(userTableName, updatedAtColumn)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.AlterTableAddColumn")
 }
 
 func TestAlterTableDropColumn(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lUpdatedAtColumnName := testutils.FakeUpdatedAtColumnName(t)
-	lExpectedSQL := "ALTER TABLE [user] DROP COLUMN [updated_at];"
-	lReturnedSQL := lSQLBuilder.AlterTableDropColumn(lUserTableName, lUpdatedAtColumnName)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.AlterTableDropColumn")
+	userTableName := testutils.FakeUserTableName(t)
+	updatedAtColumnName := testutils.FakeUpdatedAtColumnName(t)
+	expectedSQL := "ALTER TABLE [user] DROP COLUMN [updated_at];"
+	returnedSQL := sqlBuilder.AlterTableDropColumn(userTableName, updatedAtColumnName)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.AlterTableDropColumn")
 }
 
 func TestInsert(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Insert("product", []string{"id", "sku", "name", "description"})
-	lExpectedSQL := "insert into [product] ([id],[sku],[name],[description]) values (@id,@sku,@name,@description)"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Insert")
+	returnedSQL := sqlBuilder.Insert("product", []string{"id", "sku", "name", "description"})
+	expectedSQL := "insert into [product] ([id],[sku],[name],[description]) values (@id,@sku,@name,@description)"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Insert")
 }
 
 func TestInsertWithValues(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
-
-	lReturnedSQL, lReturnedValues := lSQLBuilder.InsertWithValues("product", ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.9", "name": "Trufa Sabor Amarula 30g Cacaushow"})
-	lExpectedSQL := "insert into [product] ([id],[name],[sku]) values (@id,@name,@sku)"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.InsertWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 3, len(lReturnedValues), "SQLBuilder.InsertWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.InsertWithValues.Values[0]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 30g Cacaushow"}, "SQLBuilder.InsertWithValues.Values[1]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.9"}, "SQLBuilder.InsertWithValues.Values[2]")
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
+
+	returnedSQL, returnedValues := sqlBuilder.InsertWithValues("product", ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.9", "name": "Trufa Sabor Amarula 30g Cacaushow"})
+	expectedSQL := "insert into [product] ([id],[name],[sku]) values (@id,@name,@sku)"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.InsertWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 3, len(returnedValues), "SQLBuilder.InsertWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.InsertWithValues.Values[0]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 30g Cacaushow"}, "SQLBuilder.InsertWithValues.Values[1]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.9"}, "SQLBuilder.InsertWithValues.Values[2]")
 }
 
 func TestUpdate(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Update("product", []string{"sku", "name", "description"}, []string{"id"})
-	lExpectedSQL := "update [product] set [sku] = @sku,[name] = @name,[description] = @description where [id] = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Update")
+	returnedSQL := sqlBuilder.Update("product", []string{"sku", "name", "description"}, []string{"id"})
+	expectedSQL := "update [product] set [sku] = @sku,[name] = @name,[description] = @description where [id] = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Update")
 }
 
 func TestUpdateWithValues(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
-
-	lReturnedSQL, lReturnedValues := lSQLBuilder.UpdateWithValues("product", []string{"sku", "name"}, []string{"id"}, ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.5", "name": "Trufa Sabor Amarula 18g Cacaushow"})
-	lExpectedSQL := "update [product] set [sku] = @sku,[name] = @name where [id] = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.UpdateWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 3, len(lReturnedValues), "SQLBuilder.UpdateWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.UpdateWithValues.Values[0]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 18g Cacaushow"}, "SQLBuilder.UpdateWithValues.Values[1]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.5"}, "SQLBuilder.UpdateWithValues.Values[2]")
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
+
+	returnedSQL, returnedValues := sqlBuilder.UpdateWithValues("product", []string{"sku", "name"}, []string{"id"}, ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.5", "name": "Trufa Sabor Amarula 18g Cacaushow"})
+	expectedSQL := "update [product] set [sku] = @sku,[name] = @name where [id] = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.UpdateWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 3, len(returnedValues), "SQLBuilder.UpdateWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.UpdateWithValues.Values[0]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 18g Cacaushow"}, "SQLBuilder.UpdateWithValues.Values[1]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.5"}, "SQLBuilder.UpdateWithValues.Values[2]")
 }
 
 func TestDelete(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Delete("product", []string{"id"})
-	lExpectedSQL := "delete from [product] where [id] = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Delete")
+	returnedSQL := sqlBuilder.Delete("product", []string{"id"})
+	expectedSQL := "delete from [product] where [id] = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Delete")
 }
 
 func TestDeleteWithValues(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
 
-	lReturnedSQL, lReturnedValues := lSQLBuilder.DeleteWithValues("product", ormshift.ColumnsValues{"id": 1})
-	lExpectedSQL := "delete from [product] where [id] = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.DeleteWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 1, len(lReturnedValues), "SQLBuilder.DeleteWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.DeleteWithValues.Values[0]")
+	returnedSQL, returnedValues := sqlBuilder.DeleteWithValues("product", ormshift.ColumnsValues{"id": 1})
+	expectedSQL := "delete from [product] where [id] = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.DeleteWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 1, len(returnedValues), "SQLBuilder.DeleteWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.DeleteWithValues.Values[0]")
 }
 
 func TestSelect(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.Select("product", []string{"id", "name", "description"}, []string{"sku", "active"})
-	lExpectedSQL := "select [id],[name],[description] from [product] where [sku] = @sku and [active] = @active"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Select")
+	returnedSQL := sqlBuilder.Select("product", []string{"id", "name", "description"}, []string{"sku", "active"})
+	expectedSQL := "select [id],[name],[description] from [product] where [sku] = @sku and [active] = @active"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Select")
 }
 
 func TestSelectWithValues(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
-
-	lReturnedSQL, lReturnedValues := lSQLBuilder.SelectWithValues("product", []string{"id", "sku", "name", "description"}, ormshift.ColumnsValues{"category_id": 1, "active": true})
-	lExpectedSQL := "select [id],[sku],[name],[description] from [product] where [active] = @active and [category_id] = @category_id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.SelectWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 2, len(lReturnedValues), "SQLBuilder.SelectWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "active", Value: true}, "SQLBuilder.SelectWithValues.Values[0]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[1], sql.NamedArg{Name: "category_id", Value: 1}, "SQLBuilder.SelectWithValues.Values[1]")
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
+
+	returnedSQL, returnedValues := sqlBuilder.SelectWithValues("product", []string{"id", "sku", "name", "description"}, ormshift.ColumnsValues{"category_id": 1, "active": true})
+	expectedSQL := "select [id],[sku],[name],[description] from [product] where [active] = @active and [category_id] = @category_id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.SelectWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 2, len(returnedValues), "SQLBuilder.SelectWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "active", Value: true}, "SQLBuilder.SelectWithValues.Values[0]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[1], sql.NamedArg{Name: "category_id", Value: 1}, "SQLBuilder.SelectWithValues.Values[1]")
 }
 
 func TestSelectWithPagination(t *testing.T) {
-	lSQLBuilder := sqlserver.Driver().SQLBuilder()
+	sqlBuilder := sqlserver.Driver().SQLBuilder()
 
-	lReturnedSQL := lSQLBuilder.SelectWithPagination("select * from product", 10, 5)
-	lExpectedSQL := "select * from product OFFSET 40 ROWS FETCH NEXT 10 ROWS ONLY"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.SelectWithPagination")
+	returnedSQL := sqlBuilder.SelectWithPagination("select * from product", 10, 5)
+	expectedSQL := "select * from product OFFSET 40 ROWS FETCH NEXT 10 ROWS ONLY"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.SelectWithPagination")
 }
diff --git a/dialects/sqlserver/driver.go b/dialects/sqlserver/driver.go
index e415ade..620edf1 100644
--- a/dialects/sqlserver/driver.go
+++ b/dialects/sqlserver/driver.go
@@ -25,21 +25,21 @@ func (d *sqlserverDriver) Name() string {
 	return "sqlserver"
 }
 
-func (d *sqlserverDriver) ConnectionString(pParams ormshift.ConnectionParams) string {
-	lHostInstanceAndPort := pParams.Host
-	if pParams.Instance != "" {
-		lHostInstanceAndPort = fmt.Sprintf("%s\\%s", pParams.Host, pParams.Instance)
+func (d *sqlserverDriver) ConnectionString(params ormshift.ConnectionParams) string {
+	hostInstanceAndPort := params.Host
+	if params.Instance != "" {
+		hostInstanceAndPort = fmt.Sprintf("%s\\%s", params.Host, params.Instance)
 	}
-	if pParams.Port > 0 {
-		lHostInstanceAndPort += fmt.Sprintf(";port=%d", pParams.Port)
+	if params.Port > 0 {
+		hostInstanceAndPort += fmt.Sprintf(";port=%d", params.Port)
 	}
-	return fmt.Sprintf("server=%s;user id=%s;password=%s;database=%s", lHostInstanceAndPort, pParams.User, pParams.Password, pParams.Database)
+	return fmt.Sprintf("server=%s;user id=%s;password=%s;database=%s", hostInstanceAndPort, params.User, params.Password, params.Database)
 }
 
 func (d *sqlserverDriver) SQLBuilder() ormshift.SQLBuilder {
 	return d.sqlBuilder
 }
 
-func (d *sqlserverDriver) DBSchema(pDB *sql.DB) (*schema.DBSchema, error) {
-	return schema.NewDBSchema(pDB, tableNamesQuery, columnTypesQueryFunc(d.sqlBuilder))
+func (d *sqlserverDriver) DBSchema(db *sql.DB) (*schema.DBSchema, error) {
+	return schema.NewDBSchema(db, tableNamesQuery, columnTypesQueryFunc(d.sqlBuilder))
 }
diff --git a/dialects/sqlserver/driver_test.go b/dialects/sqlserver/driver_test.go
index 040cfb9..f22286c 100644
--- a/dialects/sqlserver/driver_test.go
+++ b/dialects/sqlserver/driver_test.go
@@ -10,13 +10,13 @@ import (
 )
 
 func TestName(t *testing.T) {
-	lDriver := sqlserver.Driver()
-	testutils.AssertEqualWithLabel(t, "sqlserver", lDriver.Name(), "lDriver.Name")
+	driver := sqlserver.Driver()
+	testutils.AssertEqualWithLabel(t, "sqlserver", driver.Name(), "driver.Name")
 }
 
 func TestConnectionString(t *testing.T) {
-	lDriver := sqlserver.Driver()
-	lReturnedConnectionString := lDriver.ConnectionString(ormshift.ConnectionParams{
+	driver := sqlserver.Driver()
+	returnedConnectionString := driver.ConnectionString(ormshift.ConnectionParams{
 		Host:     "my-server",
 		Port:     1433,
 		Instance: "sqlexpress",
@@ -24,29 +24,29 @@ func TestConnectionString(t *testing.T) {
 		Password: "123456",
 		Database: "my-db",
 	})
-	lExpectedConnectionString := "server=my-server\\sqlexpress;port=1433;user id=sa;password=123456;database=my-db"
-	testutils.AssertEqualWithLabel(t, lExpectedConnectionString, lReturnedConnectionString, "lDriver.ConnectionString")
+	expectedConnectionString := "server=my-server\\sqlexpress;port=1433;user id=sa;password=123456;database=my-db"
+	testutils.AssertEqualWithLabel(t, expectedConnectionString, returnedConnectionString, "driver.ConnectionString")
 }
 
 func TestDBSchema(t *testing.T) {
-	lDriver := sqlserver.Driver()
-	lDB, lError := sql.Open(lDriver.Name(), "server=my-server\\sqlexpress;port=1433;user id=sa;password=123456;database=my-db")
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "sql.Open") {
+	driver := sqlserver.Driver()
+	db, err := sql.Open(driver.Name(), "server=my-server\\sqlexpress;port=1433;user id=sa;password=123456;database=my-db")
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "sql.Open") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lSchema, lError := lDriver.DBSchema(lDB)
-	if !testutils.AssertNotNilResultAndNilError(t, lSchema, lError, "lDriver.DBSchema") {
+	schema, err := driver.DBSchema(db)
+	if !testutils.AssertNotNilResultAndNilError(t, schema, err, "driver.DBSchema") {
 		return
 	}
 }
 
 func TestDBSchemaFailsWhenDBIsNil(t *testing.T) {
-	lDriver := sqlserver.Driver()
-	lSchema, lError := lDriver.DBSchema(nil)
-	if !testutils.AssertNilResultAndNotNilError(t, lSchema, lError, "lDriver.DBSchema") {
+	driver := sqlserver.Driver()
+	schema, err := driver.DBSchema(nil)
+	if !testutils.AssertNilResultAndNotNilError(t, schema, err, "driver.DBSchema") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "sql.DB cannot be nil", lError, "lDriver.DBSchema")
+	testutils.AssertErrorMessage(t, "sql.DB cannot be nil", err, "driver.DBSchema")
 }
diff --git a/dialects/sqlserver/schema.go b/dialects/sqlserver/schema.go
index 764086c..0171f90 100644
--- a/dialects/sqlserver/schema.go
+++ b/dialects/sqlserver/schema.go
@@ -22,8 +22,8 @@ const tableNamesQuery = `
 			t.name
 	`
 
-func columnTypesQueryFunc(pSQLBuilder ormshift.SQLBuilder) func(string) string {
-	return func(pTableName string) string {
-		return fmt.Sprintf("SELECT * FROM %s WHERE 1=0", pSQLBuilder.QuoteIdentifier(pTableName))
+func columnTypesQueryFunc(sqlBuilder ormshift.SQLBuilder) func(string) string {
+	return func(table string) string {
+		return fmt.Sprintf("SELECT * FROM %s WHERE 1=0", sqlBuilder.QuoteIdentifier(table))
 	}
 }
diff --git a/dialects/sqlserver/schema_test.go b/dialects/sqlserver/schema_test.go
index db45dcf..b5db51f 100644
--- a/dialects/sqlserver/schema_test.go
+++ b/dialects/sqlserver/schema_test.go
@@ -9,25 +9,25 @@ import (
 )
 
 func TestHasTable(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlserver.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlserver.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	if lDB.DBSchema().HasTable("user") {
+	if db.DBSchema().HasTable("user") {
 		t.Errorf("Expected HasTable('user') to be false")
 	}
 }
 
 func TestHasColumn(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlserver.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlserver.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	if lDB.DBSchema().HasColumn("user", "id") {
+	if db.DBSchema().HasColumn("user", "id") {
 		t.Errorf("Expected HasColumn('user', 'id') to be false")
 	}
 }
diff --git a/executor_test.go b/executor_test.go
index bc0d4f9..bb8acc6 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -23,27 +23,27 @@ type userRow struct {
 }
 
 func TestExecutor(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lMigrationManager, lError := migrations.Migrate(
-		lDB,
+	migrationManager, err := migrations.Migrate(
+		db,
 		migrations.NewMigratorConfig(),
 		testutils.M001_Create_Table_User{},
 		testutils.M002_Alter_Table_User_Add_Column_UpdatedAt{},
 	)
-	if !testutils.AssertNotNilResultAndNilError(t, lMigrationManager, lError, "migrations.Migrate") {
+	if !testutils.AssertNotNilResultAndNilError(t, migrationManager, err, "migrations.Migrate") {
 		return
 	}
 
-	lSQLExecutor := lDB.SQLExecutor()
-	lSQLBuilder := lDB.SQLBuilder()
+	sqlExecutor := db.SQLExecutor()
+	sqlBuilder := db.SQLBuilder()
 
 	//INSERT
-	lValues := ormshift.ColumnsValues{
+	values := ormshift.ColumnsValues{
 		"name":       "Jonh Doe",
 		"email":      "jonh.doe@mail.com",
 		"updated_at": time.Date(2026, time.January, 9, 12, 15, 52, 100952002, time.UTC),
@@ -51,57 +51,57 @@ func TestExecutor(t *testing.T) {
 		"ammount":    5000.00,
 		"percent":    25.54325,
 	}
-	lSQLInsert, lArgs := lSQLBuilder.InsertWithValues("user", lValues)
-	lResult, lError := lSQLExecutor.Exec(lSQLInsert, lArgs...)
-	if !testutils.AssertNilError(t, lError, "sqlExecutor.Exec") {
+	sql, args := sqlBuilder.InsertWithValues("user", values)
+	result, err := sqlExecutor.Exec(sql, args...)
+	if !testutils.AssertNilError(t, err, "sqlExecutor.Exec") {
 		return
 	}
-	r, lError := lResult.RowsAffected()
-	if !testutils.AssertNilError(t, lError, "RowsAffected") {
+	r, err := result.RowsAffected()
+	if !testutils.AssertNilError(t, err, "RowsAffected") {
 		return
 	}
 	testutils.AssertEqualWithLabel(t, 1, r, "RowsAffected")
-	i, lError := lResult.LastInsertId()
-	if !testutils.AssertNilError(t, lError, "LastInsertId") {
+	i, err := result.LastInsertId()
+	if !testutils.AssertNilError(t, err, "LastInsertId") {
 		return
 	}
 
 	//SELECT
-	lSQLSelect, lArgs := lSQLBuilder.SelectWithValues(
+	sql, args = sqlBuilder.SelectWithValues(
 		"user",
 		[]string{"id", "name", "email", "updated_at", "active", "ammount", "percent", "photo"},
 		ormshift.ColumnsValues{"id": i},
 	)
-	lUserRows, lError := lSQLExecutor.Query(lSQLSelect, lArgs...)
-	if !testutils.AssertNotNilResultAndNilError(t, lUserRows, lError, "sqlExecutor.Query") {
+	userRows, err := sqlExecutor.Query(sql, args...)
+	if !testutils.AssertNotNilResultAndNilError(t, userRows, err, "sqlExecutor.Query") {
 		return
 	}
-	defer func() { _ = lUserRows.Close() }()
-	if !testutils.AssertEqualWithLabel(t, true, lUserRows.Next(), "Next") {
+	defer func() { _ = userRows.Close() }()
+	if !testutils.AssertEqualWithLabel(t, true, userRows.Next(), "Next") {
 		return
 	}
 
 	//SCAN
-	var lUserRow userRow
-	lError = lUserRows.Scan(
-		&lUserRow.ID,
-		&lUserRow.Name,
-		&lUserRow.Email,
-		&lUserRow.UpdatedAt,
-		&lUserRow.Active,
-		&lUserRow.Ammount,
-		&lUserRow.Percent,
-		&lUserRow.Photo,
+	var userRow userRow
+	err = userRows.Scan(
+		&userRow.ID,
+		&userRow.Name,
+		&userRow.Email,
+		&userRow.UpdatedAt,
+		&userRow.Active,
+		&userRow.Ammount,
+		&userRow.Percent,
+		&userRow.Photo,
 	)
-	if !testutils.AssertNilError(t, lError, "Scan") {
+	if !testutils.AssertNilError(t, err, "Scan") {
 		return
 	}
-	testutils.AssertEqualWithLabel(t, i, lUserRow.ID.Int64, "user.id")
-	testutils.AssertEqualWithLabel(t, "Jonh Doe", lUserRow.Name.String, "user.name")
-	testutils.AssertEqualWithLabel(t, "jonh.doe@mail.com", lUserRow.Email.String, "user.email")
-	testutils.AssertEqualWithLabel(t, time.Date(2026, time.January, 9, 12, 15, 52, 100952002, time.UTC), lUserRow.UpdatedAt.Time, "user.updated_at")
-	testutils.AssertEqualWithLabel(t, 1, lUserRow.Active.Byte, "user.active")
-	testutils.AssertEqualWithLabel(t, 5000.00, lUserRow.Ammount.Float64, "user.ammount")
-	testutils.AssertEqualWithLabel(t, 25.54325, lUserRow.Percent.Float64, "user.percent")
-	testutils.AssertEqualWithLabel(t, nil, lUserRow.Photo, "user.photo")
+	testutils.AssertEqualWithLabel(t, i, userRow.ID.Int64, "user.id")
+	testutils.AssertEqualWithLabel(t, "Jonh Doe", userRow.Name.String, "user.name")
+	testutils.AssertEqualWithLabel(t, "jonh.doe@mail.com", userRow.Email.String, "user.email")
+	testutils.AssertEqualWithLabel(t, time.Date(2026, time.January, 9, 12, 15, 52, 100952002, time.UTC), userRow.UpdatedAt.Time, "user.updated_at")
+	testutils.AssertEqualWithLabel(t, 1, userRow.Active.Byte, "user.active")
+	testutils.AssertEqualWithLabel(t, 5000.00, userRow.Ammount.Float64, "user.ammount")
+	testutils.AssertEqualWithLabel(t, 25.54325, userRow.Percent.Float64, "user.percent")
+	testutils.AssertEqualWithLabel(t, nil, userRow.Photo, "user.photo")
 }
diff --git a/internal/builder_generic.go b/internal/builder_generic.go
index 1f061bd..1bcd96b 100644
--- a/internal/builder_generic.go
+++ b/internal/builder_generic.go
@@ -13,7 +13,7 @@ type ColumnDefinitionFunc func(schema.Column) string
 
 type QuoteIdentifierFunc func(string) string
 
-type InteroperateSQLCommandWithNamedArgsFunc func(pSQLCommand string, pNamedArgs ...sql.NamedArg) (string, []any)
+type InteroperateSQLCommandWithNamedArgsFunc func(sql string, args ...sql.NamedArg) (string, []any)
 
 type genericSQLBuilder struct {
 	ColumnDefinitionFunc                    ColumnDefinitionFunc
@@ -22,178 +22,177 @@ type genericSQLBuilder struct {
 }
 
 func NewGenericSQLBuilder(
-	pColumnDefinitionFunc ColumnDefinitionFunc,
-	pQuoteIdentifierFunc QuoteIdentifierFunc,
-	pInteroperateSQLCommandWithNamedArgsFunc InteroperateSQLCommandWithNamedArgsFunc,
+	columnDefinitionFunc ColumnDefinitionFunc,
+	quoteIdentifierFunc QuoteIdentifierFunc,
+	interoperateSQLCommandWithNamedArgsFunc InteroperateSQLCommandWithNamedArgsFunc,
 ) ormshift.SQLBuilder {
 	return &genericSQLBuilder{
-		ColumnDefinitionFunc:                    pColumnDefinitionFunc,
-		QuoteIdentifierFunc:                     pQuoteIdentifierFunc,
-		InteroperateSQLCommandWithNamedArgsFunc: pInteroperateSQLCommandWithNamedArgsFunc,
+		ColumnDefinitionFunc:                    columnDefinitionFunc,
+		QuoteIdentifierFunc:                     quoteIdentifierFunc,
+		InteroperateSQLCommandWithNamedArgsFunc: interoperateSQLCommandWithNamedArgsFunc,
 	}
 }
 
-func (sb *genericSQLBuilder) CreateTable(pTable schema.Table) string {
-	lColumns := ""
-	lPKColumns := ""
-	for _, lColumn := range pTable.Columns() {
-		if lColumns != "" {
-			lColumns += ","
+func (sb *genericSQLBuilder) CreateTable(table schema.Table) string {
+	columns := ""
+	pkColumns := ""
+	for _, column := range table.Columns() {
+		if columns != "" {
+			columns += ","
 		}
-		lColumns += sb.columnDefinition(lColumn)
+		columns += sb.columnDefinition(column)
 
-		if lColumn.PrimaryKey() {
-			if lPKColumns != "" {
-				lPKColumns += ","
+		if column.PrimaryKey() {
+			if pkColumns != "" {
+				pkColumns += ","
 			}
-			lPKColumns += sb.QuoteIdentifier(lColumn.Name())
+			pkColumns += sb.QuoteIdentifier(column.Name())
 		}
 	}
 
-	if lPKColumns != "" {
-		if lColumns != "" {
-			lColumns += ","
+	if pkColumns != "" {
+		if columns != "" {
+			columns += ","
 		}
-		lColumns += fmt.Sprintf("PRIMARY KEY (%s)", lPKColumns)
+		columns += fmt.Sprintf("PRIMARY KEY (%s)", pkColumns)
 	}
-	return fmt.Sprintf("CREATE TABLE %s (%s);", sb.QuoteIdentifier(pTable.Name()), lColumns)
+	return fmt.Sprintf("CREATE TABLE %s (%s);", sb.QuoteIdentifier(table.Name()), columns)
 }
 
-func (sb *genericSQLBuilder) DropTable(pTableName string) string {
-	return fmt.Sprintf("DROP TABLE %s;", sb.QuoteIdentifier(pTableName))
+func (sb *genericSQLBuilder) DropTable(table string) string {
+	return fmt.Sprintf("DROP TABLE %s;", sb.QuoteIdentifier(table))
 }
 
-func (sb *genericSQLBuilder) AlterTableAddColumn(pTableName string, pColumn schema.Column) string {
-	return fmt.Sprintf("ALTER TABLE %s ADD COLUMN %s;", sb.QuoteIdentifier(pTableName), sb.columnDefinition(pColumn))
+func (sb *genericSQLBuilder) AlterTableAddColumn(table string, column schema.Column) string {
+	return fmt.Sprintf("ALTER TABLE %s ADD COLUMN %s;", sb.QuoteIdentifier(table), sb.columnDefinition(column))
 }
 
-func (sb *genericSQLBuilder) AlterTableDropColumn(pTableName, pColumnName string) string {
-	return fmt.Sprintf("ALTER TABLE %s DROP COLUMN %s;", sb.QuoteIdentifier(pTableName), sb.QuoteIdentifier(pColumnName))
+func (sb *genericSQLBuilder) AlterTableDropColumn(table, column string) string {
+	return fmt.Sprintf("ALTER TABLE %s DROP COLUMN %s;", sb.QuoteIdentifier(table), sb.QuoteIdentifier(column))
 }
 
-func (sb *genericSQLBuilder) ColumnTypeAsString(pColumnType schema.ColumnType) string {
+func (sb *genericSQLBuilder) ColumnTypeAsString(columnType schema.ColumnType) string {
 	// Generic implementation, should be overridden by specific SQL builders
-	return fmt.Sprintf("<<TYPE_%d>>", pColumnType)
+	return fmt.Sprintf("<<TYPE_%d>>", columnType)
 }
 
-func (sb *genericSQLBuilder) columnDefinition(pColumn schema.Column) string {
+func (sb *genericSQLBuilder) columnDefinition(column schema.Column) string {
 	if sb.ColumnDefinitionFunc != nil {
-		return sb.ColumnDefinitionFunc(pColumn)
+		return sb.ColumnDefinitionFunc(column)
 	}
-	return fmt.Sprintf("%s %s", sb.QuoteIdentifier(pColumn.Name()), sb.ColumnTypeAsString(pColumn.Type()))
+	return fmt.Sprintf("%s %s", sb.QuoteIdentifier(column.Name()), sb.ColumnTypeAsString(column.Type()))
 }
 
-func (sb *genericSQLBuilder) Insert(pTableName string, pColumns []string) string {
-	return fmt.Sprintf("insert into %s (%s) values (%s)", sb.QuoteIdentifier(pTableName), sb.columnsList(pColumns), sb.namesList(pColumns))
+func (sb *genericSQLBuilder) Insert(table string, columns []string) string {
+	return fmt.Sprintf("insert into %s (%s) values (%s)", sb.QuoteIdentifier(table), sb.columnsList(columns), sb.namesList(columns))
 }
 
-func (sb *genericSQLBuilder) InsertWithValues(pTableName string, pColumnsValues ormshift.ColumnsValues) (string, []any) {
-	lInsertSQL := sb.Insert(pTableName, pColumnsValues.ToColumns())
-	lInsertArgs := pColumnsValues.ToNamedArgs()
-	return sb.InteroperateSQLCommandWithNamedArgs(lInsertSQL, lInsertArgs...)
+func (sb *genericSQLBuilder) InsertWithValues(table string, values ormshift.ColumnsValues) (string, []any) {
+	insertSQL := sb.Insert(table, values.ToColumns())
+	insertArgs := values.ToNamedArgs()
+	return sb.InteroperateSQLCommandWithNamedArgs(insertSQL, insertArgs...)
 }
 
-func (sb *genericSQLBuilder) Update(pTableName string, pColumns, pColumnsWhere []string) string {
-	lUpdate := fmt.Sprintf("update %s set %s ", sb.QuoteIdentifier(pTableName), sb.columnEqualNameList(pColumns, ","))
-	if len(pColumnsWhere) > 0 {
-		lUpdate += fmt.Sprintf("where %s", sb.columnEqualNameList(pColumnsWhere, " and ")) // NOSONAR go:S1192 - duplicate tradeoff accepted
+func (sb *genericSQLBuilder) Update(table string, columns, where []string) string {
+	update := fmt.Sprintf("update %s set %s ", sb.QuoteIdentifier(table), sb.columnEqualNameList(columns, ","))
+	if len(where) > 0 {
+		update += fmt.Sprintf("where %s", sb.columnEqualNameList(where, " and ")) // NOSONAR go:S1192 - duplicate tradeoff accepted
 	}
-	return lUpdate
+	return update
 }
 
-func (sb *genericSQLBuilder) UpdateWithValues(pTableName string, pColumns, pColumnsWhere []string, pValues ormshift.ColumnsValues) (string, []any) {
-	lUpdateSQL := sb.Update(pTableName, pColumns, pColumnsWhere)
-	lUpdateArgs := pValues.ToNamedArgs()
-	return sb.InteroperateSQLCommandWithNamedArgs(lUpdateSQL, lUpdateArgs...)
+func (sb *genericSQLBuilder) UpdateWithValues(table string, columns, where []string, values ormshift.ColumnsValues) (string, []any) {
+	updateSQL := sb.Update(table, columns, where)
+	updateArgs := values.ToNamedArgs()
+	return sb.InteroperateSQLCommandWithNamedArgs(updateSQL, updateArgs...)
 }
 
-func (sb *genericSQLBuilder) Delete(pTableName string, pColumnsWhere []string) string {
-	lDelete := fmt.Sprintf("delete from %s ", sb.QuoteIdentifier(pTableName))
-	if len(pColumnsWhere) > 0 {
-		lDelete += fmt.Sprintf("where %s", sb.columnEqualNameList(pColumnsWhere, " and ")) // NOSONAR go:S1192 - duplicate tradeoff accepted
+func (sb *genericSQLBuilder) Delete(table string, where []string) string {
+	delete := fmt.Sprintf("delete from %s ", sb.QuoteIdentifier(table))
+	if len(where) > 0 {
+		delete += fmt.Sprintf("where %s", sb.columnEqualNameList(where, " and ")) // NOSONAR go:S1192 - duplicate tradeoff accepted
 	}
-	return lDelete
+	return delete
 }
 
-func (sb *genericSQLBuilder) DeleteWithValues(pTableName string, pWhereColumnsValues ormshift.ColumnsValues) (string, []any) {
-	lDeleteSQL := sb.Delete(pTableName, pWhereColumnsValues.ToColumns())
-	lDeleteArgs := pWhereColumnsValues.ToNamedArgs()
-	return sb.InteroperateSQLCommandWithNamedArgs(lDeleteSQL, lDeleteArgs...)
+func (sb *genericSQLBuilder) DeleteWithValues(table string, where ormshift.ColumnsValues) (string, []any) {
+	deleteSQL := sb.Delete(table, where.ToColumns())
+	deleteArgs := where.ToNamedArgs()
+	return sb.InteroperateSQLCommandWithNamedArgs(deleteSQL, deleteArgs...)
 }
 
-func (sb *genericSQLBuilder) Select(pTableName string, pColumns, pColumnsWhere []string) string {
-	lUpdate := fmt.Sprintf("select %s from %s ", sb.columnsList(pColumns), sb.QuoteIdentifier(pTableName))
-	if len(pColumnsWhere) > 0 {
-		lUpdate += fmt.Sprintf("where %s", sb.columnEqualNameList(pColumnsWhere, " and ")) // NOSONAR go:S1192 - duplicate tradeoff accepted
+func (sb *genericSQLBuilder) Select(table string, columns, where []string) string {
+	update := fmt.Sprintf("select %s from %s ", sb.columnsList(columns), sb.QuoteIdentifier(table))
+	if len(where) > 0 {
+		update += fmt.Sprintf("where %s", sb.columnEqualNameList(where, " and ")) // NOSONAR go:S1192 - duplicate tradeoff accepted
 	}
-	return lUpdate
+	return update
 }
 
-func (sb *genericSQLBuilder) SelectWithValues(pTableName string, pColumns []string, pWhereColumnsValues ormshift.ColumnsValues) (string, []any) {
-	lSelectSQL := sb.Select(pTableName, pColumns, pWhereColumnsValues.ToColumns())
-	lSelectArgs := pWhereColumnsValues.ToNamedArgs()
-	return sb.InteroperateSQLCommandWithNamedArgs(lSelectSQL, lSelectArgs...)
+func (sb *genericSQLBuilder) SelectWithValues(table string, columns []string, where ormshift.ColumnsValues) (string, []any) {
+	selectSQL := sb.Select(table, columns, where.ToColumns())
+	selectArgs := where.ToNamedArgs()
+	return sb.InteroperateSQLCommandWithNamedArgs(selectSQL, selectArgs...)
 }
 
-func (sb *genericSQLBuilder) SelectWithPagination(pSQLSelectCommand string, pRowsPerPage, pPageNumber uint) string {
-	lSelectWithPagination := pSQLSelectCommand
-	if pRowsPerPage > 0 {
-		lSelectWithPagination += fmt.Sprintf(" LIMIT %d", pRowsPerPage)
-		if pPageNumber > 1 {
-			lSelectWithPagination += fmt.Sprintf(" OFFSET %d", pRowsPerPage*(pPageNumber-1))
+func (sb *genericSQLBuilder) SelectWithPagination(sql string, size, number uint) string {
+	selectWithPagination := sql
+	if size > 0 {
+		selectWithPagination += fmt.Sprintf(" LIMIT %d", size)
+		if number > 1 {
+			selectWithPagination += fmt.Sprintf(" OFFSET %d", size*(number-1))
 		}
 	}
-	return lSelectWithPagination
+	return selectWithPagination
 }
 
-func (sb *genericSQLBuilder) columnsList(pColumns []string) string {
-	lQuotedColumns := []string{}
-	for _, col := range pColumns {
-		lQuotedColumns = append(lQuotedColumns, sb.QuoteIdentifier(col))
+func (sb *genericSQLBuilder) columnsList(columns []string) string {
+	quotedColumns := []string{}
+	for _, col := range columns {
+		quotedColumns = append(quotedColumns, sb.QuoteIdentifier(col))
 	}
-	return strings.Join(lQuotedColumns, ",")
+	return strings.Join(quotedColumns, ",")
 }
 
-func (sb *genericSQLBuilder) namesList(pColumns []string) string {
-	lNames := []string{}
-	for _, lColumn := range pColumns {
-		lNames = append(lNames, "@"+lColumn)
+func (sb *genericSQLBuilder) namesList(columns []string) string {
+	names := []string{}
+	for _, column := range columns {
+		names = append(names, "@"+column)
 	}
-	return strings.Join(lNames, ",")
+	return strings.Join(names, ",")
 }
 
-func (sb *genericSQLBuilder) columnEqualNameList(pColumns []string, pSeparator string) string {
-	lColumnEqualNameList := ""
-	for _, lColumn := range pColumns {
-		if lColumnEqualNameList != "" {
-			lColumnEqualNameList += pSeparator
+func (sb *genericSQLBuilder) columnEqualNameList(columns []string, separator string) string {
+	columnEqualNameList := ""
+	for _, column := range columns {
+		if columnEqualNameList != "" {
+			columnEqualNameList += separator
 		}
-		lColumnEqualNameList += fmt.Sprintf("%s = @%s", sb.QuoteIdentifier(lColumn), lColumn)
+		columnEqualNameList += fmt.Sprintf("%s = @%s", sb.QuoteIdentifier(column), column)
 	}
-	return lColumnEqualNameList
+	return columnEqualNameList
 }
 
-func (sb *genericSQLBuilder) QuoteIdentifier(pIdentifier string) string {
+func (sb *genericSQLBuilder) QuoteIdentifier(identifier string) string {
 	if sb.QuoteIdentifierFunc != nil {
-		return sb.QuoteIdentifierFunc(pIdentifier)
+		return sb.QuoteIdentifierFunc(identifier)
 	}
 
 	// Most databases uses double quotes: "identifier" (PostgreSQL, SQLite, etc.)
 	// Escape rule: double quote becomes two double quotes
 	// Example: users -> "users", table"name -> "table""name"
-	pIdentifier = strings.ReplaceAll(pIdentifier, `"`, `""`)
-	return fmt.Sprintf(`"%s"`, pIdentifier)
+	identifier = strings.ReplaceAll(identifier, `"`, `""`)
+	return fmt.Sprintf(`"%s"`, identifier)
 }
 
-func (sb *genericSQLBuilder) InteroperateSQLCommandWithNamedArgs(pSQLCommand string, pNamedArgs ...sql.NamedArg) (string, []any) {
+func (sb *genericSQLBuilder) InteroperateSQLCommandWithNamedArgs(sql string, args ...sql.NamedArg) (string, []any) {
 	if sb.InteroperateSQLCommandWithNamedArgsFunc != nil {
-		return sb.InteroperateSQLCommandWithNamedArgsFunc(pSQLCommand, pNamedArgs...)
+		return sb.InteroperateSQLCommandWithNamedArgsFunc(sql, args...)
 	}
 
-	lSQLCommand := pSQLCommand
-	lArgs := []any{}
-	for _, lParam := range pNamedArgs {
-		lArgs = append(lArgs, lParam)
+	a := []any{}
+	for _, param := range args {
+		a = append(a, param)
 	}
-	return lSQLCommand, lArgs
+	return sql, a
 }
diff --git a/internal/builder_generic_test.go b/internal/builder_generic_test.go
index 03d1a1c..c574b4b 100644
--- a/internal/builder_generic_test.go
+++ b/internal/builder_generic_test.go
@@ -11,156 +11,156 @@ import (
 )
 
 func TestCreateTable(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lUserTable := testutils.FakeUserTable(t)
-	lExpectedSQL := "CREATE TABLE \"user\" (\"id\" <<TYPE_0>>,\"email\" <<TYPE_1>>,\"name\" <<TYPE_1>>,\"password_hash\" <<TYPE_1>>," +
+	userTable := testutils.FakeUserTable(t)
+	expectedSQL := "CREATE TABLE \"user\" (\"id\" <<TYPE_0>>,\"email\" <<TYPE_1>>,\"name\" <<TYPE_1>>,\"password_hash\" <<TYPE_1>>," +
 		"\"active\" <<TYPE_5>>,\"created_at\" <<TYPE_3>>,\"user_master\" <<TYPE_0>>,\"master_user_id\" <<TYPE_0>>," +
 		"\"licence_price\" <<TYPE_2>>,\"relevance\" <<TYPE_4>>,\"photo\" <<TYPE_6>>,\"any\" <<TYPE_-1>>,PRIMARY KEY (\"id\",\"email\"));"
-	lReturnedSQL := lSQLBuilder.CreateTable(lUserTable)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.CreateTable")
+	returnedSQL := sqlBuilder.CreateTable(userTable)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.CreateTable")
 
-	lProductAttributeTable := testutils.FakeProductAttributeTable(t)
-	lExpectedSQL = "CREATE TABLE \"product_attribute\" (\"product_id\" <<TYPE_0>>,\"attribute_id\" <<TYPE_0>>,\"value\" <<TYPE_1>>,\"position\" <<TYPE_0>>,PRIMARY KEY (\"product_id\",\"attribute_id\"));"
-	lReturnedSQL = lSQLBuilder.CreateTable(lProductAttributeTable)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.CreateTable")
+	productAttributeTable := testutils.FakeProductAttributeTable(t)
+	expectedSQL = "CREATE TABLE \"product_attribute\" (\"product_id\" <<TYPE_0>>,\"attribute_id\" <<TYPE_0>>,\"value\" <<TYPE_1>>,\"position\" <<TYPE_0>>,PRIMARY KEY (\"product_id\",\"attribute_id\"));"
+	returnedSQL = sqlBuilder.CreateTable(productAttributeTable)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.CreateTable")
 }
 
 func TestDropTable(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lExpectedSQL := "DROP TABLE \"user\";"
-	lReturnedSQL := lSQLBuilder.DropTable(lUserTableName)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.DropTable")
+	userTableName := testutils.FakeUserTableName(t)
+	expectedSQL := "DROP TABLE \"user\";"
+	returnedSQL := sqlBuilder.DropTable(userTableName)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.DropTable")
 }
 
 func TestAlterTableAddColumn(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lUpdatedAtColumn := testutils.FakeUpdatedAtColumn(t)
-	lExpectedSQL := "ALTER TABLE \"user\" ADD COLUMN \"updated_at\" <<TYPE_3>>;"
-	lReturnedSQL := lSQLBuilder.AlterTableAddColumn(lUserTableName, lUpdatedAtColumn)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.AlterTableAddColumn")
+	userTableName := testutils.FakeUserTableName(t)
+	updatedAtColumn := testutils.FakeUpdatedAtColumn(t)
+	expectedSQL := "ALTER TABLE \"user\" ADD COLUMN \"updated_at\" <<TYPE_3>>;"
+	returnedSQL := sqlBuilder.AlterTableAddColumn(userTableName, updatedAtColumn)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.AlterTableAddColumn")
 }
 
 func TestAlterTableDropColumn(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lUserTableName := testutils.FakeUserTableName(t)
-	lUpdatedAtColumnName := testutils.FakeUpdatedAtColumnName(t)
-	lExpectedSQL := "ALTER TABLE \"user\" DROP COLUMN \"updated_at\";"
-	lReturnedSQL := lSQLBuilder.AlterTableDropColumn(lUserTableName, lUpdatedAtColumnName)
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.AlterTableDropColumn")
+	userTableName := testutils.FakeUserTableName(t)
+	updatedAtColumnName := testutils.FakeUpdatedAtColumnName(t)
+	expectedSQL := "ALTER TABLE \"user\" DROP COLUMN \"updated_at\";"
+	returnedSQL := sqlBuilder.AlterTableDropColumn(userTableName, updatedAtColumnName)
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.AlterTableDropColumn")
 }
 
 func TestInsert(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lReturnedSQL := lSQLBuilder.Insert("product", []string{"id", "sku", "name", "description"})
-	lExpectedSQL := "insert into \"product\" (\"id\",\"sku\",\"name\",\"description\") values (@id,@sku,@name,@description)"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Insert")
+	returnedSQL := sqlBuilder.Insert("product", []string{"id", "sku", "name", "description"})
+	expectedSQL := "insert into \"product\" (\"id\",\"sku\",\"name\",\"description\") values (@id,@sku,@name,@description)"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Insert")
 }
 
 func TestInsertWithValues(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lReturnedSQL, lReturnedValues := lSQLBuilder.InsertWithValues("product", ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.9", "name": "Trufa Sabor Amarula 30g Cacaushow"})
-	lExpectedSQL := "insert into \"product\" (\"id\",\"name\",\"sku\") values (@id,@name,@sku)"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.InsertWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 3, len(lReturnedValues), "SQLBuilder.InsertWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.InsertWithValues.Values[0]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 30g Cacaushow"}, "SQLBuilder.InsertWithValues.Values[1]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.9"}, "SQLBuilder.InsertWithValues.Values[2]")
+	returnedSQL, returnedValues := sqlBuilder.InsertWithValues("product", ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.9", "name": "Trufa Sabor Amarula 30g Cacaushow"})
+	expectedSQL := "insert into \"product\" (\"id\",\"name\",\"sku\") values (@id,@name,@sku)"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.InsertWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 3, len(returnedValues), "SQLBuilder.InsertWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.InsertWithValues.Values[0]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 30g Cacaushow"}, "SQLBuilder.InsertWithValues.Values[1]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.9"}, "SQLBuilder.InsertWithValues.Values[2]")
 }
 
 func TestUpdate(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lReturnedSQL := lSQLBuilder.Update("product", []string{"sku", "name", "description"}, []string{"id"})
-	lExpectedSQL := "update \"product\" set \"sku\" = @sku,\"name\" = @name,\"description\" = @description where \"id\" = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Update")
+	returnedSQL := sqlBuilder.Update("product", []string{"sku", "name", "description"}, []string{"id"})
+	expectedSQL := "update \"product\" set \"sku\" = @sku,\"name\" = @name,\"description\" = @description where \"id\" = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Update")
 }
 
 func TestUpdateWithValues(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lReturnedSQL, lReturnedValues := lSQLBuilder.UpdateWithValues("product", []string{"sku", "name"}, []string{"id"}, ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.5", "name": "Trufa Sabor Amarula 18g Cacaushow"})
-	lExpectedSQL := "update \"product\" set \"sku\" = @sku,\"name\" = @name where \"id\" = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.UpdateWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 3, len(lReturnedValues), "SQLBuilder.UpdateWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.UpdateWithValues.Values[0]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 18g Cacaushow"}, "SQLBuilder.UpdateWithValues.Values[1]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.5"}, "SQLBuilder.UpdateWithValues.Values[2]")
+	returnedSQL, returnedValues := sqlBuilder.UpdateWithValues("product", []string{"sku", "name"}, []string{"id"}, ormshift.ColumnsValues{"id": 1, "sku": "1.005.12.5", "name": "Trufa Sabor Amarula 18g Cacaushow"})
+	expectedSQL := "update \"product\" set \"sku\" = @sku,\"name\" = @name where \"id\" = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.UpdateWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 3, len(returnedValues), "SQLBuilder.UpdateWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.UpdateWithValues.Values[0]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[1], sql.NamedArg{Name: "name", Value: "Trufa Sabor Amarula 18g Cacaushow"}, "SQLBuilder.UpdateWithValues.Values[1]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[2], sql.NamedArg{Name: "sku", Value: "1.005.12.5"}, "SQLBuilder.UpdateWithValues.Values[2]")
 }
 
 func TestDelete(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lReturnedSQL := lSQLBuilder.Delete("product", []string{"id"})
-	lExpectedSQL := "delete from \"product\" where \"id\" = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Delete")
+	returnedSQL := sqlBuilder.Delete("product", []string{"id"})
+	expectedSQL := "delete from \"product\" where \"id\" = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Delete")
 }
 
 func TestDeleteWithValues(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lReturnedSQL, lReturnedValues := lSQLBuilder.DeleteWithValues("product", ormshift.ColumnsValues{"id": 1})
-	lExpectedSQL := "delete from \"product\" where \"id\" = @id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.DeleteWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 1, len(lReturnedValues), "SQLBuilder.DeleteWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.DeleteWithValues.Values[0]")
+	returnedSQL, returnedValues := sqlBuilder.DeleteWithValues("product", ormshift.ColumnsValues{"id": 1})
+	expectedSQL := "delete from \"product\" where \"id\" = @id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.DeleteWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 1, len(returnedValues), "SQLBuilder.DeleteWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "id", Value: 1}, "SQLBuilder.DeleteWithValues.Values[0]")
 }
 
 func TestSelect(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lReturnedSQL := lSQLBuilder.Select("product", []string{"id", "name", "description"}, []string{"sku", "active"})
-	lExpectedSQL := "select \"id\",\"name\",\"description\" from \"product\" where \"sku\" = @sku and \"active\" = @active"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.Select")
+	returnedSQL := sqlBuilder.Select("product", []string{"id", "name", "description"}, []string{"sku", "active"})
+	expectedSQL := "select \"id\",\"name\",\"description\" from \"product\" where \"sku\" = @sku and \"active\" = @active"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.Select")
 }
 
 func TestSelectWithValues(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lReturnedSQL, lReturnedValues := lSQLBuilder.SelectWithValues("product", []string{"id", "sku", "name", "description"}, ormshift.ColumnsValues{"category_id": 1, "active": true})
-	lExpectedSQL := "select \"id\",\"sku\",\"name\",\"description\" from \"product\" where \"active\" = @active and \"category_id\" = @category_id"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.SelectWithValues.SQL")
-	testutils.AssertEqualWithLabel(t, 2, len(lReturnedValues), "SQLBuilder.SelectWithValues.Values")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[0], sql.NamedArg{Name: "active", Value: true}, "SQLBuilder.SelectWithValues.Values[0]")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedValues[1], sql.NamedArg{Name: "category_id", Value: 1}, "SQLBuilder.SelectWithValues.Values[1]")
+	returnedSQL, returnedValues := sqlBuilder.SelectWithValues("product", []string{"id", "sku", "name", "description"}, ormshift.ColumnsValues{"category_id": 1, "active": true})
+	expectedSQL := "select \"id\",\"sku\",\"name\",\"description\" from \"product\" where \"active\" = @active and \"category_id\" = @category_id"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.SelectWithValues.SQL")
+	testutils.AssertEqualWithLabel(t, 2, len(returnedValues), "SQLBuilder.SelectWithValues.Values")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[0], sql.NamedArg{Name: "active", Value: true}, "SQLBuilder.SelectWithValues.Values[0]")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedValues[1], sql.NamedArg{Name: "category_id", Value: 1}, "SQLBuilder.SelectWithValues.Values[1]")
 }
 
 func TestSelectWithPagination(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, nil)
 
-	lReturnedSQL := lSQLBuilder.SelectWithPagination("select * from product", 10, 5)
-	lExpectedSQL := "select * from product LIMIT 10 OFFSET 40"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.SelectWithPagination")
+	returnedSQL := sqlBuilder.SelectWithPagination("select * from product", 10, 5)
+	expectedSQL := "select * from product LIMIT 10 OFFSET 40"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.SelectWithPagination")
 }
 
 func TestInteroperateSQLCommandWithNamedArgs(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, nil, testutils.FakeInteroperateSQLCommandWithNamedArgsFunc)
-	lReturnedSQL, lReturnedNamedArgs := lSQLBuilder.InteroperateSQLCommandWithNamedArgs("original command", sql.NamedArg{Name: "param1", Value: 1})
-	lExpectedSQL := "command has been modified"
-	testutils.AssertEqualWithLabel(t, lExpectedSQL, lReturnedSQL, "SQLBuilder.InteroperateSQLCommandWithNamedArgs.SQL")
-	testutils.AssertEqualWithLabel(t, 1, len(lReturnedNamedArgs), "SQLBuilder.InteroperateSQLCommandWithNamedArgs.NamedArgs")
-	testutils.AssertNamedArgEqualWithLabel(t, lReturnedNamedArgs[0], sql.NamedArg{Name: "param1", Value: 1}, "SQLBuilder.InteroperateSQLCommandWithNamedArgs.NamedArgs[0]")
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, nil, testutils.FakeInteroperateSQLCommandWithNamedArgsFunc)
+	returnedSQL, returnedNamedArgs := sqlBuilder.InteroperateSQLCommandWithNamedArgs("original command", sql.NamedArg{Name: "param1", Value: 1})
+	expectedSQL := "command has been modified"
+	testutils.AssertEqualWithLabel(t, expectedSQL, returnedSQL, "SQLBuilder.InteroperateSQLCommandWithNamedArgs.SQL")
+	testutils.AssertEqualWithLabel(t, 1, len(returnedNamedArgs), "SQLBuilder.InteroperateSQLCommandWithNamedArgs.NamedArgs")
+	testutils.AssertNamedArgEqualWithLabel(t, returnedNamedArgs[0], sql.NamedArg{Name: "param1", Value: 1}, "SQLBuilder.InteroperateSQLCommandWithNamedArgs.NamedArgs[0]")
 }
 
 func TestColumnDefinition(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(testutils.FakeColumnDefinitionFunc, nil, nil)
-	lColumn := schema.NewColumn(schema.NewColumnParams{Name: "column_name", Type: schema.Integer, Size: 0})
-	lTableName := "test_table"
-	lReturnedSQL := lSQLBuilder.AlterTableAddColumn(lTableName, lColumn)
-	testutils.AssertEqualWithLabel(t, "ALTER TABLE \"test_table\" ADD COLUMN fake;", lReturnedSQL, "SQLBuilder.ColumnDefinition")
+	sqlBuilder := internal.NewGenericSQLBuilder(testutils.FakeColumnDefinitionFunc, nil, nil)
+	column := schema.NewColumn(schema.NewColumnParams{Name: "column_name", Type: schema.Integer, Size: 0})
+	table := "test_table"
+	returnedSQL := sqlBuilder.AlterTableAddColumn(table, column)
+	testutils.AssertEqualWithLabel(t, "ALTER TABLE \"test_table\" ADD COLUMN fake;", returnedSQL, "SQLBuilder.ColumnDefinition")
 }
 
 func TestQuoteIdentifier(t *testing.T) {
-	lSQLBuilder := internal.NewGenericSQLBuilder(nil, testutils.FakeQuoteIdentifierFunc, nil)
-	lColumn := schema.NewColumn(schema.NewColumnParams{Name: "column_name", Type: schema.Integer, Size: 0})
-	lTableName := "test_table"
-	lReturnedSQL := lSQLBuilder.AlterTableAddColumn(lTableName, lColumn)
-	testutils.AssertEqualWithLabel(t, "ALTER TABLE quoted_test_table ADD COLUMN quoted_column_name <<TYPE_0>>;", lReturnedSQL, "SQLBuilder.QuoteIdentifier")
+	sqlBuilder := internal.NewGenericSQLBuilder(nil, testutils.FakeQuoteIdentifierFunc, nil)
+	column := schema.NewColumn(schema.NewColumnParams{Name: "column_name", Type: schema.Integer, Size: 0})
+	table := "test_table"
+	returnedSQL := sqlBuilder.AlterTableAddColumn(table, column)
+	testutils.AssertEqualWithLabel(t, "ALTER TABLE quoted_test_table ADD COLUMN quoted_column_name <<TYPE_0>>;", returnedSQL, "SQLBuilder.QuoteIdentifier")
 }
diff --git a/internal/testutils/assert.go b/internal/testutils/assert.go
index c301e1c..f7f5566 100644
--- a/internal/testutils/assert.go
+++ b/internal/testutils/assert.go
@@ -6,84 +6,84 @@ import (
 	"testing"
 )
 
-func AssertErrorMessage(t *testing.T, pExpectedErrorMessage string, pError error, pFunctionName string) {
-	if pError == nil {
-		t.Errorf("%s should return not nil error", pFunctionName)
+func AssertErrorMessage(t *testing.T, expectedErrorMessage string, err error, functionName string) {
+	if err == nil {
+		t.Errorf("%s should return not nil error", functionName)
 		return
 	}
-	if pError.Error() != pExpectedErrorMessage {
+	if err.Error() != expectedErrorMessage {
 		t.Errorf(
 			"%s error message expected [%s], but returned [%s]",
-			pFunctionName,
-			pExpectedErrorMessage,
-			pError.Error(),
+			functionName,
+			expectedErrorMessage,
+			err.Error(),
 		)
 	}
 }
 
-func AssertNotNilResultAndNilError[R any](t *testing.T, pResult *R, pError error, pFunctionName string) bool {
-	lResult := true
-	if pResult == nil {
-		t.Errorf("%s cannot return nil Result", pFunctionName)
-		lResult = false
+func AssertNotNilResultAndNilError[R any](t *testing.T, result *R, err error, functionName string) bool {
+	res := true
+	if result == nil {
+		t.Errorf("%s cannot return nil Result", functionName)
+		res = false
 	}
-	if !AssertNilError(t, pError, pFunctionName) {
-		lResult = false
+	if !AssertNilError(t, err, functionName) {
+		res = false
 	}
-	return lResult
+	return res
 }
 
-func AssertNilResultAndNotNilError[R any](t *testing.T, pResult *R, pError error, pFunctionName string) bool {
-	lResult := true
-	if pResult != nil {
-		t.Errorf("%s should return nil Result", pFunctionName)
-		lResult = false
+func AssertNilResultAndNotNilError[R any](t *testing.T, result *R, err error, functionName string) bool {
+	res := true
+	if result != nil {
+		t.Errorf("%s should return nil Result", functionName)
+		res = false
 	}
-	if !AssertNotNilError(t, pError, pFunctionName) {
-		lResult = false
+	if !AssertNotNilError(t, err, functionName) {
+		res = false
 	}
-	return lResult
+	return res
 }
 
-func AssertNilError(t *testing.T, pError error, pFunctionName string) bool {
-	if pError == nil {
+func AssertNilError(t *testing.T, err error, functionName string) bool {
+	if err == nil {
 		return true
 	}
-	t.Errorf("%s return an error: %s", pFunctionName, pError.Error())
+	t.Errorf("%s cannot return error %q", functionName, err.Error())
 	return false
 }
 
-func AssertNotNilError(t *testing.T, pError error, pFunctionName string) bool {
-	if pError != nil {
+func AssertNotNilError(t *testing.T, err error, functionName string) bool {
+	if err != nil {
 		return true
 	}
-	t.Errorf("%s should return not nil error", pFunctionName)
+	t.Errorf("%s should return not nil error", functionName)
 	return false
 }
 
-func AssertEqualWithLabel[T comparable](t *testing.T, pExpected, pReturned T, pLabel string) bool {
-	if pExpected == pReturned {
+func AssertEqualWithLabel[T comparable](t *testing.T, expected, returned T, label string) bool {
+	if expected == returned {
 		return true
 	}
-	if pLabel != "" && !strings.HasSuffix(pLabel, ": ") {
-		pLabel += ": "
+	if label != "" && !strings.HasSuffix(label, ": ") {
+		label += ": "
 	}
-	t.Errorf("%sexpected [%v], but returned [%v]", pLabel, pExpected, pReturned)
+	t.Errorf("%sexpected [%v], but returned [%v]", label, expected, returned)
 	return false
 }
 
-func AssertNamedArgEqualWithLabel(t *testing.T, pExpected any, pReturned sql.NamedArg, pLabel string) bool {
-	if pExpected == pReturned {
+func AssertNamedArgEqualWithLabel(t *testing.T, expected any, returned sql.NamedArg, label string) bool {
+	if expected == returned {
 		return true
 	}
-	pExpectedNamedArg := pExpected.(sql.NamedArg)
-	if pExpectedNamedArg.Name == pReturned.Name && pExpectedNamedArg.Value == pReturned.Value {
+	expectedNamedArg := expected.(sql.NamedArg)
+	if expectedNamedArg.Name == returned.Name && expectedNamedArg.Value == returned.Value {
 		return true
 	}
 
-	if pLabel != "" && !strings.HasSuffix(pLabel, ": ") {
-		pLabel += ": "
+	if label != "" && !strings.HasSuffix(label, ": ") {
+		label += ": "
 	}
-	t.Errorf("%sexpected [%v], but returned [%v]", pLabel, pExpected, pReturned)
+	t.Errorf("%sexpected [%v], but returned [%v]", label, expected, returned)
 	return false
 }
diff --git a/internal/testutils/database.go b/internal/testutils/database.go
index 372041a..9a09026 100644
--- a/internal/testutils/database.go
+++ b/internal/testutils/database.go
@@ -27,8 +27,8 @@ func (d *FakeDriver) Name() string {
 func (d *FakeDriver) SQLBuilder() ormshift.SQLBuilder {
 	return d.underlyingDriver.SQLBuilder()
 }
-func (d *FakeDriver) DBSchema(pDB *sql.DB) (*schema.DBSchema, error) {
-	return d.underlyingDriver.DBSchema(pDB)
+func (d *FakeDriver) DBSchema(db *sql.DB) (*schema.DBSchema, error) {
+	return d.underlyingDriver.DBSchema(db)
 }
 
 // FakeDriverInvalidConnectionString always returns an empty connection string.
@@ -50,8 +50,8 @@ func (d *FakeDriverInvalidConnectionString) Name() string {
 func (d *FakeDriverInvalidConnectionString) SQLBuilder() ormshift.SQLBuilder {
 	return d.underlyingDriver.SQLBuilder()
 }
-func (d *FakeDriverInvalidConnectionString) DBSchema(pDB *sql.DB) (*schema.DBSchema, error) {
-	return d.underlyingDriver.DBSchema(pDB)
+func (d *FakeDriverInvalidConnectionString) DBSchema(db *sql.DB) (*schema.DBSchema, error) {
+	return d.underlyingDriver.DBSchema(db)
 }
 
 // FakeDriverBadSchema always returns an error when attempting to get the DB schema.
@@ -73,7 +73,7 @@ func (d *FakeDriverBadSchema) Name() string {
 func (d *FakeDriverBadSchema) SQLBuilder() ormshift.SQLBuilder {
 	return d.underlyingDriver.SQLBuilder()
 }
-func (d *FakeDriverBadSchema) DBSchema(pDB *sql.DB) (*schema.DBSchema, error) {
+func (d *FakeDriverBadSchema) DBSchema(db *sql.DB) (*schema.DBSchema, error) {
 	return nil, fmt.Errorf("intentionally bad schema")
 }
 
@@ -96,6 +96,6 @@ func (d *FakeDriverBadName) Name() string {
 func (d *FakeDriverBadName) SQLBuilder() ormshift.SQLBuilder {
 	return d.underlyingDriver.SQLBuilder()
 }
-func (d *FakeDriverBadName) DBSchema(pDB *sql.DB) (*schema.DBSchema, error) {
-	return d.underlyingDriver.DBSchema(pDB)
+func (d *FakeDriverBadName) DBSchema(db *sql.DB) (*schema.DBSchema, error) {
+	return d.underlyingDriver.DBSchema(db)
 }
diff --git a/internal/testutils/fake.go b/internal/testutils/fake.go
index 245bfc4..79e7694 100644
--- a/internal/testutils/fake.go
+++ b/internal/testutils/fake.go
@@ -8,8 +8,8 @@ import (
 )
 
 func FakeProductAttributeTable(t *testing.T) schema.Table {
-	lProductAttributeTable := schema.NewTable("product_attribute")
-	lError := lProductAttributeTable.AddColumns(
+	productAttributeTable := schema.NewTable("product_attribute")
+	err := productAttributeTable.AddColumns(
 		schema.NewColumnParams{
 			Name:       "product_id",
 			Type:       schema.Integer,
@@ -32,15 +32,15 @@ func FakeProductAttributeTable(t *testing.T) schema.Table {
 			Type: schema.Integer,
 		},
 	)
-	if !AssertNilError(t, lError, "ProductAttributeTable.AddColumns") {
-		panic(lError)
+	if !AssertNilError(t, err, "ProductAttributeTable.AddColumns") {
+		panic(err)
 	}
-	return lProductAttributeTable
+	return productAttributeTable
 }
 
 func FakeUserTable(t *testing.T) schema.Table {
-	lUserTable := schema.NewTable("user")
-	lError := lUserTable.AddColumns(
+	userTable := schema.NewTable("user")
+	err := userTable.AddColumns(
 		schema.NewColumnParams{
 			Name:          "id",
 			Type:          schema.Integer,
@@ -129,10 +129,10 @@ func FakeUserTable(t *testing.T) schema.Table {
 			AutoIncrement: false,
 		},
 	)
-	if !AssertNilError(t, lError, "UserTable.AddColumns") {
-		panic(lError)
+	if !AssertNilError(t, err, "UserTable.AddColumns") {
+		panic(err)
 	}
-	return lUserTable
+	return userTable
 }
 
 func FakeUserTableName(t *testing.T) string {
@@ -140,26 +140,26 @@ func FakeUserTableName(t *testing.T) string {
 }
 
 func FakeUpdatedAtColumn(t *testing.T) schema.Column {
-	lUpdatedAtColumn := schema.NewColumn(schema.NewColumnParams{
+	updatedAtColumn := schema.NewColumn(schema.NewColumnParams{
 		Name:          "updated_at",
 		Type:          schema.DateTime,
 		PrimaryKey:    false,
 		NotNull:       false,
 		AutoIncrement: false,
 	})
-	return lUpdatedAtColumn
+	return updatedAtColumn
 }
 
 func FakeUpdatedAtColumnName(t *testing.T) string {
 	return "updated_at"
 }
 
-func FakeInteroperateSQLCommandWithNamedArgsFunc(command string, namedArgs ...sql.NamedArg) (string, []any) {
-	lArgs := make([]any, len(namedArgs))
-	for i, v := range namedArgs {
-		lArgs[i] = v
+func FakeInteroperateSQLCommandWithNamedArgsFunc(command string, args ...sql.NamedArg) (string, []any) {
+	a := make([]any, len(args))
+	for i, v := range args {
+		a[i] = v
 	}
-	return "command has been modified", lArgs
+	return "command has been modified", a
 }
 
 func FakeColumnDefinitionFunc(column schema.Column) string {
diff --git a/internal/testutils/migrations.go b/internal/testutils/migrations.go
index 564283c..bc15bb9 100644
--- a/internal/testutils/migrations.go
+++ b/internal/testutils/migrations.go
@@ -10,13 +10,13 @@ import (
 // M001 Create_Table_User creates the "user" table.
 type M001_Create_Table_User struct{}
 
-func (m M001_Create_Table_User) Up(pMigrator *migrations.Migrator) error {
-	lUserTable := schema.NewTable("user")
-	if pMigrator.Database().DBSchema().HasTable(lUserTable.Name()) {
+func (m M001_Create_Table_User) Up(migrator *migrations.Migrator) error {
+	userTable := schema.NewTable("user")
+	if migrator.Database().DBSchema().HasTable(userTable.Name()) {
 		return nil
 	}
 
-	lError := lUserTable.AddColumns(
+	err := userTable.AddColumns(
 		schema.NewColumnParams{
 			Name:          "id",
 			Type:          schema.Integer,
@@ -63,76 +63,76 @@ func (m M001_Create_Table_User) Up(pMigrator *migrations.Migrator) error {
 			NotNull:    false,
 		},
 	)
-	if lError != nil {
-		return lError
+	if err != nil {
+		return err
 	}
 
-	_, lError = pMigrator.Database().SQLExecutor().Exec(pMigrator.Database().SQLBuilder().CreateTable(lUserTable))
-	return lError
+	_, err = migrator.Database().SQLExecutor().Exec(migrator.Database().SQLBuilder().CreateTable(userTable))
+	return err
 }
 
-func (m M001_Create_Table_User) Down(pMigrator *migrations.Migrator) error {
-	lUserTableName := "user"
-	if !pMigrator.Database().DBSchema().HasTable(lUserTableName) {
+func (m M001_Create_Table_User) Down(migrator *migrations.Migrator) error {
+	userTableName := "user"
+	if !migrator.Database().DBSchema().HasTable(userTableName) {
 		return nil
 	}
 
-	_, lError := pMigrator.Database().SQLExecutor().Exec(pMigrator.Database().SQLBuilder().DropTable(lUserTableName))
-	return lError
+	_, err := migrator.Database().SQLExecutor().Exec(migrator.Database().SQLBuilder().DropTable(userTableName))
+	return err
 }
 
 // M002_Alter_Table_User_Add_Column_UpdatedAt adds the "updated_at" column to the "user" table.
 type M002_Alter_Table_User_Add_Column_UpdatedAt struct{}
 
-func (m M002_Alter_Table_User_Add_Column_UpdatedAt) Up(pMigrator *migrations.Migrator) error {
-	lUserTableName := "user"
-	lUpdatedAtColumn := schema.NewColumn(schema.NewColumnParams{
+func (m M002_Alter_Table_User_Add_Column_UpdatedAt) Up(migrator *migrations.Migrator) error {
+	userTableName := "user"
+	updatedAtColumn := schema.NewColumn(schema.NewColumnParams{
 		Name: "updated_at",
 		Type: schema.DateTime,
 	})
-	if pMigrator.Database().DBSchema().HasColumn(lUserTableName, lUpdatedAtColumn.Name()) {
+	if migrator.Database().DBSchema().HasColumn(userTableName, updatedAtColumn.Name()) {
 		return nil
 	}
-	_, lError := pMigrator.Database().SQLExecutor().Exec(pMigrator.Database().SQLBuilder().AlterTableAddColumn(lUserTableName, lUpdatedAtColumn))
-	return lError
+	_, err := migrator.Database().SQLExecutor().Exec(migrator.Database().SQLBuilder().AlterTableAddColumn(userTableName, updatedAtColumn))
+	return err
 }
 
-func (m M002_Alter_Table_User_Add_Column_UpdatedAt) Down(pMigrator *migrations.Migrator) error {
-	lUserTableName := "user"
-	lUpdatedAtColumnName := "updated_at"
-	if !pMigrator.Database().DBSchema().HasColumn(lUserTableName, lUpdatedAtColumnName) {
+func (m M002_Alter_Table_User_Add_Column_UpdatedAt) Down(migrator *migrations.Migrator) error {
+	userTableName := "user"
+	updatedAtColumnName := "updated_at"
+	if !migrator.Database().DBSchema().HasColumn(userTableName, updatedAtColumnName) {
 		return nil
 	}
-	_, lError := pMigrator.Database().SQLExecutor().Exec(pMigrator.Database().SQLBuilder().AlterTableDropColumn(lUserTableName, lUpdatedAtColumnName))
-	return lError
+	_, err := migrator.Database().SQLExecutor().Exec(migrator.Database().SQLBuilder().AlterTableDropColumn(userTableName, updatedAtColumnName))
+	return err
 }
 
 // M003_Bad_Migration_Fails_To_Apply is a migration that always fails to apply.
 type M003_Bad_Migration_Fails_To_Apply struct{}
 
-func (m M003_Bad_Migration_Fails_To_Apply) Up(pMigrator *migrations.Migrator) error {
+func (m M003_Bad_Migration_Fails_To_Apply) Up(migrator *migrations.Migrator) error {
 	return fmt.Errorf("intentionally failed to Up")
 }
-func (m M003_Bad_Migration_Fails_To_Apply) Down(pMigrator *migrations.Migrator) error {
+func (m M003_Bad_Migration_Fails_To_Apply) Down(migrator *migrations.Migrator) error {
 	return nil
 }
 
 // M004_Bad_Migration_Fails_To_Revert is a migration that always fails to revert.
 type M004_Bad_Migration_Fails_To_Revert struct{}
 
-func (m M004_Bad_Migration_Fails_To_Revert) Up(pMigrator *migrations.Migrator) error {
+func (m M004_Bad_Migration_Fails_To_Revert) Up(migrator *migrations.Migrator) error {
 	return nil
 }
-func (m M004_Bad_Migration_Fails_To_Revert) Down(pMigrator *migrations.Migrator) error {
+func (m M004_Bad_Migration_Fails_To_Revert) Down(migrator *migrations.Migrator) error {
 	return fmt.Errorf("intentionally failed to Down")
 }
 
 // M005_Blank_Migration is a migration that does nothing, always succeeding regardless of direction and database state.
 type M005_Blank_Migration struct{}
 
-func (m M005_Blank_Migration) Up(pMigrator *migrations.Migrator) error {
+func (m M005_Blank_Migration) Up(migrator *migrations.Migrator) error {
 	return nil
 }
-func (m M005_Blank_Migration) Down(pMigrator *migrations.Migrator) error {
+func (m M005_Blank_Migration) Down(migrator *migrations.Migrator) error {
 	return nil
 }
diff --git a/migrations/config.go b/migrations/config.go
index 4adb1ef..d276a33 100644
--- a/migrations/config.go
+++ b/migrations/config.go
@@ -1,45 +1,45 @@
 package migrations
 
 type MigratorConfig struct {
-	tableName              string
-	migrationNameColumn    string
-	migrationNameMaxLength uint
-	appliedAtColumn        string
+	table        string
+	nameCol      string
+	nameMaxLen   uint
+	appliedAtCol string
 }
 
 func NewMigratorConfig() *MigratorConfig {
-	lConfig := MigratorConfig{
-		tableName:              "__ormshift_migrations",
-		migrationNameColumn:    "name",
-		migrationNameMaxLength: 250,
-		appliedAtColumn:        "applied_at",
+	config := MigratorConfig{
+		table:        "__ormshift_migrations",
+		nameCol:      "name",
+		nameMaxLen:   250,
+		appliedAtCol: "applied_at",
 	}
-	return &lConfig
+	return &config
 }
 
-func (mc *MigratorConfig) WithTableName(pTableName string) *MigratorConfig {
-	mc.tableName = pTableName
+func (mc *MigratorConfig) WithTableName(table string) *MigratorConfig {
+	mc.table = table
 	return mc
 }
-func (mc *MigratorConfig) WithColumnNames(pMigrationNameColumn, pAppliedAtColumn string) *MigratorConfig {
-	mc.migrationNameColumn = pMigrationNameColumn
-	mc.appliedAtColumn = pAppliedAtColumn
+func (mc *MigratorConfig) WithColumnNames(nameCol, appliedAtCol string) *MigratorConfig {
+	mc.nameCol = nameCol
+	mc.appliedAtCol = appliedAtCol
 	return mc
 }
-func (mc *MigratorConfig) WithMigrationNameMaxLength(pMaxLength uint) *MigratorConfig {
-	mc.migrationNameMaxLength = pMaxLength
+func (mc *MigratorConfig) WithMigrationNameMaxLength(maxLength uint) *MigratorConfig {
+	mc.nameMaxLen = maxLength
 	return mc
 }
 
 func (mc *MigratorConfig) TableName() string {
-	return mc.tableName
+	return mc.table
 }
 func (mc *MigratorConfig) MigrationNameColumn() string {
-	return mc.migrationNameColumn
+	return mc.nameCol
 }
 func (mc *MigratorConfig) MigrationNameMaxLength() uint {
-	return mc.migrationNameMaxLength
+	return mc.nameMaxLen
 }
 func (mc *MigratorConfig) AppliedAtColumn() string {
-	return mc.appliedAtColumn
+	return mc.appliedAtCol
 }
diff --git a/migrations/config_test.go b/migrations/config_test.go
index 156aeb2..8c8c073 100644
--- a/migrations/config_test.go
+++ b/migrations/config_test.go
@@ -8,22 +8,22 @@ import (
 )
 
 func TestNewMigratorConfigDefaults(t *testing.T) {
-	lConfig := migrations.NewMigratorConfig()
+	config := migrations.NewMigratorConfig()
 
-	testutils.AssertEqualWithLabel(t, "__ormshift_migrations", lConfig.TableName(), "MigratorConfig.TableName")
-	testutils.AssertEqualWithLabel(t, "name", lConfig.MigrationNameColumn(), "MigratorConfig.MigrationNameColumn")
-	testutils.AssertEqualWithLabel(t, "applied_at", lConfig.AppliedAtColumn(), "MigratorConfig.AppliedAtColumn")
-	testutils.AssertEqualWithLabel(t, uint(250), lConfig.MigrationNameMaxLength(), "MigratorConfig.MigrationNameMaxLength")
+	testutils.AssertEqualWithLabel(t, "__ormshift_migrations", config.TableName(), "MigratorConfig.TableName")
+	testutils.AssertEqualWithLabel(t, "name", config.MigrationNameColumn(), "MigratorConfig.MigrationNameColumn")
+	testutils.AssertEqualWithLabel(t, "applied_at", config.AppliedAtColumn(), "MigratorConfig.AppliedAtColumn")
+	testutils.AssertEqualWithLabel(t, uint(250), config.MigrationNameMaxLength(), "MigratorConfig.MigrationNameMaxLength")
 }
 
 func TestNewMigratorConfigCustom(t *testing.T) {
-	lConfig := migrations.NewMigratorConfig().
+	config := migrations.NewMigratorConfig().
 		WithTableName("custom_migrations").
 		WithColumnNames("migration_name", "applied_on").
 		WithMigrationNameMaxLength(500)
 
-	testutils.AssertEqualWithLabel(t, "custom_migrations", lConfig.TableName(), "MigratorConfig.TableName")
-	testutils.AssertEqualWithLabel(t, "migration_name", lConfig.MigrationNameColumn(), "MigratorConfig.MigrationNameColumn")
-	testutils.AssertEqualWithLabel(t, "applied_on", lConfig.AppliedAtColumn(), "MigratorConfig.AppliedAtColumn")
-	testutils.AssertEqualWithLabel(t, uint(500), lConfig.MigrationNameMaxLength(), "MigratorConfig.MigrationNameMaxLength")
+	testutils.AssertEqualWithLabel(t, "custom_migrations", config.TableName(), "MigratorConfig.TableName")
+	testutils.AssertEqualWithLabel(t, "migration_name", config.MigrationNameColumn(), "MigratorConfig.MigrationNameColumn")
+	testutils.AssertEqualWithLabel(t, "applied_on", config.AppliedAtColumn(), "MigratorConfig.AppliedAtColumn")
+	testutils.AssertEqualWithLabel(t, uint(500), config.MigrationNameMaxLength(), "MigratorConfig.MigrationNameMaxLength")
 }
diff --git a/migrations/migrations.go b/migrations/migrations.go
index d14fcd0..a5f2bfe 100644
--- a/migrations/migrations.go
+++ b/migrations/migrations.go
@@ -3,21 +3,21 @@ package migrations
 import "github.com/ordershift/ormshift"
 
 type Migration interface {
-	Up(pMigrator *Migrator) error
-	Down(pMigrator *Migrator) error
+	Up(migrator *Migrator) error
+	Down(migrator *Migrator) error
 }
 
-func Migrate(pDatabase *ormshift.Database, pConfig *MigratorConfig, pMigrations ...Migration) (*Migrator, error) {
-	lMigrator, lError := NewMigrator(pDatabase, pConfig)
-	if lError != nil {
-		return nil, lError
+func Migrate(database *ormshift.Database, config *MigratorConfig, migrations ...Migration) (*Migrator, error) {
+	migrator, err := NewMigrator(database, config)
+	if err != nil {
+		return nil, err
 	}
-	for _, lMigration := range pMigrations {
-		lMigrator.Add(lMigration)
+	for _, migration := range migrations {
+		migrator.Add(migration)
 	}
-	lError = lMigrator.ApplyAllMigrations()
-	if lError != nil {
-		return nil, lError
+	err = migrator.ApplyAllMigrations()
+	if err != nil {
+		return nil, err
 	}
-	return lMigrator, nil
+	return migrator, nil
 }
diff --git a/migrations/migrations_test.go b/migrations/migrations_test.go
index 0b7ef0d..d85b54d 100644
--- a/migrations/migrations_test.go
+++ b/migrations/migrations_test.go
@@ -10,93 +10,93 @@ import (
 )
 
 func TestMigrate(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNilError(t, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNilError(t, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lMigrator, lError := migrations.Migrate(
-		lDB,
+	migrator, err := migrations.Migrate(
+		db,
 		migrations.NewMigratorConfig(),
 		testutils.M001_Create_Table_User{},
 		testutils.M002_Alter_Table_User_Add_Column_UpdatedAt{},
 	)
-	if !testutils.AssertNotNilResultAndNilError(t, lMigrator, lError, "migrations.Migrate") {
+	if !testutils.AssertNotNilResultAndNilError(t, migrator, err, "migrations.Migrate") {
 		return
 	}
-	lUserTableName := "user"
-	lUpdatedAtColumnName := "updated_at"
-	testutils.AssertEqualWithLabel(t, true, lDB.DBSchema().HasColumn(lUserTableName, lUpdatedAtColumnName), "Migrator.DBSchema.HasColumn[user.updated_at]")
-	testutils.AssertEqualWithLabel(t, 2, len(lMigrator.AppliedMigrations()), "len(Migrator.AppliedMigrations)")
+	userTableName := "user"
+	updatedAtColumnName := "updated_at"
+	testutils.AssertEqualWithLabel(t, true, db.DBSchema().HasColumn(userTableName, updatedAtColumnName), "Migrator.DBSchema.HasColumn[user.updated_at]")
+	testutils.AssertEqualWithLabel(t, 2, len(migrator.AppliedMigrations()), "len(Migrator.AppliedMigrations)")
 }
 
 func TestMigrateTwice(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNilError(t, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNilError(t, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lMigrator, lError := migrations.Migrate(
-		lDB,
+	migrator, err := migrations.Migrate(
+		db,
 		migrations.NewMigratorConfig(),
 		testutils.M001_Create_Table_User{},
 		testutils.M002_Alter_Table_User_Add_Column_UpdatedAt{},
 	)
-	if !testutils.AssertNotNilResultAndNilError(t, lMigrator, lError, "migrations.Migrate") {
+	if !testutils.AssertNotNilResultAndNilError(t, migrator, err, "migrations.Migrate") {
 		return
 	}
 
-	lMigrator, lError = migrations.Migrate(
-		lDB,
+	migrator, err = migrations.Migrate(
+		db,
 		migrations.NewMigratorConfig(),
 		testutils.M001_Create_Table_User{},
 		testutils.M002_Alter_Table_User_Add_Column_UpdatedAt{},
 	)
-	if !testutils.AssertNotNilResultAndNilError(t, lMigrator, lError, "migrations.Migrate") {
+	if !testutils.AssertNotNilResultAndNilError(t, migrator, err, "migrations.Migrate") {
 		return
 	}
 
-	lUserTableName := "user"
-	lUpdatedAtColumnName := "updated_at"
-	testutils.AssertEqualWithLabel(t, true, lDB.DBSchema().HasColumn(lUserTableName, lUpdatedAtColumnName), "Migrator.DBSchema.HasColumn[user.updated_at]")
-	testutils.AssertEqualWithLabel(t, 2, len(lMigrator.AppliedMigrations()), "len(Migrator.AppliedMigrations)")
+	userTableName := "user"
+	updatedAtColumnName := "updated_at"
+	testutils.AssertEqualWithLabel(t, true, db.DBSchema().HasColumn(userTableName, updatedAtColumnName), "Migrator.DBSchema.HasColumn[user.updated_at]")
+	testutils.AssertEqualWithLabel(t, 2, len(migrator.AppliedMigrations()), "len(Migrator.AppliedMigrations)")
 }
 
 func TestMigrateFailsWhenDatabaseIsClosed(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNilError(t, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNilError(t, err, "ormshift.OpenDatabase") {
 		return
 	}
-	_ = lDB.Close()
+	_ = db.Close()
 
-	lMigrator, lError := migrations.Migrate(
-		lDB,
+	migrator, err := migrations.Migrate(
+		db,
 		migrations.NewMigratorConfig(),
 		testutils.M001_Create_Table_User{},
 		testutils.M002_Alter_Table_User_Add_Column_UpdatedAt{},
 	)
-	if !testutils.AssertNilResultAndNotNilError(t, lMigrator, lError, "migrations.Migrate") {
+	if !testutils.AssertNilResultAndNotNilError(t, migrator, err, "migrations.Migrate") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "failed to get applied migration names: sql: database is closed", lError, "migrations.Migrate")
+	testutils.AssertErrorMessage(t, "failed to get applied migration names: sql: database is closed", err, "migrations.Migrate")
 }
 
 func TestMigrateFailsWhenMigrationUpFails(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNilError(t, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNilError(t, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lMigrator, lError := migrations.Migrate(
-		lDB,
+	migrator, err := migrations.Migrate(
+		db,
 		migrations.NewMigratorConfig(),
 		testutils.M003_Bad_Migration_Fails_To_Apply{},
 	)
-	if !testutils.AssertNilResultAndNotNilError(t, lMigrator, lError, "migrations.Migrate") {
+	if !testutils.AssertNilResultAndNotNilError(t, migrator, err, "migrations.Migrate") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "failed to apply migration \"M003_Bad_Migration_Fails_To_Apply\": intentionally failed to Up", lError, "migrations.Migrate")
+	testutils.AssertErrorMessage(t, "failed to apply migration \"M003_Bad_Migration_Fails_To_Apply\": intentionally failed to Up", err, "migrations.Migrate")
 }
diff --git a/migrations/migrator.go b/migrations/migrator.go
index 7a83934..85f7c37 100644
--- a/migrations/migrator.go
+++ b/migrations/migrator.go
@@ -16,48 +16,48 @@ type Migrator struct {
 	appliedMigrations map[string]bool
 }
 
-func NewMigrator(pDatabase *ormshift.Database, pConfig *MigratorConfig) (*Migrator, error) {
-	if pDatabase == nil {
+func NewMigrator(database *ormshift.Database, config *MigratorConfig) (*Migrator, error) {
+	if database == nil {
 		return nil, fmt.Errorf("database cannot be nil")
 	}
-	if pConfig == nil {
+	if config == nil {
 		return nil, fmt.Errorf("migrator config cannot be nil")
 	}
 
-	lAppliedMigrationNames, lError := getAppliedMigrationNames(pDatabase, pConfig)
-	if lError != nil {
-		return nil, fmt.Errorf("failed to get applied migration names: %w", lError)
+	appliedMigrationNames, err := getAppliedMigrationNames(database, config)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get applied migration names: %w", err)
 	}
-	lAppliedMigrations := make(map[string]bool, len(lAppliedMigrationNames))
-	for _, name := range lAppliedMigrationNames {
-		lAppliedMigrations[name] = true
+	appliedMigrations := make(map[string]bool, len(appliedMigrationNames))
+	for _, name := range appliedMigrationNames {
+		appliedMigrations[name] = true
 	}
 
 	return &Migrator{
-		database:          pDatabase,
-		config:            pConfig,
+		database:          database,
+		config:            config,
 		migrations:        []Migration{},
-		appliedMigrations: lAppliedMigrations,
+		appliedMigrations: appliedMigrations,
 	}, nil
 }
 
-func (m *Migrator) Add(pMigration Migration) {
-	m.migrations = append(m.migrations, pMigration)
+func (m *Migrator) Add(migration Migration) {
+	m.migrations = append(m.migrations, migration)
 }
 
 func (m *Migrator) ApplyAllMigrations() error {
-	for _, lMigration := range m.migrations {
-		lMigrationName := reflect.TypeOf(lMigration).Name()
-		if !m.isApplied(lMigrationName) {
-			lError := lMigration.Up(m)
-			if lError != nil {
-				return fmt.Errorf("failed to apply migration %q: %w", lMigrationName, lError)
+	for _, migration := range m.migrations {
+		migrationName := reflect.TypeOf(migration).Name()
+		if !m.isApplied(migrationName) {
+			err := migration.Up(m)
+			if err != nil {
+				return fmt.Errorf("failed to apply migration %q: %w", migrationName, err)
 			}
-			lError = m.recordAppliedMigration(lMigrationName)
-			if lError != nil {
-				return fmt.Errorf("failed to record applied migration %q: %w", lMigrationName, lError)
+			err = m.recordAppliedMigration(migrationName)
+			if err != nil {
+				return fmt.Errorf("failed to record applied migration %q: %w", migrationName, err)
 			}
-			m.appliedMigrations[lMigrationName] = true
+			m.appliedMigrations[migrationName] = true
 		}
 	}
 	return nil
@@ -65,18 +65,18 @@ func (m *Migrator) ApplyAllMigrations() error {
 
 func (m *Migrator) RevertLastAppliedMigration() error {
 	for i := len(m.migrations) - 1; i >= 0; i-- {
-		lMigration := m.migrations[i]
-		lMigrationName := reflect.TypeOf(lMigration).Name()
-		if m.isApplied(lMigrationName) {
-			lError := lMigration.Down(m)
-			if lError != nil {
-				return fmt.Errorf("failed to revert migration %q: %w", lMigrationName, lError)
+		migration := m.migrations[i]
+		migrationName := reflect.TypeOf(migration).Name()
+		if m.isApplied(migrationName) {
+			err := migration.Down(m)
+			if err != nil {
+				return fmt.Errorf("failed to revert migration %q: %w", migrationName, err)
 			}
-			lError = m.deleteAppliedMigration(lMigrationName)
-			if lError != nil {
-				return fmt.Errorf("failed to delete applied migration %q: %w", lMigrationName, lError)
+			err = m.deleteAppliedMigration(migrationName)
+			if err != nil {
+				return fmt.Errorf("failed to delete applied migration %q: %w", migrationName, err)
 			}
-			delete(m.appliedMigrations, lMigrationName)
+			delete(m.appliedMigrations, migrationName)
 			return nil
 		}
 	}
@@ -92,101 +92,101 @@ func (m *Migrator) Migrations() []Migration {
 }
 
 func (m *Migrator) AppliedMigrations() []Migration {
-	lMigrations := []Migration{}
+	migrations := []Migration{}
 	for _, migration := range m.Migrations() {
 		name := reflect.TypeOf(migration).Name()
 		if m.appliedMigrations[name] {
-			lMigrations = append(lMigrations, migration)
+			migrations = append(migrations, migration)
 		}
 	}
-	return lMigrations
+	return migrations
 }
 
-func (m *Migrator) isApplied(pMigrationName string) bool {
-	_, exists := m.appliedMigrations[pMigrationName]
+func (m *Migrator) isApplied(migrationName string) bool {
+	_, exists := m.appliedMigrations[migrationName]
 	return exists
 }
 
-func (m *Migrator) recordAppliedMigration(pMigrationName string) error {
+func (m *Migrator) recordAppliedMigration(migrationName string) error {
 	q, p := m.database.SQLBuilder().InsertWithValues(
-		m.config.tableName,
+		m.config.table,
 		ormshift.ColumnsValues{
-			m.config.migrationNameColumn: pMigrationName,
-			m.config.appliedAtColumn:     time.Now().UTC(),
+			m.config.nameCol:      migrationName,
+			m.config.appliedAtCol: time.Now().UTC(),
 		},
 	)
-	_, lError := m.database.SQLExecutor().Exec(q, p...)
-	return lError
+	_, err := m.database.SQLExecutor().Exec(q, p...)
+	return err
 }
 
-func (m *Migrator) deleteAppliedMigration(pMigrationName string) error {
+func (m *Migrator) deleteAppliedMigration(migrationName string) error {
 	q, p := m.database.SQLBuilder().DeleteWithValues(
-		m.config.tableName,
+		m.config.table,
 		ormshift.ColumnsValues{
-			m.config.migrationNameColumn: pMigrationName,
+			m.config.nameCol: migrationName,
 		},
 	)
-	_, lError := m.database.SQLExecutor().Exec(q, p...)
-	return lError
+	_, err := m.database.SQLExecutor().Exec(q, p...)
+	return err
 }
 
-func getAppliedMigrationNames(pDatabase *ormshift.Database, pConfig *MigratorConfig) (rMigrationNames []string, rError error) {
-	rError = ensureMigrationsTableExists(pDatabase, pConfig)
-	if rError != nil {
+func getAppliedMigrationNames(database *ormshift.Database, config *MigratorConfig) (migrationNames []string, err error) {
+	err = ensureMigrationsTableExists(database, config)
+	if err != nil {
 		return
 	}
 
-	q, p := pDatabase.SQLBuilder().InteroperateSQLCommandWithNamedArgs(
+	q, p := database.SQLBuilder().InteroperateSQLCommandWithNamedArgs(
 		fmt.Sprintf(
 			"select %s from %s order by %s",
-			pDatabase.SQLBuilder().QuoteIdentifier(pConfig.migrationNameColumn),
-			pDatabase.SQLBuilder().QuoteIdentifier(pConfig.tableName),
-			pDatabase.SQLBuilder().QuoteIdentifier(pConfig.migrationNameColumn),
+			database.SQLBuilder().QuoteIdentifier(config.nameCol),
+			database.SQLBuilder().QuoteIdentifier(config.table),
+			database.SQLBuilder().QuoteIdentifier(config.nameCol),
 		),
 	)
-	lMigrationsRows, rError := pDatabase.SQLExecutor().Query(q, p...)
-	if rError != nil {
+	migrationsRows, err := database.SQLExecutor().Query(q, p...)
+	if err != nil {
 		return
 	}
 	defer func() {
-		if err := lMigrationsRows.Close(); err != nil && rError == nil {
-			rError = err
+		if closeErr := migrationsRows.Close(); closeErr != nil && err == nil {
+			err = closeErr
 		}
 	}()
-	for lMigrationsRows.Next() {
-		var lMigrationName string
-		rError = lMigrationsRows.Scan(&lMigrationName)
-		if rError != nil {
+	for migrationsRows.Next() {
+		var migrationName string
+		err = migrationsRows.Scan(&migrationName)
+		if err != nil {
 			break
 		}
-		rMigrationNames = append(rMigrationNames, lMigrationName)
+		migrationNames = append(migrationNames, migrationName)
 	}
 	return
 }
 
-func ensureMigrationsTableExists(pDatabase *ormshift.Database, pConfig *MigratorConfig) error {
-	lMigrationsTable := schema.NewTable(pConfig.TableName())
-	if pDatabase.DBSchema().HasTable(lMigrationsTable.Name()) {
+func ensureMigrationsTableExists(database *ormshift.Database, config *MigratorConfig) error {
+	migrationsTable := schema.NewTable(config.TableName())
+	if database.DBSchema().HasTable(migrationsTable.Name()) {
 		return nil
 	}
-	lError := lMigrationsTable.AddColumns(
+	err := migrationsTable.AddColumns(
 		schema.NewColumnParams{
-			Name:       pConfig.MigrationNameColumn(),
+			Name:       config.MigrationNameColumn(),
 			Type:       schema.Varchar,
-			Size:       pConfig.MigrationNameMaxLength(),
+			Size:       config.MigrationNameMaxLength(),
 			PrimaryKey: true,
 			NotNull:    true,
 		},
 		schema.NewColumnParams{
-			Name:    pConfig.AppliedAtColumn(),
+			Name:    config.AppliedAtColumn(),
 			Type:    schema.DateTime,
 			NotNull: true,
 		},
 	)
-	if lError != nil {
-		return lError
+	if err != nil {
+		return err
 	}
 
-	_, lError = pDatabase.SQLExecutor().Exec(pDatabase.SQLBuilder().CreateTable(lMigrationsTable))
-	return lError
+	_, err = database.SQLExecutor().Exec(database.SQLBuilder().CreateTable(migrationsTable))
+	return err
 }
diff --git a/migrations/migrator_test.go b/migrations/migrator_test.go
index 598b033..f72d2d9 100644
--- a/migrations/migrator_test.go
+++ b/migrations/migrator_test.go
@@ -11,149 +11,149 @@ import (
 )
 
 func TestNewMigratorWhenDatabaseIsNil(t *testing.T) {
-	lMigrator, lError := migrations.NewMigrator(nil, migrations.NewMigratorConfig())
-	testutils.AssertNilResultAndNotNilError(t, lMigrator, lError, "migrations.NewMigrator[database=nil]")
-	testutils.AssertErrorMessage(t, "database cannot be nil", lError, "migrations.NewMigrator[database=nil]")
+	migrator, err := migrations.NewMigrator(nil, migrations.NewMigratorConfig())
+	testutils.AssertNilResultAndNotNilError(t, migrator, err, "migrations.NewMigrator[database=nil]")
+	testutils.AssertErrorMessage(t, "database cannot be nil", err, "migrations.NewMigrator[database=nil]")
 }
 
 func TestNewMigratorWhenConfigIsNil(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lMigrator, lError := migrations.NewMigrator(lDB, nil)
-	testutils.AssertNilResultAndNotNilError(t, lMigrator, lError, "migrations.NewMigrator[config=nil]")
-	testutils.AssertErrorMessage(t, "migrator config cannot be nil", lError, "migrations.NewMigrator[config=nil]")
+	migrator, err := migrations.NewMigrator(db, nil)
+	testutils.AssertNilResultAndNotNilError(t, migrator, err, "migrations.NewMigrator[config=nil]")
+	testutils.AssertErrorMessage(t, "migrator config cannot be nil", err, "migrations.NewMigrator[config=nil]")
 }
 
 func TestNewMigratorWhenDatabaseIsInvalid(t *testing.T) {
-	lDriver := testutils.NewFakeDriverInvalidConnectionString(postgresql.Driver())
-	lDB, lError := ormshift.OpenDatabase(lDriver, ormshift.ConnectionParams{})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	driver := testutils.NewFakeDriverInvalidConnectionString(postgresql.Driver())
+	db, err := ormshift.OpenDatabase(driver, ormshift.ConnectionParams{})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lMigrator, lError := migrations.NewMigrator(lDB, migrations.NewMigratorConfig())
-	testutils.AssertNilResultAndNotNilError(t, lMigrator, lError, "migrations.NewMigrator[database=invalid]")
-	testutils.AssertErrorMessage(t, "failed to get applied migration names: missing \"=\" after \"invalid-connection-string\" in connection info string\"", lError, "migrations.NewMigrator[database=invalid]")
+	migrator, err := migrations.NewMigrator(db, migrations.NewMigratorConfig())
+	testutils.AssertNilResultAndNotNilError(t, migrator, err, "migrations.NewMigrator[database=invalid]")
+	testutils.AssertErrorMessage(t, "failed to get applied migration names: missing \"=\" after \"invalid-connection-string\" in connection info string\"", err, "migrations.NewMigrator[database=invalid]")
 }
 
 func TestApplyAllMigrationsFailsWhenRecordingFails(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lMigrator, lError := migrations.NewMigrator(lDB, migrations.NewMigratorConfig())
-	if !testutils.AssertNotNilResultAndNilError(t, lMigrator, lError, "migrations.NewMigrator") {
+	migrator, err := migrations.NewMigrator(db, migrations.NewMigratorConfig())
+	if !testutils.AssertNotNilResultAndNilError(t, migrator, err, "migrations.NewMigrator") {
 		return
 	}
-	lMigrator.Add(testutils.M005_Blank_Migration{})
+	migrator.Add(testutils.M005_Blank_Migration{})
 
-	_ = lDB.Close()
+	_ = db.Close()
 
-	lError = lMigrator.ApplyAllMigrations()
-	if !testutils.AssertNotNilError(t, lError, "Migrator.ApplyAllMigrations") {
+	err = migrator.ApplyAllMigrations()
+	if !testutils.AssertNotNilError(t, err, "Migrator.ApplyAllMigrations") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "failed to record applied migration \"M005_Blank_Migration\": sql: database is closed", lError, "Migrator.ApplyAllMigrations")
+	testutils.AssertErrorMessage(t, "failed to record applied migration \"M005_Blank_Migration\": sql: database is closed", err, "Migrator.ApplyAllMigrations")
 }
 
 func TestRevertLastAppliedMigration(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lMigrator, lError := migrations.Migrate(
-		lDB,
+	migrator, err := migrations.Migrate(
+		db,
 		migrations.NewMigratorConfig(),
 		testutils.M001_Create_Table_User{},
 		testutils.M002_Alter_Table_User_Add_Column_UpdatedAt{},
 	)
-	if !testutils.AssertNotNilResultAndNilError(t, lMigrator, lError, "migrations.NewMigrator") {
+	if !testutils.AssertNotNilResultAndNilError(t, migrator, err, "migrations.NewMigrator") {
 		return
 	}
 
-	lUserTableName := "user"
-	testutils.AssertEqualWithLabel(t, true, lDB.DBSchema().HasTable(lUserTableName), "Migrator.DBSchema.HasTable[user]")
+	userTableName := "user"
+	testutils.AssertEqualWithLabel(t, true, db.DBSchema().HasTable(userTableName), "Migrator.DBSchema.HasTable[user]")
 
-	lError = lMigrator.RevertLastAppliedMigration()
-	if !testutils.AssertNilError(t, lError, "Migrator.RevertLastAppliedMigration") {
+	err = migrator.RevertLastAppliedMigration()
+	if !testutils.AssertNilError(t, err, "Migrator.RevertLastAppliedMigration") {
 		return
 	}
 
-	lUpdatedAtColumnName := "updated_at"
-	testutils.AssertEqualWithLabel(t, false, lDB.DBSchema().HasColumn(lUserTableName, lUpdatedAtColumnName), "Migrator.DBSchema.HasColumn[user.updated_at]")
+	updatedAtColumnName := "updated_at"
+	testutils.AssertEqualWithLabel(t, false, db.DBSchema().HasColumn(userTableName, updatedAtColumnName), "Migrator.DBSchema.HasColumn[user.updated_at]")
 }
 
 func TestRevertLastAppliedMigrationWhenNoMigrationsApplied(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lMigrator, lError := migrations.NewMigrator(lDB, migrations.NewMigratorConfig())
-	if !testutils.AssertNotNilResultAndNilError(t, lMigrator, lError, "migrations.NewMigrator") {
+	migrator, err := migrations.NewMigrator(db, migrations.NewMigratorConfig())
+	if !testutils.AssertNotNilResultAndNilError(t, migrator, err, "migrations.NewMigrator") {
 		return
 	}
-	lError = lMigrator.RevertLastAppliedMigration()
-	if !testutils.AssertNilError(t, lError, "Migrator.RevertLastAppliedMigration") {
+	err = migrator.RevertLastAppliedMigration()
+	if !testutils.AssertNilError(t, err, "Migrator.RevertLastAppliedMigration") {
 		return
 	}
 }
 
 func TestRevertLastAppliedMigrationFailsWhenDownFails(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lMigrator, lError := migrations.Migrate(
-		lDB,
+	migrator, err := migrations.Migrate(
+		db,
 		migrations.NewMigratorConfig(),
 		testutils.M004_Bad_Migration_Fails_To_Revert{},
 	)
-	if !testutils.AssertNotNilResultAndNilError(t, lMigrator, lError, "migrations.Migrate") {
+	if !testutils.AssertNotNilResultAndNilError(t, migrator, err, "migrations.Migrate") {
 		return
 	}
 
-	lError = lMigrator.RevertLastAppliedMigration()
-	if !testutils.AssertNotNilError(t, lError, "Migrator.RevertLastAppliedMigration") {
+	err = migrator.RevertLastAppliedMigration()
+	if !testutils.AssertNotNilError(t, err, "Migrator.RevertLastAppliedMigration") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "failed to revert migration \"M004_Bad_Migration_Fails_To_Revert\": intentionally failed to Down", lError, "Migrator.RevertLastAppliedMigration")
+	testutils.AssertErrorMessage(t, "failed to revert migration \"M004_Bad_Migration_Fails_To_Revert\": intentionally failed to Down", err, "Migrator.RevertLastAppliedMigration")
 }
 
 func TestRevertLastAppliedMigrationFailsWhenDeletingFails(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lMigrator, lError := migrations.NewMigrator(lDB, migrations.NewMigratorConfig())
-	if !testutils.AssertNotNilResultAndNilError(t, lMigrator, lError, "migrations.NewMigrator") {
+	migrator, err := migrations.NewMigrator(db, migrations.NewMigratorConfig())
+	if !testutils.AssertNotNilResultAndNilError(t, migrator, err, "migrations.NewMigrator") {
 		return
 	}
-	lMigrator.Add(testutils.M005_Blank_Migration{})
-	lError = lMigrator.ApplyAllMigrations()
-	if !testutils.AssertNilError(t, lError, "Migrator.ApplyAllMigrations") {
+	migrator.Add(testutils.M005_Blank_Migration{})
+	err = migrator.ApplyAllMigrations()
+	if !testutils.AssertNilError(t, err, "Migrator.ApplyAllMigrations") {
 		return
 	}
 
-	_ = lDB.Close()
+	_ = db.Close()
 
-	lError = lMigrator.RevertLastAppliedMigration()
-	if !testutils.AssertNotNilError(t, lError, "Migrator.RevertLastAppliedMigration") {
+	err = migrator.RevertLastAppliedMigration()
+	if !testutils.AssertNotNilError(t, err, "Migrator.RevertLastAppliedMigration") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "failed to delete applied migration \"M005_Blank_Migration\": sql: database is closed", lError, "Migrator.RevertLastAppliedMigration")
+	testutils.AssertErrorMessage(t, "failed to delete applied migration \"M005_Blank_Migration\": sql: database is closed", err, "Migrator.RevertLastAppliedMigration")
 }
diff --git a/schema/column.go b/schema/column.go
index 7eed88e..f081065 100644
--- a/schema/column.go
+++ b/schema/column.go
@@ -30,14 +30,14 @@ type Column struct {
 	autoIncrement bool
 }
 
-func NewColumn(pParams NewColumnParams) Column {
+func NewColumn(params NewColumnParams) Column {
 	return Column{
-		name:          pParams.Name,
-		columnType:    pParams.Type,
-		size:          pParams.Size,
-		primaryKey:    pParams.PrimaryKey,
-		notNull:       pParams.NotNull,
-		autoIncrement: pParams.AutoIncrement,
+		name:          params.Name,
+		columnType:    params.Type,
+		size:          params.Size,
+		primaryKey:    params.PrimaryKey,
+		notNull:       params.NotNull,
+		autoIncrement: params.AutoIncrement,
 	}
 }
 
diff --git a/schema/column_test.go b/schema/column_test.go
index 0a634a0..e3da5e2 100644
--- a/schema/column_test.go
+++ b/schema/column_test.go
@@ -8,12 +8,12 @@ import (
 )
 
 func TestColumn(t *testing.T) {
-	lColumn := schema.NewColumn(schema.NewColumnParams{Name: "id", Type: schema.Integer, NotNull: true, PrimaryKey: true, AutoIncrement: true})
+	column := schema.NewColumn(schema.NewColumnParams{Name: "id", Type: schema.Integer, NotNull: true, PrimaryKey: true, AutoIncrement: true})
 
-	testutils.AssertEqualWithLabel(t, "id", lColumn.Name(), "Column.Name")
-	testutils.AssertEqualWithLabel(t, schema.Integer, lColumn.Type(), "Column.Type")
-	testutils.AssertEqualWithLabel(t, uint(0), lColumn.Size(), "Column.Size")
-	testutils.AssertEqualWithLabel(t, true, lColumn.PrimaryKey(), "Column.IsPrimaryKey")
-	testutils.AssertEqualWithLabel(t, true, lColumn.NotNull(), "Column.IsNotNull")
-	testutils.AssertEqualWithLabel(t, true, lColumn.AutoIncrement(), "Column.IsAutoIncrement")
+	testutils.AssertEqualWithLabel(t, "id", column.Name(), "Column.Name")
+	testutils.AssertEqualWithLabel(t, schema.Integer, column.Type(), "Column.Type")
+	testutils.AssertEqualWithLabel(t, uint(0), column.Size(), "Column.Size")
+	testutils.AssertEqualWithLabel(t, true, column.PrimaryKey(), "Column.IsPrimaryKey")
+	testutils.AssertEqualWithLabel(t, true, column.NotNull(), "Column.IsNotNull")
+	testutils.AssertEqualWithLabel(t, true, column.AutoIncrement(), "Column.IsAutoIncrement")
 }
diff --git a/schema/schema.go b/schema/schema.go
index 4c48360..d9c9790 100644
--- a/schema/schema.go
+++ b/schema/schema.go
@@ -13,74 +13,74 @@ type DBSchema struct {
 	columnTypesQueryFunc ColumnTypesQueryFunc
 }
 
-type ColumnTypesQueryFunc func(pTableName string) string
+type ColumnTypesQueryFunc func(table string) string
 
 func NewDBSchema(
-	pDB *sql.DB,
-	pTableNamesQuery string,
-	pColumnTypesQueryFunc ColumnTypesQueryFunc,
+	db *sql.DB,
+	tableNamesQuery string,
+	columnTypesQueryFunc ColumnTypesQueryFunc,
 ) (*DBSchema, error) {
-	if pDB == nil {
+	if db == nil {
 		return nil, errors.New("sql.DB cannot be nil")
 	}
 	return &DBSchema{
-		db:                   pDB,
-		tableNamesQuery:      pTableNamesQuery,
-		columnTypesQueryFunc: pColumnTypesQueryFunc,
+		db:                   db,
+		tableNamesQuery:      tableNamesQuery,
+		columnTypesQueryFunc: columnTypesQueryFunc,
 	}, nil
 }
 
-func (s *DBSchema) HasTable(pTableName string) bool {
-	lTables, lError := s.fetchTableNames()
-	if lError != nil {
+func (s *DBSchema) HasTable(table string) bool {
+	tables, err := s.fetchTableNames()
+	if err != nil {
 		return false
 	}
-	return slices.ContainsFunc(lTables, func(t string) bool {
-		return strings.EqualFold(t, pTableName)
+	return slices.ContainsFunc(tables, func(t string) bool {
+		return strings.EqualFold(t, table)
 	})
 }
 
-func (s *DBSchema) fetchTableNames() (rTableNames []string, rError error) {
-	lRows, rError := s.db.Query(s.tableNamesQuery)
-	if rError != nil {
+func (s *DBSchema) fetchTableNames() (tableNames []string, err error) {
+	rows, err := s.db.Query(s.tableNamesQuery)
+	if err != nil {
 		return
 	}
 	defer func() {
-		if err := lRows.Close(); err != nil && rError == nil {
-			rError = err
+		if closeErr := rows.Close(); closeErr != nil && err == nil {
+			err = closeErr
 		}
 	}()
-	lTableName := ""
-	for lRows.Next() {
-		rError = lRows.Scan(&lTableName)
-		if rError != nil {
+	table := ""
+	for rows.Next() {
+		err = rows.Scan(&table)
+		if err != nil {
 			return
 		}
-		rTableNames = append(rTableNames, lTableName)
+		tableNames = append(tableNames, table)
 	}
 	return
 }
 
-func (s *DBSchema) HasColumn(pTableName, pColumnName string) bool {
-	lColumnTypes, lError := s.fetchColumnTypes(pTableName)
-	if lError != nil {
+func (s *DBSchema) HasColumn(table, column string) bool {
+	columnTypes, err := s.fetchColumnTypes(table)
+	if err != nil {
 		return false
 	}
-	return slices.ContainsFunc(lColumnTypes, func(ct *sql.ColumnType) bool {
-		return strings.EqualFold(ct.Name(), pColumnName)
+	return slices.ContainsFunc(columnTypes, func(ct *sql.ColumnType) bool {
+		return strings.EqualFold(ct.Name(), column)
 	})
 }
 
-func (s *DBSchema) fetchColumnTypes(pTableName string) (rColumnTypes []*sql.ColumnType, rError error) {
-	lRows, rError := s.db.Query(s.columnTypesQueryFunc(pTableName))
-	if rError != nil {
+func (s *DBSchema) fetchColumnTypes(table string) (columnTypes []*sql.ColumnType, err error) {
+	rows, err := s.db.Query(s.columnTypesQueryFunc(table))
+	if err != nil {
 		return
 	}
 	defer func() {
-		if err := lRows.Close(); err != nil && rError == nil {
-			rError = err
+		if closeErr := rows.Close(); closeErr != nil && err == nil {
+			err = closeErr
 		}
 	}()
-	rColumnTypes, rError = lRows.ColumnTypes()
+	columnTypes, err = rows.ColumnTypes()
 	return
 }
diff --git a/schema/schema_test.go b/schema/schema_test.go
index 7985eb9..838ce6a 100644
--- a/schema/schema_test.go
+++ b/schema/schema_test.go
@@ -10,74 +10,74 @@ import (
 	"github.com/ordershift/ormshift/schema"
 )
 
-func testColumnTypesQueryFunc(pTableName string) string {
-	return fmt.Sprintf("SELECT * FROM %s WHERE 1=0", pTableName)
+func testColumnTypesQueryFunc(table string) string {
+	return fmt.Sprintf("SELECT * FROM %s WHERE 1=0", table)
 }
 
 func TestNewDBSchema(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lDBSchema, lError := schema.NewDBSchema(lDB.DB(), "query", testColumnTypesQueryFunc)
-	if !testutils.AssertNotNilResultAndNilError(t, lDBSchema, lError, "schema.NewDBSchema") {
+	dbSchema, err := schema.NewDBSchema(db.DB(), "query", testColumnTypesQueryFunc)
+	if !testutils.AssertNotNilResultAndNilError(t, dbSchema, err, "schema.NewDBSchema") {
 		return
 	}
 }
 
 func TestNewDBSchemaFailsWhenDBIsNil(t *testing.T) {
-	lDBSchema, lError := schema.NewDBSchema(nil, "query", testColumnTypesQueryFunc)
-	if !testutils.AssertNilResultAndNotNilError(t, lDBSchema, lError, "schema.NewDBSchema") {
+	dbSchema, err := schema.NewDBSchema(nil, "query", testColumnTypesQueryFunc)
+	if !testutils.AssertNilResultAndNotNilError(t, dbSchema, err, "schema.NewDBSchema") {
 		return
 	}
-	testutils.AssertErrorMessage(t, "sql.DB cannot be nil", lError, "schema.NewDBSchema")
+	testutils.AssertErrorMessage(t, "sql.DB cannot be nil", err, "schema.NewDBSchema")
 }
 
 func TestHasColumn(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lProductAttributeTable := testutils.FakeProductAttributeTable(t)
+	productAttributeTable := testutils.FakeProductAttributeTable(t)
 
-	_, lError = lDB.SQLExecutor().Exec(sqlite.Driver().SQLBuilder().CreateTable(lProductAttributeTable))
-	if !testutils.AssertNilError(t, lError, "DB.Exec") {
+	_, err = db.SQLExecutor().Exec(sqlite.Driver().SQLBuilder().CreateTable(productAttributeTable))
+	if !testutils.AssertNilError(t, err, "DB.Exec") {
 		return
 	}
 
-	lDBSchema := lDB.DBSchema()
-	testutils.AssertEqualWithLabel(t, true, lDBSchema.HasTable(lProductAttributeTable.Name()), "DBSchema.HasTable")
-	for _, lColumn := range lProductAttributeTable.Columns() {
-		testutils.AssertEqualWithLabel(t, true, lDBSchema.HasColumn(lProductAttributeTable.Name(), lColumn.Name()), "DBSchema.HasColumn")
+	dbSchema := db.DBSchema()
+	testutils.AssertEqualWithLabel(t, true, dbSchema.HasTable(productAttributeTable.Name()), "DBSchema.HasTable")
+	for _, column := range productAttributeTable.Columns() {
+		testutils.AssertEqualWithLabel(t, true, dbSchema.HasColumn(productAttributeTable.Name(), column.Name()), "DBSchema.HasColumn")
 	}
-	lAnyTableName := "any_table"
-	lAnyColumnName := "any_col"
-	testutils.AssertEqualWithLabel(t, false, lDBSchema.HasColumn(lProductAttributeTable.Name(), lAnyColumnName), "DBSchema.HasColumn")
-	testutils.AssertEqualWithLabel(t, false, lDBSchema.HasColumn(lAnyTableName, lAnyColumnName), "DBSchema.HasColumn")
+	anyTableName := "any_table"
+	anyColumnName := "any_col"
+	testutils.AssertEqualWithLabel(t, false, dbSchema.HasColumn(productAttributeTable.Name(), anyColumnName), "DBSchema.HasColumn")
+	testutils.AssertEqualWithLabel(t, false, dbSchema.HasColumn(anyTableName, anyColumnName), "DBSchema.HasColumn")
 }
 
 func TestHasTableReturnsFalseWhenDatabaseIsInvalid(t *testing.T) {
-	lDB, lError := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
-	if !testutils.AssertNotNilResultAndNilError(t, lDB, lError, "ormshift.OpenDatabase") {
+	db, err := ormshift.OpenDatabase(sqlite.Driver(), ormshift.ConnectionParams{InMemory: true})
+	if !testutils.AssertNotNilResultAndNilError(t, db, err, "ormshift.OpenDatabase") {
 		return
 	}
-	defer func() { _ = lDB.Close() }()
+	defer func() { _ = db.Close() }()
 
-	lProductAttributeTable := testutils.FakeProductAttributeTable(t)
+	productAttributeTable := testutils.FakeProductAttributeTable(t)
 
-	_, lError = lDB.SQLExecutor().Exec(sqlite.Driver().SQLBuilder().CreateTable(lProductAttributeTable))
-	if !testutils.AssertNilError(t, lError, "DB.Exec") {
+	_, err = db.SQLExecutor().Exec(sqlite.Driver().SQLBuilder().CreateTable(productAttributeTable))
+	if !testutils.AssertNilError(t, err, "DB.Exec") {
 		return
 	}
 
-	lError = lDB.Close()
-	if !testutils.AssertNilError(t, lError, "DB.Close") {
+	err = db.Close()
+	if !testutils.AssertNilError(t, err, "DB.Close") {
 		return
 	}
-	lDBSchema := lDB.DBSchema()
-	testutils.AssertEqualWithLabel(t, false, lDBSchema.HasTable(lProductAttributeTable.Name()), "DBSchema.HasTable")
+	dbSchema := db.DBSchema()
+	testutils.AssertEqualWithLabel(t, false, dbSchema.HasTable(productAttributeTable.Name()), "DBSchema.HasTable")
 }
diff --git a/schema/table.go b/schema/table.go
index c1a5ce2..becb105 100644
--- a/schema/table.go
+++ b/schema/table.go
@@ -11,9 +11,9 @@ type Table struct {
 	columns []Column
 }
 
-func NewTable(pName string) Table {
+func NewTable(name string) Table {
 	return Table{
-		name:    pName,
+		name:    name,
 		columns: []Column{},
 	}
 }
@@ -26,16 +26,16 @@ func (t *Table) Columns() []Column {
 	return t.columns
 }
 
-func (t *Table) AddColumns(pParams ...NewColumnParams) error {
-	for _, lColParams := range pParams {
-		lColumn := NewColumn(lColParams)
-		lColumnAlreadyExists := slices.ContainsFunc(t.columns, func(c Column) bool {
-			return strings.EqualFold(lColumn.Name(), c.Name())
+func (t *Table) AddColumns(params ...NewColumnParams) error {
+	for _, colParams := range params {
+		column := NewColumn(colParams)
+		exists := slices.ContainsFunc(t.columns, func(c Column) bool {
+			return strings.EqualFold(column.Name(), c.Name())
 		})
-		if lColumnAlreadyExists {
-			return fmt.Errorf("column %q already exists in table %q", lColumn.Name(), t.Name())
+		if exists {
+			return fmt.Errorf("column %q already exists in table %q", column.Name(), t.Name())
 		}
-		t.columns = append(t.columns, lColumn)
+		t.columns = append(t.columns, column)
 	}
 	return nil
 }
diff --git a/schema/table_test.go b/schema/table_test.go
index 028c5bd..f46d6b1 100644
--- a/schema/table_test.go
+++ b/schema/table_test.go
@@ -9,13 +9,13 @@ import (
 )
 
 func TestAddColumnFailsWhenAlreadyExists(t *testing.T) {
-	lProductAttributeTable := testutils.FakeProductAttributeTable(t)
-	lError := lProductAttributeTable.AddColumns(schema.NewColumnParams{
+	productAttributeTable := testutils.FakeProductAttributeTable(t)
+	err := productAttributeTable.AddColumns(schema.NewColumnParams{
 		Name: "value",
 		Type: schema.Integer,
 	})
-	if !testutils.AssertNotNilError(t, lError, "Table.AddColumns") {
+	if !testutils.AssertNotNilError(t, err, "Table.AddColumns") {
 		return
 	}
-	testutils.AssertErrorMessage(t, fmt.Sprintf("column %q already exists in table %q", "value", "product_attribute"), lError, "Table.AddColumns")
+	testutils.AssertErrorMessage(t, fmt.Sprintf("column %q already exists in table %q", "value", "product_attribute"), err, "Table.AddColumns")
 }