Pgtype - Revision history

Busk at 01:27, 24 March 2022

2022-03-24T01:27:53Z

Busk at 23:48, 23 March 2022

2022-03-23T23:48:35Z

Busk: Created page with "timeVal := pgtype.Timestamptz{Status: pgtype.Null} timeVal.Set(theTime)"

2022-03-23T14:22:19Z

Created page with "timeVal := pgtype.Timestamptz{Status: pgtype.Null} timeVal.Set(theTime)"

New page

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

@@ Line 16: / Line 16: @@
          "github.com/jackc/pgtype"
          "github.com/jackc/pgx/v4"
          "os"
          "time"
+)
 func testInsert() error {
          ctx := context.Background()
@@ Line 31: / Line 31: @@
          tx, err := conn.Begin(ctx)
          if err != nil {
                  return err
+         }
          defer tx.Rollback(ctx)
-         name := "test4"
+         name := "test6"
          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)
+         sqlp := `insert into test1(
-         // _, err = tx.Exec("insert into foo(id) values (1)")
+                name,
-//      _, err = tx.Exec(ctx, sql)
+                duration,
          if err != nil {
                  return err
+         }
@@ Line 49: / Line 57: @@
          err = tx.Commit(ctx)
          if err != nil {
                  return err
+         }
-         x := "foo"
+         msg := fmt.Sprintf("Insert into test1 of name = %v.\n", name)
-        err2 := fmt.Errorf("math: square root of negative number %v", x)
+        log.Debug(msg)
-         return err2
+         return err
+}
 func main() {
-         r := testInsert()
+         for {
-        fmt.Printf("r: %v\n", r)
+                e := testInsert()
+                if e != nil {
          conn, err := pgx.Connect(context.Background(), os.Getenv("DATABASE_URL"))

← Older revision		Revision as of 23:48, 23 March 2022
Line 1:		Line 1:
		+	```
	timeVal := pgtype.Timestamptz{Status: pgtype.Null}		timeVal := pgtype.Timestamptz{Status: pgtype.Null}
	timeVal.Set(theTime)		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)
		+	}
		+	```