Golang phân tích cú pháp mysql datetime

Gabor Javorszky

Ngày 7 tháng 10 năm 2020 • 8 phút đọc

Trong quá trình thử nghiệm một tính năng, tôi phải tạo các đối tượng tạo ra thời gian hiện tại, lưu trữ nó trong cơ sở dữ liệu, đọc lại và đảm bảo rằng thời gian trên cả đối tượng mà tôi đã lưu trữ và đối tượng mà tôi lấy ra khỏi cơ sở dữ liệu

Trên đường đi tôi gặp rất nhiều điều kỳ lạ. Nguyên nhân đầu tiên là vì một lý do nào đó mà thời gian tôi nhập và thời gian tôi rút ra bị lệch đi một giờ, vì vậy tôi đã xem xét các phần khác nhau của nguyên nhân có thể gây ra tình trạng này.

Nói ngắn gọn về phần bên trong của time.Time, cách xử lý múi giờ của nó, sau đó là cách xử lý múi giờ của kết nối cơ sở dữ liệu và máy chủ, điều đó có nghĩa là gì đối với việc lưu trữ dữ liệu và một loạt vấn đề ở cuối

Điều gì xảy ra trong time.Now()?

Cấu trúc của cấu trúc time.Time là nó có ba bit khác nhau

1. một cái gì đó gọi là "đồng hồ treo tường", đó là những gì chúng ta sử dụng khi nói thời gian. Đó là những gì bạn nhìn thấy khi nhìn vào đồng hồ trên tường, giả sử đồng hồ tuân theo DST tự động thay đổi. Thông thường, điều này sẽ không được sử dụng để nói khoảng thời gian giữa hai thời điểm khác nhau bởi vì nếu bạn xem thời gian ở 1. 58 giờ sáng ngày 25 tháng 10 tại Luân Đôn, và sau đó nhìn vào thời gian một giờ sau, nó sẽ hiện 1. 58 giờ sáng với sự khác biệt là 0 giữa các đồng hồ treo tường. Giờ mùa hè của Anh kết thúc lúc 2 giờ sáng ngày 25 tháng 10 năm 2020, vì vậy 2 giờ sáng -> 1 giờ sáng ngày hôm đó
2. một cái gì đó gọi là đồng hồ đơn điệu. Điều này được khởi tạo vào thời điểm phiên bản thời gian mới được tạo và được sử dụng cho các chênh lệch thời gian. Một số phương pháp về thời gian sẽ loại bỏ đồng hồ đơn điệu khỏi ví dụ. Ví dụ: .AddDate, .Round và .Truncate
3. và một địa điểm. Vị trí chỉ được sử dụng cho mục đích hiển thị, nó không làm thay đổi giá trị thực của thời gian. Theo mặc định, vị trí sẽ dựa trên múi giờ địa phương của máy

"Múi giờ địa phương" là gì?

Tôi không biết điều này hoạt động như thế nào trên hệ thống Windows, nhưng trên hệ thống Unix (tôi đang dùng mac), trước tiên, nó xem xét biến môi trường

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

Nếu

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

Cài đặt ở trên dẫn đến kết quả này

$ ls -la /etc/localtime
lrwxr-xr-x  1 root  wheel  36  8 Oct 00:21 /etc/localtime -> /var/db/timezone/zoneinfo/Asia/Tokyo

Giờ địa phương trong vùng chứa docker

Cách đặt múi giờ của bộ chứa docker là đặt biến môi trường

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

Điều gì xảy ra trong một kết nối SQL?

Có hai múi giờ mà chúng ta cần xử lý trong cơ sở dữ liệu MySQL

1. múi giờ của hệ thống, đó là những gì máy chủ mysql sẽ sử dụng
2. và múi giờ của chính kết nối

kết nối SQL

Đặt múi giờ của kết nối là cách dễ dàng hơn. dsn (tên nguồn dữ liệu) có thể chứa một loạt các tham số. Một dsn đầy đủ tôi sẽ sử dụng trong mã của mình trông như thế này

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

Ở đây tôi đang đặt kết nối thành

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

máy chủ SQL

Nếu máy chủ mysql đang chạy cục bộ, rất có thể nó sử dụng cùng múi giờ với hệ thống của bạn. Nếu không, bạn có thể định cấu hình nó bằng cờ dòng lệnh

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

Điều này rất quan trọng vì cột

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

TLDR của

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

như một ví dụ.

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

Cùng một giá trị

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

ts.In(connection.Timezone).Format(mysqlDateTimeFormat)

Múi giờ của máy chủ MySQL sẽ rất quan trọng đối với dấu thời gian hiện tại

Giờ địa phương hiện tại ở London là

ts.In(connection.Timezone).Format(mysqlDateTimeFormat)

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

const dsn = "test:test@(localhost:3310)/test?parseTime=true&loc=Asia%2FTokyo"

ts.In(connection.Timezone).Format(mysqlDateTimeFormat)

ts.In(connection.Timezone).Format(mysqlDateTimeFormat)

Hãy nói về các câu lệnh parseTime và SQL

Tầm quan trọng của

ts.In(connection.Timezone).Format(mysqlDateTimeFormat)

Điều đó cũng có nghĩa là khi quét các giá trị ra khỏi bảng có dấu thời gian (hoặc cột ngày giờ, ngày tháng, thời gian) sẽ được mở ra thành một thể hiện time.Time thay vì một time.Time0

Xem xét đoạn mã này (xử lý lỗi và nhập bị bỏ qua)

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

Lưu ý rằng nano giây (phần time.Time1) bị thiếu trong thời gian "hết". Đó là bởi vì khi chúng tôi tạo thời gian với time.Now(), Go đã quản lý để đo nano giây tại thời điểm nó được tạo

Tuy nhiên, việc đưa dữ liệu đó vào cơ sở dữ liệu với định dạng ngày của MySQL (time.Time3) không có độ phân giải để lưu trữ nano giây, do đó, khi đọc dấu thời gian, không thể tạo lại nano giây¹

tuyên bố. Exec nội bộ cho thời gian. phân tích thời gian

Nó sẽ lặp qua tất cả các đối số, kiểm tra loại của chúng và nếu đó là một time.Time, trước tiên, nó sẽ thay đổi vị trí múi giờ của nó thành bất kỳ múi giờ nào của kết nối, sau đó định dạng nó thành định dạng dấu thời gian của MySQL và chuyển nó tới

Về bản chất, nó đang làm điều này

ts.In(connection.Timezone).Format(mysqlDateTimeFormat)

Nếu bạn muốn xem mã thực tế trong phiên bản 1. 5. 0 của trình điều khiển mysql.

hàng. Quét nội bộ cho thời gian. phân tích thời gian

Bên trong trình điều khiển (time.Time5) sẽ trả về một tập kết quả time.Time6 cốt lõi

Phương thức time.Time7 trên cấu trúc đó sẽ gọi một hàm có tên là time.Time8 cho mỗi cột, nơi nó sẽ lấy time.Time9, con trỏ tới loại bạn đang quét và nguồn, kết quả trả về từ cơ sở dữ liệu cho

Trên thực tế, điều này có nghĩa là nếu kết nối có time.Now()0 trên dsn, bất kỳ giá trị nào có

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

Nếu sau đó biến bạn đang quét cũng là một time.Time, thì bạn chỉ cần lấy lại giá trị đó ngay lập tức. Nếu bạn đang quét một time.Time thành một chuỗi, thì bạn sẽ lấy lại biểu diễn time.Now()8 của giá trị được lưu trữ

Đây là

Điều quan trọng cần lưu ý là nếu time.Now()0 không có trên dsn, thì giá trị của cột

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

Điều này có ý nghĩa gì đối với thử nghiệm?

Tất cả những điều trên có nghĩa là như sau

• time.Now() sẽ Just Work™ với mọi thứ. Những gì bạn đưa vào là những gì bạn sẽ nhận ra vì cả ba múi giờ đều được tính đến (hệ thống cục bộ của bạn, kết nối SQL và máy chủ SQL)
• khi bạn đang tạo thời gian mới dựa trên một chuỗi có time.Time4, hãy đảm bảo rằng chuỗi bạn đang phân tích cú pháp ở múi giờ UTC vì time.Time4 chỉ là cách viết tắt của time.Time6 với ____42_______7 là một vị trí
• khi bạn đang tạo một thời gian mới dựa trên một chuỗi có time.Time8, hãy đảm bảo rằng bạn tạo một time.Time9 tương ứng với các giá trị trong chuỗi thời gian
• khi so sánh xem một time.Time mà bạn đưa vào và lấy ra khỏi cơ sở dữ liệu có giống nhau hay không, hãy đảm bảo làm tròn đến giây gần nhất. Cột

  // connection is America/Phoenix
  db, _ := sql.Open("mysql", mysqlDSN)
  
  // table has an auto-increment id and a timestamp colum ts
  insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")
  
  // ts is now 2020-10-07 12:00:00+01:00 for BST
  ts := time.Now()
  
  results, _ := insert.Exec(ts)
  id, _ := results.LastInsertId()
  
  // then we open another connection, this time the tz is Europe/London
  db2, _ := sql.Open("mysql", mysqlDSN2)
  
  select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")
  
  // we get the same row out that we inserted previously
  rows, _ := select.Exec(id)
  
  var id int64
  var gotTime time.Time
  
  for rows.Next() {
  	_ = rows.Scan(&id, &gotTime)
  }
  
  // compare the times
  fmt.Printf("in: %s\nout: %s",
      ts.In(time.UTC).Format(time.RFC3339Nano),
      gotTime.In(time.UTC).Format(time.RFC3339Nano))
  
  // this will print:
  in: 2020-10-07 11:00:00.703337Z
  out: 2020-10-07 11:00:00Z

  2 không có độ phân giải để lưu trữ nano giây, vì vậy khi lấy ra cột đó sẽ bị mất và .AddDate2 sẽ không thành công¹
• nói chung hãy để Go api thực hiện công việc của nó khi hoạt động theo thời gian. Sử dụng các phương pháp có sẵn và chỉ loay hoay với múi giờ khi tạo thời gian hoặc khi bạn chuẩn bị hiển thị thời gian ở đâu đó

Hy vọng bạn tìm thấy điều này phần nào hữu ích. Nếu bạn có câu hỏi hoặc muốn gửi email cho tôi, hãy tìm tôi trên twitter qua @javorszky hoặc gửi email cho tôi trên gabor (at) javorszky (dot) co (dot) uk

phụ lục

[1] Về mặt kỹ thuật, bạn có thể tạo cột

// connection is America/Phoenix
db, _ := sql.Open("mysql", mysqlDSN)

// table has an auto-increment id and a timestamp colum ts
insert, _ := db.Prepare("INSERT INTO table (ts) VALUES (?)")

// ts is now 2020-10-07 12:00:00+01:00 for BST
ts := time.Now()

results, _ := insert.Exec(ts)
id, _ := results.LastInsertId()

// then we open another connection, this time the tz is Europe/London
db2, _ := sql.Open("mysql", mysqlDSN2)

select, _ := db.Prepare("SELECT * FROM table WHERE id = ?")

// we get the same row out that we inserted previously
rows, _ := select.Exec(id)

var id int64
var gotTime time.Time

for rows.Next() {
	_ = rows.Scan(&id, &gotTime)
}

// compare the times
fmt.Printf("in: %s\nout: %s",
    ts.In(time.UTC).Format(time.RFC3339Nano),
    gotTime.In(time.UTC).Format(time.RFC3339Nano))

// this will print:
in: 2020-10-07 11:00:00.703337Z
out: 2020-10-07 11:00:00Z

Làm cách nào để phân tích ngày tháng trong golang?

Làm thế nào để phân tích thời gian trong golang?