FilesExpand file tree

main

/

db.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

107 lines (92 loc) · 2.91 KB

main

/

db.go

Copy path

Top

File metadata and controls

• Code
• Blame

107 lines (92 loc) · 2.91 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

package reform

import (

"context"

"database/sql"

"time"

)

// DBInterface is a subset of *sql.DB used by reform.

// Can be used together with NewDBFromInterface for easier integration with existing code or for passing test doubles.

//

// It may grow and shrink over time to include only needed *sql.DB methods,

// and is excluded from SemVer compatibility guarantees.

type DBInterface interface {

DBTXContext

BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)

// Deprecated: do not use, it will be removed in v1.6.

DBTX

// Deprecated: do not use, it will be removed in v1.6.

Begin() (*sql.Tx, error)

}

// check interface

var _ DBInterface = (*sql.DB)(nil)

// DB represents a connection to SQL database.

type DB struct {

*Querier

db DBInterface

}

// NewDB creates new DB object for given SQL database connection.

// Logger can be nil.

func NewDB(db *sql.DB, dialect Dialect, logger Logger) *DB {

return NewDBFromInterface(db, dialect, logger)

}

// NewDBFromInterface creates new DB object for given DBInterface.

// Can be used for easier integration with existing code or for passing test doubles.

// Logger can be nil.

func NewDBFromInterface(db DBInterface, dialect Dialect, logger Logger) *DB {

return &DB{

Querier: newQuerier(context.Background(), db, "", dialect, logger),

db: db,

}

}

// DBInterface returns DBInterface associated with a given DB object.

func (db *DB) DBInterface() DBInterface {

return db.db

}

// Begin starts transaction with Querier's context and default options.

func (db *DB) Begin() (*TX, error) {

return db.BeginTx(db.Querier.ctx, nil)

}

// BeginTx starts transaction with given context and options (can be nil).

func (db *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (*TX, error) {

db.logBefore("BEGIN", nil)

start := time.Now()

tx, err := db.db.BeginTx(ctx, opts)

db.logAfter("BEGIN", nil, time.Since(start), err)

if err != nil {

return nil, err

}

return newTX(ctx, tx, db.Dialect, db.Logger), nil

}

// InTransaction wraps function execution in transaction with Querier's context and default options,

// rolling back it in case of error or panic, committing otherwise.

func (db *DB) InTransaction(f func(t *TX) error) error {

return db.InTransactionContext(db.Querier.ctx, nil, f)

}

// InTransactionContext wraps function execution in transaction with given context and options (can be nil),

// rolling back it in case of error or panic, committing otherwise.

func (db *DB) InTransactionContext(ctx context.Context, opts *sql.TxOptions, f func(t *TX) error) error {

tx, err := db.BeginTx(ctx, opts)

if err != nil {

return err

}

var committed bool

defer func() {

if !committed {

// always return f() or Commit() error, not possible Rollback() error

_ = tx.Rollback()

}

}()

err = f(tx)

if err == nil {

err = tx.Commit()

}

if err == nil {

committed = true

}

return err

}

// check interfaces

var (

_ DBTX = (*DB)(nil)

_ DBTXContext = (*DB)(nil)

)