Pgtype

timeVal := pgtype.Timestamptz{Status: pgtype.Null}
timeVal.Set(theTime)


select extract(epoch from ts) as time from test1;

a.go

package main

import (
        "context"
        "fmt"
        "github.com/jackc/pgtype"
        "github.com/jackc/pgx/v4"
        "os"
        "time"
)

// func testInsert() error {
func testInsert() error {
        ctx := context.Background()
        conn, err := pgx.Connect(context.Background(), os.Getenv("DATABASE_URL"))
        if err != nil {
                fmt.Fprintf(os.Stderr, "Unable to connect to database: %v\n", err)
                os.Exit(1)
        }
        defer conn.Close(ctx)
        tx, err := conn.Begin(ctx)
        if err != nil {
                return err
        }
        defer tx.Rollback(ctx)

        name := "test4"
        nowtime := time.Now()
        // durationtime := time.Duration(500000)
        durationtime := time.Duration(5000000000)
        // sql := "insert into test1(name, duration, ts) values ('test2', '00:00:00.005', NOW())"
        _, err = tx.Exec(ctx, "insert into test1(name, duration, ts) values ($1, $2, $3)", name, durationtime, nowtime)
        // _, err = tx.Exec("insert into foo(id) values (1)")
//      _, err = tx.Exec(ctx, sql)
        if err != nil {
                return err
        }

        err = tx.Commit(ctx)
        if err != nil {
                return err
        }
        x := "foo"
        err2 := fmt.Errorf("math: square root of negative number %v", x)
        return err2
}

func main() {
        r := testInsert()
        fmt.Printf("r: %v\n", r)


        conn, err := pgx.Connect(context.Background(), os.Getenv("DATABASE_URL"))
        if err != nil {
                fmt.Fprintf(os.Stderr, "Unable to connect to database: %v\n", err)
                os.Exit(1)
        }
        defer conn.Close(context.Background())

        var name string
        var duration pgtype.Interval
        var ts pgtype.Time
        err = conn.QueryRow(context.Background(), "select name, duration, ts from test1 where name=$1", "test1").Scan(&name, &duration, &ts)
        if err != nil {
                fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
                os.Exit(1)
        }

        fmt.Println("row: ", name, duration, ts)

        // err = conn.exec(context.Background(), sql)
        // insert into test1(name, duration, ts) values ('test1', '00:00:00.005', NOW());

        // loc, _ := time.LoadLocation("Asia/Shanghai")
        //set timezone,
        // now := time.Now().In(loc)

        // var timeTz pgtype.Timestamptz
        //timeTz = pgtype.Timestamptz{Status: pgtype.Null}
        // timeTz, _ = time.Parse("00:00:00.000005", "00:00:00.000005")
        const layout = "00:00:00.000005"
        timeTz, _ := time.Parse(layout, "00:00:00.000005")
        fmt.Printf("timeTz: %v\n", timeTz)
        // pgTime = pgtype.Timestamptz{Time: timeTz, Status: pgtype.Null}
        var pgTime pgtype.Timestamptz
        pgTime = pgtype.Timestamptz{Time: timeTz}
        fmt.Printf("pgTime: %v\n", pgTime)
        // timeTz = pgtype.Timestamptz{Time: "00:00:00.000005", Status: pgtype.Null}
        var tnow time.Time
        tnow = time.Now()
        fmt.Printf("tnow: %v\n", tnow)
        os.Exit(1)
        var v int32
        v = 1
        //var pv pgtype.Int2
        // pv = pgtype.Int2(1)
        // var pv int16
        // pv := pgtype.Int2(1)
        // var t time.Duration
        // var t pgtype.Interval
        // t = "00:00:00.1"
        t := 1
        fmt.Printf("t: %v\n", t)
        // pt := pgtype.Interval(t/1000)
        // pt := t

        // var pt pgtype.Interval
        // pt = pgtype.Interval("40:00:00")
        pt := 1

        a, b := time.Parse("2006-01-02 3:04PM", "1970-01-01 9:00PM")
        fmt.Printf("a %v\n", a)
        fmt.Printf("b %v\n", b)
        timeVal := pgtype.Timestamptz{Status: pgtype.Null}
        // timeVal := pgtype.Interval{Microseconds:10000, Status: pgtype.Null}
        // timeVal := pgtype.Interval{Microseconds:10000}
        // timeDur := time.Time(timeVal)
        timeDur := timeVal
        fmt.Printf("timeVal %v\n", timeVal)
        fmt.Printf("timeDur %v\n", timeDur)

        tt := time.Now()
        // tunixmicro := time.Now().UnixMicro()
        tunixmicro := tt.UnixMicro()
        // j := pgtype.Interval{Microseconds:tt}
        // j := pgtype.Time{Microseconds:tt}
        // j := pgtype.Time(tt)
        var j time.Time
        j = tt
        fmt.Printf("j: %v\n", j)
        var jt pgtype.Timestamptz
        // jt = pgtype.Timestamptz{Time: j, Status: pgtype.Null}
        jt = pgtype.Timestamptz{Time: j, Status: 1}
        // jt = pgtype.Timestamptz{Time: j}
        fmt.Printf("pt: %v\n", jt)
        fmt.Printf("tunixmicro: %v\n", tunixmicro)
        os.Exit(1)
        // tt := time.Now().UnixNano()
        // pgtype.Timestamp(tt)
        fmt.Println(tt)
        // fmt.Println(t.String())
        // fmt.Println(t.Format("2006-01-02 15:04:05"))
        // fmt.Printf("timeVal %v\n", time.Duration(timeVal))

        // *dst = pgtype.Interval{Microseconds: value / 1000, Status: Present}
        // pt = pgtype.Interval{Microseconds: t / 1000, Status: Present}
        // pt = pgtype.Interval{Microseconds: t / 1000, Status: "Present"}
        fmt.Printf("pt: %v\n", pt)

        pv := 1
        fmt.Printf("v: %v pv: %v\n", v, pv)
        // "2006-01-02 15:04:05.999999999Z07:00:00"

        var n int = 97
        m := int64(n)
        fmt.Printf("m: %v\n", m)

        var badboys int = 1921

        // explicit type conversion
        var badboys2 float64 = float64(badboys)

        var badboys3 int64 = int64(badboys)

        var badboys4 uint = uint(badboys)
        fmt.Printf("v: %v pv: %v, %v", badboys2, badboys3, badboys4)
}