Golang pgx.Connect函数代码示例

func tableExists(t *testing.T, tableName string) bool {
	connConfig, err := readConfig("testdata/tern.conf")
	if err != nil {
		t.Fatal(err)
	}

	connConfig.TLSConfig = &tls.Config{InsecureSkipVerify: true}

	conn, err := pgx.Connect(*connConfig)
	if err != nil {
		connConfig.TLSConfig = nil
		conn, err = pgx.Connect(*connConfig)
	}
	if err != nil {
		t.Fatal(err)
	}
	defer conn.Close()

	var exists bool
	err = conn.QueryRow(
		"select exists(select 1 from information_schema.tables where table_catalog=$1 and table_name=$2)",
		connConfig.Database,
		tableName,
	).Scan(&exists)
	if err != nil {
		t.Fatal(err)
	}

	return exists
}

func TestConnectWithTLSFallback(t *testing.T) {
	t.Parallel()

	if tlsConnConfig == nil {
		t.Skip("Skipping due to undefined tlsConnConfig")
	}

	connConfig := *tlsConnConfig
	connConfig.TLSConfig = &tls.Config{ServerName: "bogus.local"} // bogus ServerName should ensure certificate validation failure

	conn, err := pgx.Connect(connConfig)
	if err == nil {
		t.Fatal("Expected failed connection, but succeeded")
	}

	connConfig.UseFallbackTLS = true
	connConfig.FallbackTLSConfig = &tls.Config{InsecureSkipVerify: true}

	conn, err = pgx.Connect(connConfig)
	if err != nil {
		t.Fatal("Unable to establish connection: " + err.Error())
	}

	err = conn.Close()
	if err != nil {
		t.Fatal("Unable to close connection")
	}
}

func totalrep(wg *sync.WaitGroup) {
	var snapshot int64
	conn1, err := pgx.Connect(cfg1)
	checkErr(err)
	defer conn1.Close()

	conn2, err := pgx.Connect(cfg2)
	checkErr(err)
	defer conn2.Close()

	var prevSum int64 = 0

	for running {
		exec(conn1, "begin transaction")
		exec(conn2, "begin transaction")

		snapshot = execQuery(conn1, "select dtm_extend()")
		snapshot = execQuery(conn2, "select dtm_access($1)", snapshot)

		sum1 := execQuery(conn1, "select sum(v) from t")
		sum2 := execQuery(conn2, "select sum(v) from t")

		exec(conn1, "commit")
		exec(conn2, "commit")

		sum := sum1 + sum2
		if sum != prevSum {
			fmt.Printf("Total=%d snapshot=%d\n", sum, snapshot)
			prevSum = sum
		}
	}
	wg.Done()
}

func prepare_db() {
	var snapshot int64
	var csn int64
	var gtid string = "init"

	conn1, err := pgx.Connect(cfg1)
	checkErr(err)
	defer conn1.Close()

	conn2, err := pgx.Connect(cfg2)
	checkErr(err)
	defer conn2.Close()

	exec(conn1, "drop extension if exists pg_dtm")
	exec(conn1, "create extension pg_dtm")
	exec(conn1, "drop table if exists t")
	exec(conn1, "create table t(u int primary key, v int)")

	exec(conn2, "drop extension if exists pg_dtm")
	exec(conn2, "create extension pg_dtm")
	exec(conn2, "drop table if exists t")
	exec(conn2, "create table t(u int primary key, v int)")

	exec(conn1, "begin transaction")
	exec(conn2, "begin transaction")

	snapshot = execQuery(conn1, "select dtm_extend($1)", gtid)
	snapshot = execQuery(conn2, "select dtm_access($1, $2)", snapshot, gtid)

	//for i := 0; i < N_ACCOUNTS; i++ {
	//    exec(conn1, "insert into t values($1, $2)", i, INIT_AMOUNT)
	//    exec(conn2, "insert into t values($1, $2)", i, INIT_AMOUNT)
	//}
	exec(conn1, "insert into t (select generate_series(0,$1-1), $2)", N_ACCOUNTS, 0)
	exec(conn2, "insert into t (select generate_series(0,$1-1), $2)", N_ACCOUNTS, 0)

	exec(conn1, "prepare transaction '"+gtid+"'")
	exec(conn2, "prepare transaction '"+gtid+"'")

	exec(conn1, "select dtm_begin_prepare($1)", gtid)
	exec(conn2, "select dtm_begin_prepare($1)", gtid)

	csn = execQuery(conn1, "select dtm_prepare($1, 0)", gtid)
	csn = execQuery(conn2, "select dtm_prepare($1, $2)", gtid, csn)

	exec(conn1, "select dtm_end_prepare($1, $2)", gtid, csn)
	exec(conn2, "select dtm_end_prepare($1, $2)", gtid, csn)

	exec(conn1, "commit prepared '"+gtid+"'")
	exec(conn2, "commit prepared '"+gtid+"'")
}

func transfer(id int, wg *sync.WaitGroup) {
	var err error
	var snapshot int64
	var csn int64

	nGlobalTrans := 0

	conn1, err := pgx.Connect(cfg1)
	checkErr(err)
	defer conn1.Close()

	conn2, err := pgx.Connect(cfg2)
	checkErr(err)
	defer conn2.Close()

	for i := 0; i < N_ITERATIONS; i++ {

		gtid := strconv.Itoa(id) + "." + strconv.Itoa(i)
		amount := 2*rand.Intn(2) - 1
		account1 := 2*id + 1
		account2 := 2*id + 2

		exec(conn1, "begin transaction")
		exec(conn2, "begin transaction")
		snapshot = execQuery(conn1, "select dtm_extend($1)", gtid)
		snapshot = execQuery(conn2, "select dtm_access($1, $2)", snapshot, gtid)

		exec(conn1, "update t set v = v - $1 where u=$2", amount, account1)
		exec(conn2, "update t set v = v + $1 where u=$2", amount, account2)

		exec(conn1, "prepare transaction '"+gtid+"'")
		exec(conn2, "prepare transaction '"+gtid+"'")

		exec(conn1, "select dtm_begin_prepare($1)", gtid)
		exec(conn2, "select dtm_begin_prepare($1)", gtid)

		csn = execQuery(conn1, "select dtm_prepare($1, 0)", gtid)
		csn = execQuery(conn2, "select dtm_prepare($1, $2)", gtid, csn)

		exec(conn1, "select dtm_end_prepare($1, $2)", gtid, csn)
		exec(conn2, "select dtm_end_prepare($1, $2)", gtid, csn)

		exec(conn1, "commit prepared '"+gtid+"'")
		exec(conn2, "commit prepared '"+gtid+"'")
		nGlobalTrans++

	}

	fmt.Printf("Test completed, performed %d global transactions\n", nGlobalTrans)
	wg.Done()
}

func main() {
	// get the database name as the first command-line argument
	if len(os.Args) <= 1 {
		fmt.Fprintf(os.Stderr, "Expected the name of a database as a command-line argument, but got nothing\n")
		os.Exit(1)
	}
	database_name := os.Args[1]

	pgxConfig := extractConfig()
	pgxConfig.Database = database_name

	var err error
	conn, err = pgx.Connect(pgxConfig)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Unable to connect to the database: %v\n", err)
		os.Exit(1)
	}

	db := AnalyzeDatabase(conn)
	initiateDeepAnalysis(db.name)
	// print a bunch of stats about the database
	fmt.Printf("database name: %s\n", db.name)
	fmt.Printf("database size: %s\n", db.size)
	publicTables := selectTablesBySchema("public")
	fmt.Printf("the 'public' schema contains %d tables\n", len(publicTables))
	printTables(publicTables)
	fmt.Printf("\n-----\n")
	printTableColumns("public", publicTables)
}

func Example_OnStartMigrationProgressLogging() {
	conn, err := pgx.Connect(*defaultConnectionParameters)
	if err != nil {
		fmt.Printf("Unable to establish connection: %v", err)
		return
	}

	// Clear any previous runs
	if _, err = conn.Exec("drop table if exists schema_version"); err != nil {
		fmt.Printf("Unable to drop schema_version table: %v", err)
		return
	}

	var m *migrate.Migrator
	m, err = migrate.NewMigrator(conn, "schema_version")
	if err != nil {
		fmt.Printf("Unable to create migrator: %v", err)
		return
	}

	m.OnStart = func(_ int32, name, direction, _ string) {
		fmt.Printf("Migrating %s: %s", direction, name)
	}

	m.AppendMigration("create a table", "create temporary table foo(id serial primary key)", "")

	if err = m.Migrate(); err != nil {
		fmt.Printf("Unexpected failure migrating: %v", err)
		return
	}
	// Output:
	// Migrating up: create a table
}

func (s *MigrateSuite) SetUpTest(c *C) {
	var err error
	s.conn, err = pgx.Connect(*defaultConnectionParameters)
	c.Assert(err, IsNil)

	s.cleanupSampleMigrator(c)
}

func (t TransfersFDW) prepare_master() {
	dbconf, err := pgx.ParseDSN(cfg.ConnStrs[0])
	checkErr(err)
	conn, err := pgx.Connect(dbconf)
	checkErr(err)
	defer conn.Close()

	exec(conn, "CREATE EXTENSION postgres_fdw")

	for i, connstr := range cfg.ConnStrs[1:] {
		conf, _ := pgx.ParseDSN(connstr)
		server_sql := fmt.Sprintf(
			"CREATE SERVER dtm%d FOREIGN DATA WRAPPER postgres_fdw options(dbname '%s', host '%s', port '%d')",
			i, conf.Database, conf.Host, conf.Port)
		foreign_sql := fmt.Sprintf(
			"CREATE FOREIGN TABLE t_fdw%d() inherits (t) server dtm%d options(table_name 't')",
			i, i)
		mapping_sql := fmt.Sprintf(
			"CREATE USER MAPPING for %s SERVER dtm%d options (user '%s')",
			conf.User, i, conf.User)

		exec(conn, server_sql)
		exec(conn, foreign_sql)
		exec(conn, mapping_sql)
	}

	if dbconf.User != "" {

	}

}

func Example_CustomType() {
	conn, err := pgx.Connect(*defaultConnConfig)
	if err != nil {
		fmt.Printf("Unable to establish connection: %v", err)
		return
	}

	var p NullPoint
	err = conn.QueryRow("select null::point").Scan(&p)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(p)

	err = conn.QueryRow("select point(1.5,2.5)").Scan(&p)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(p)
	// Output:
	// null point
	// 1.5, 2.5
}

func TestFatalTxError(t *testing.T) {
	t.Parallel()

	// Run timing sensitive test many times
	for i := 0; i < 50; i++ {
		func() {
			conn := mustConnect(t, *defaultConnConfig)
			defer closeConn(t, conn)

			otherConn, err := pgx.Connect(*defaultConnConfig)
			if err != nil {
				t.Fatalf("Unable to establish connection: %v", err)
			}
			defer otherConn.Close()

			_, err = otherConn.Exec("select pg_terminate_backend($1)", conn.Pid)
			if err != nil {
				t.Fatalf("Unable to kill backend PostgreSQL process: %v", err)
			}

			_, err = conn.Query("select 1")
			if err == nil {
				t.Fatal("Expected error but none occurred")
			}

			if conn.IsAlive() {
				t.Fatalf("Connection should not be live but was. Previous Query err: %v", err)
			}
		}()
	}
}

func mustConnect(t testing.TB, config pgx.ConnConfig) *pgx.Conn {
	conn, err := pgx.Connect(config)
	if err != nil {
		t.Fatalf("Unable to establish connection: %v", err)
	}
	return conn
}

func (t TransfersFDW) reader(wg *sync.WaitGroup, cFetches chan int, inconsistency *bool) {
	var sum int64
	var prevSum int64 = 0

	dbconf, err := pgx.ParseDSN(cfg.ConnStrs[0])
	checkErr(err)
	conn, err := pgx.Connect(dbconf)
	checkErr(err)
	defer conn.Close()

	for running {
		exec(conn, "select dtm_begin_transaction()")
		exec(conn, "begin transaction isolation level "+cfg.Isolation)
		sum = execQuery64(conn, "select sum(v) from t")
		if sum != prevSum {
			fmt.Printf("Total=%d\n", sum)
			fmt.Printf("inconsistency!\n")
			*inconsistency = true
			prevSum = sum
		}
		exec(conn, "commit")
	}
	conn.Close()
	wg.Done()
}

func (c *Config) Connect() (*pgx.Conn, error) {
	if c.SSHConnConfig.Host != "" {
		client, err := NewSSHClient(&c.SSHConnConfig)
		if err != nil {
			return nil, err
		}

		c.ConnConfig.Dial = client.Dial
	}

	// If sslmode was set in config file or cli argument, set it in the
	// environment so we can use pgx.ParseEnvLibpq to use pgx's built-in
	// functionality.
	switch c.SslMode {
	case "disable", "allow", "prefer", "require", "verify-ca", "verify-full":
		if err := os.Setenv("PGHOST", c.ConnConfig.Host); err != nil {
			return nil, err
		}
		if err := os.Setenv("PGSSLMODE", c.SslMode); err != nil {
			return nil, err
		}

		if cc, err := pgx.ParseEnvLibpq(); err == nil {
			c.ConnConfig.TLSConfig = cc.TLSConfig
			c.ConnConfig.UseFallbackTLS = cc.UseFallbackTLS
			c.ConnConfig.FallbackTLSConfig = cc.FallbackTLSConfig
		} else {
			return nil, err
		}
	}

	return pgx.Connect(c.ConnConfig)
}

func TestConnectCustomDialer(t *testing.T) {
	t.Parallel()

	if customDialerConnConfig == nil {
		t.Skip("Skipping due to undefined customDialerConnConfig")
	}

	dialled := false
	conf := *customDialerConnConfig
	conf.Dial = func(network, address string) (net.Conn, error) {
		dialled = true
		return net.Dial(network, address)
	}

	conn, err := pgx.Connect(conf)
	if err != nil {
		t.Fatalf("Unable to establish connection: %s", err)
	}
	if !dialled {
		t.Fatal("Connect did not use custom dialer")
	}

	err = conn.Close()
	if err != nil {
		t.Fatal("Unable to close connection")
	}
}