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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
---
id: sql-integration
title: sql.DB Integration
---
The following examples show how to pass a custom `sql.DB` object to `ent.Client`.
## Configure `sql.DB`
First option:
```go
package main
import (
"time"
"<your_project>/ent"
"github.com/facebook/ent/dialect/sql"
)
func Open() (*ent.Client, error) {
drv, err := sql.Open("mysql", "<mysql-dsn>")
if err != nil {
return nil, err
}
// Get the underlying sql.DB object of the driver.
db := drv.DB()
db.SetMaxIdleConns(10)
db.SetMaxOpenConns(100)
db.SetConnMaxLifetime(time.Hour)
return ent.NewClient(ent.Driver(drv)), nil
}
```
Second option:
```go
package main
import (
"database/sql"
"time"
"<your_project>/ent"
entsql "github.com/facebook/ent/dialect/sql"
)
func Open() (*ent.Client, error) {
db, err := sql.Open("mysql", "<mysql-dsn>")
if err != nil {
return nil, err
}
db.SetMaxIdleConns(10)
db.SetMaxOpenConns(100)
db.SetConnMaxLifetime(time.Hour)
// Create an ent.Driver from `db`.
drv := entsql.OpenDB("mysql", db)
return ent.NewClient(ent.Driver(drv)), nil
}
```
## Use Opencensus With MySQL
```go
package main
import (
"context"
"database/sql"
"database/sql/driver"
"<project>/ent"
"contrib.go.opencensus.io/integrations/ocsql"
"github.com/go-sql-driver/mysql"
entsql "github.com/facebook/ent/dialect/sql"
)
type connector struct {
dsn string
}
func (c connector) Connect(context.Context) (driver.Conn, error) {
return c.Driver().Open(c.dsn)
}
func (connector) Driver() driver.Driver {
return ocsql.Wrap(
mysql.MySQLDriver{},
ocsql.WithAllTraceOptions(),
ocsql.WithRowsClose(false),
ocsql.WithRowsNext(false),
ocsql.WithDisableErrSkip(true),
)
}
// Open new connection and start stats recorder.
func Open(dsn string) *ent.Client {
db := sql.OpenDB(connector{dsn})
// Create an ent.Driver from `db`.
drv := entsql.OpenDB("mysql", db)
return ent.NewClient(ent.Driver(drv))
}
```
## Use pgx with PostgreSQL
```go
package main
import (
"context"
"database/sql"
"log"
"<project>/ent"
"github.com/facebook/ent/dialect"
entsql "github.com/facebook/ent/dialect/sql"
_ "github.com/jackc/pgx/v4/stdlib"
)
// Open new connection
func Open(databaseUrl string) *ent.Client {
db, err := sql.Open("pgx", databaseUrl)
if err != nil {
log.Fatal(err)
}
// Create an ent.Driver from `db`.
drv := entsql.OpenDB(dialect.Postgres, db)
return ent.NewClient(ent.Driver(drv))
}
func main() {
client := Open("postgresql://user:password@127.0.0.1/database")
// Your code. For example:
ctx := context.Background()
if err := client.Schema.Create(ctx); err != nil {
log.Fatal(err)
}
users, err := client.User.Query().All(ctx)
if err != nil {
log.Fatal(err)
}
log.Println(users)
}
```
|
