remove or change all keywords

Author: bing.ma

.github/ISSUE_TEMPLATE/bug_report.md

@@ -27,7 +27,7 @@ import (
 )
 
 func main() {
-	conn, err := pgx.Connect(context.Background(), os.Getenv("DATABASE_URL"))
+	conn, err := gaussdbgo.Connect(context.Background(), os.Getenv("DATABASE_URL"))
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -47,8 +47,8 @@ A clear and concise description of what actually happened.
 
 **Version**
  - Go: `$ go version` -> [e.g. go version go1.18.3 darwin/amd64]
- - PostgreSQL: `$ psql --no-psqlrc --tuples-only -c 'select version()'` -> [e.g. PostgreSQL 14.4 on x86_64-apple-darwin21.5.0, compiled by Apple clang version 13.1.6 (clang-1316.0.21.2.5), 64-bit]
- - pgx: `$ grep 'github.com/jackc/pgx/v[0-9]' go.mod` -> [e.g. v4.16.1]
+ - GaussDB: `$ gsql --no-psqlrc --tuples-only -c 'select version()'` -> [e.g. GaussDB 9.2.4 on x86_64-apple-darwin21.5.0, compiled by Apple clang version 13.1.6 (clang-1316.0.21.2.5), 64-bit]
+ - gaussdbgo: `$ grep 'github.com/HuaweiCloudDeveloper/gaussdb-go/v[0-9]' go.mod` -> [e.g. v4.16.1]
 
 **Additional context**
 Add any other context about the problem here.

.github/workflows/ci.yml

@@ -128,8 +128,8 @@ jobs:
         go-version: ["1.22", "1.23"]
 
     steps:
-      - name: Setup PostgreSQL
-        id: postgres
+      - name: Setup GaussDB
+        id: gaussdb
         uses: ikalnytskyi/action-setup-postgres@v4
         with:
           database: pgx_test

Rakefile

@@ -7,11 +7,11 @@ rule '.go' => '.go.erb' do |task|
 end
 
 generated_code_files = [
-  "pgtype/int.go",
-  "pgtype/int_test.go",
-  "pgtype/integration_benchmark_test.go",
-  "pgtype/zeronull/int.go",
-  "pgtype/zeronull/int_test.go"
+  "gaussdbtype/int.go",
+  "gaussdbtype/int_test.go",
+  "gaussdbtype/integration_benchmark_test.go",
+  "gaussdbtype/zeronull/int.go",
+  "gaussdbtype/zeronull/int_test.go"
 ]
 
 desc "Generate code"

batch.go

@@ -60,7 +60,7 @@ type Batch struct {
 	QueuedQueries []*QueuedQuery
 }
 
-// Queue queues a query to batch b. query can be an SQL query or the name of a prepared statement. The only pgx option
+// Queue queues a query to batch b. query can be an SQL query or the name of a prepared statement. The only gaussdbgo option
 // argument that is supported is QueryRewriter. Queries are executed using the connection's DefaultQueryExecMode.
 //
 // While query can contain multiple statements if the connection's DefaultQueryExecMode is QueryModeSimple, this should

batch_test.go

@@ -767,7 +767,7 @@ func TestTxSendBatch(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
 	defer cancel()
 
-	pgxtest.RunWithQueryExecModes(ctx, t, defaultConnTestRunner, nil, func(ctx context.Context, t testing.TB, conn *gaussdbgo.Conn) {
+	gaussdbxtest.RunWithQueryExecModes(ctx, t, defaultConnTestRunner, nil, func(ctx context.Context, t testing.TB, conn *gaussdbgo.Conn) {
 
 		sql := `create temporary table ledger1(
 	  id serial primary key,

bench_test.go

@@ -1314,7 +1314,7 @@ func (qr *queryRecorder) SetWriteDeadline(t time.Time) error {
 	return qr.conn.SetWriteDeadline(t)
 }
 
-// BenchmarkSelectRowsRawPrepared hijacks a pgconn connection and inserts a queryRecorder. It then executes the query
+// BenchmarkSelectRowsRawPrepared hijacks a gaussdbconn connection and inserts a queryRecorder. It then executes the query
 // once. The benchmark is simply sending the exact query bytes over the wire to the server and reading the expected
 // number of bytes back. It does nothing else. This should be the theoretical maximum performance a Go application
 // could achieve.

conn.go

@@ -35,7 +35,7 @@ type ConnConfig struct {
 	// "cache_describe" query exec mode.
 	DescriptionCacheCapacity int
 
-	// DefaultQueryExecMode controls the default mode for executing queries. By default pgx uses the extended protocol
+	// DefaultQueryExecMode controls the default mode for executing queries. By default gaussdbgo uses the extended protocol
 	// and automatically prepares and caches prepared statements. However, this may be incompatible with proxies such as
 	// PGBouncer. In this case it may be preferable to use QueryExecModeExec or QueryExecModeSimpleProtocol. The same
 	// functionality can be controlled on a per query basis by passing a QueryExecMode as the first query argument.
@@ -59,7 +59,7 @@ func (cc *ConnConfig) Copy() *ConnConfig {
 	return newConfig
 }
 
-// ConnString returns the connection string as parsed by pgx.ParseConfig into pgx.ConnConfig.
+// ConnString returns the connection string as parsed by gaussdbgo.ParseConfig into gaussdbgo.ConnConfig.
 func (cc *ConnConfig) ConnString() string { return cc.connString }
 
 // Conn is a GaussDB connection handle. It is not safe for concurrent usage. Use a connection pool to manage access
@@ -130,7 +130,7 @@ var (
 )
 
 // Connect establishes a connection with a GaussDB server with a connection string. See
-// pgconn.Connect for details.
+// gaussdbconn.Connect for details.
 func Connect(ctx context.Context, connString string) (*Conn, error) {
 	connConfig, err := ParseConfig(connString)
 	if err != nil {
@@ -218,7 +218,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con
 	return connConfig, nil
 }
 
-// ParseConfig creates a ConnConfig from a connection string. ParseConfig handles all options that [pgconn.ParseConfig]
+// ParseConfig creates a ConnConfig from a connection string. ParseConfig handles all options that [gaussdbconn.ParseConfig]
 // does. In addition, it accepts the following options:
 //
 //   - default_query_exec_mode.
@@ -267,7 +267,7 @@ func connect(ctx context.Context, config *ConnConfig) (c *Conn, err error) {
 		c.prepareTracer = t
 	}
 
-	// Only install pgx notification system if no other callback handler is present.
+	// Only install gaussdbgo notification system if no other callback handler is present.
 	if config.Config.OnNotification == nil {
 		config.Config.OnNotification = c.bufferNotifications
 	}
@@ -395,7 +395,7 @@ func (c *Conn) bufferNotifications(_ *gaussdbconn.GaussdbConn, n *gaussdbconn.No
 	c.notifications = append(c.notifications, n)
 }
 
-// WaitForNotification waits for a GaussDB notification. It wraps the underlying pgconn notification system in a
+// WaitForNotification waits for a GaussDB notification. It wraps the underlying gaussdbconn notification system in a
 // slightly more convenient form.
 func (c *Conn) WaitForNotification(ctx context.Context) (*gaussdbconn.Notification, error) {
 	var n *gaussdbconn.Notification
@@ -434,16 +434,16 @@ func quoteIdentifier(s string) string {
 	return `"` + strings.ReplaceAll(s, `"`, `""`) + `"`
 }
 
-// Ping delegates to the underlying *pgconn.GaussdbConn.Ping.
+// Ping delegates to the underlying *gaussdbconn.GaussdbConn.Ping.
 func (c *Conn) Ping(ctx context.Context) error {
 	return c.gaussdbConn.Ping(ctx)
 }
 
-// GaussdbConn returns the underlying *pgconn.GaussdbConn. This is an escape hatch method that allows lower level access to the
-// GaussDB connection than pgx exposes.
+// GaussdbConn returns the underlying *gaussdbconn.GaussdbConn. This is an escape hatch method that allows lower level access to the
+// GaussDB connection than gaussdbgo exposes.
 //
-// It is strongly recommended that the connection be idle (no in-progress queries) before the underlying *pgconn.GaussdbConn
-// is used and the connection must be returned to the same state before any *pgx.Conn methods are again used.
+// It is strongly recommended that the connection be idle (no in-progress queries) before the underlying *gaussdbconn.GaussdbConn
+// is used and the connection must be returned to the same state before any *gaussdbgo.Conn methods are again used.
 func (c *Conn) GaussdbConn() *gaussdbconn.GaussdbConn { return c.gaussdbConn }
 
 // TypeMap returns the connection info used for this connection.
@@ -639,7 +639,7 @@ const (
 
 	// Assume the GaussDB query parameter types based on the Go type of the arguments. This uses the extended protocol
 	// with text formatted parameters and results. Queries are executed in a single round trip. Type mappings can be
-	// registered with pgtype.Map.RegisterDefaultGaussdbType. Queries will be rejected that have arguments that are
+	// registered with gaussdbtype.Map.RegisterDefaultGaussdbType. Queries will be rejected that have arguments that are
 	// unregistered or ambiguous. e.g. A map[string]string may have the GaussDB type json or hstore. Modes that know
 	// the GaussDB type can use a map[string]string directly as an argument. This mode cannot.
 	//
@@ -648,15 +648,15 @@ const (
 	// Roman numerals (e.g. 7 is VII). The binary format would properly encode the integer 7 as the binary value for 7.
 	// But the text format would encode the integer 7 as the string "VII". As QueryExecModeExec uses the text format, it
 	// is possible that changing query mode from another mode to QueryExecModeExec could change the behavior of the query.
-	// This should not occur with types pgx supports directly and can be avoided by registering the types with
-	// pgtype.Map.RegisterDefaultGaussdbType and implementing the appropriate type interfaces. In the cas of RomanNumeral, it
-	// should implement pgtype.Int64Valuer.
+	// This should not occur with types gaussdbgo supports directly and can be avoided by registering the types with
+	// gaussdbtype.Map.RegisterDefaultGaussdbType and implementing the appropriate type interfaces. In the cas of RomanNumeral, it
+	// should implement gaussdbtype.Int64Valuer.
 	QueryExecModeExec
 
 	// Use the simple protocol. Assume the GaussDB query parameter types based on the Go type of the arguments. This is
 	// especially significant for []byte values. []byte values are encoded as GaussDB bytea. string must be used
 	// instead for text type values including json and jsonb. Type mappings can be registered with
-	// pgtype.Map.RegisterDefaultGaussdbType. Queries will be rejected that have arguments that are unregistered or ambiguous.
+	// gaussdbtype.Map.RegisterDefaultGaussdbType. Queries will be rejected that have arguments that are unregistered or ambiguous.
 	// e.g. A map[string]string may have the GaussDB type json or hstore. Modes that know the GaussDB type can use a
 	// map[string]string directly as an argument. This mode cannot. Queries are executed in a single round trip.
 	//
@@ -1243,8 +1243,8 @@ func (c *Conn) sanitizeForSimpleQuery(sql string, args ...any) (string, error) {
 	return sanitize.SanitizeSQL(sql, valueArgs...)
 }
 
-// LoadType inspects the database for typeName and produces a pgtype.Type suitable for registration. typeName must be
-// the name of a type where the underlying type(s) is already understood by pgx. It is for derived types. In particular,
+// LoadType inspects the database for typeName and produces a gaussdbtype.Type suitable for registration. typeName must be
+// the name of a type where the underlying type(s) is already understood by gaussdbgo. It is for derived types. In particular,
 // typeName must be one of the following:
 //   - An array type name of a type that is already registered. e.g. "_foo" when "foo" is registered.
 //   - A composite type name where all field types are already registered.

conn_test.go

@@ -88,7 +88,7 @@ func TestConnectWithPreferSimpleProtocol(t *testing.T) {
 	defer closeConn(t, conn)
 
 	// If simple protocol is used we should be able to correctly scan the result
-	// into a pgtype.Text as the integer will have been encoded in text.
+	// into a gaussdbtype.Text as the integer will have been encoded in text.
 
 	var s gaussdbtype.Text
 	err := conn.QueryRow(context.Background(), "select $1::int4", 42).Scan(&s)
@@ -113,7 +113,7 @@ func TestConfigContainsConnStr(t *testing.T) {
 }
 
 func TestConfigCopyReturnsEqualConfig(t *testing.T) {
-	connString := "gaussdb://jack:secret@localhost:5432/mydb?application_name=pgxtest&search_path=myschema&connect_timeout=5"
+	connString := "gaussdb://jack:secret@localhost:5432/mydb?application_name=gaussdbxtest&search_path=myschema&connect_timeout=5"
 	original, err := gaussdbgo.ParseConfig(connString)
 	require.NoError(t, err)
 
@@ -652,7 +652,7 @@ func TestDeallocateMissingPreparedStatementStillClearsFromPreparedStatementMap(t
 	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond)
 	defer cancel()
 	notification, err = listener.WaitForNotification(ctx)
-	assert.True(t, pgconn.Timeout(err))
+	assert.True(t, gaussdbconn.Timeout(err))
 	assert.Nil(t, notification)
 
 	// listener can listen again after a timeout
@@ -968,7 +968,7 @@ func TestConnInitTypeMap(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
 	defer cancel()
 
-	pgxtest.RunWithQueryExecModes(ctx, t, defaultConnTestRunner, nil, func(ctx context.Context, t testing.TB, conn *gaussdbgo.Conn) {
+	gaussdbxtest.RunWithQueryExecModes(ctx, t, defaultConnTestRunner, nil, func(ctx context.Context, t testing.TB, conn *gaussdbgo.Conn) {
 
 		// Domain type uint64 is a GaussDB domain of underlying type numeric.
 
@@ -1103,7 +1103,7 @@ func TestLoadRangeType(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
 	defer cancel()
 
-	pgxtest.RunWithQueryExecModes(ctx, t, defaultConnTestRunner, nil, func(ctx context.Context, t testing.TB, conn *gaussdbgo.Conn) {
+	gaussdbxtest.RunWithQueryExecModes(ctx, t, defaultConnTestRunner, nil, func(ctx context.Context, t testing.TB, conn *gaussdbgo.Conn) {
 
 		tx, err := conn.Begin(ctx)
 		require.NoError(t, err)
@@ -1116,30 +1116,30 @@ func TestLoadRangeType(t *testing.T) {
 		newRangeType, err := conn.LoadType(ctx, "examplefloatrange")
 		require.NoError(t, err)
 		conn.TypeMap().RegisterType(newRangeType)
-		conn.TypeMap().RegisterDefaultGaussdbType(pgtype.Range[float64]{}, "examplefloatrange")
+		conn.TypeMap().RegisterDefaultGaussdbType(gaussdbtype.Range[float64]{}, "examplefloatrange")
 
 		newMultiRangeType, err := conn.LoadType(ctx, "examplefloatmultirange")
 		require.NoError(t, err)
 		conn.TypeMap().RegisterType(newMultiRangeType)
-		conn.TypeMap().RegisterDefaultGaussdbType(pgtype.Multirange[pgtype.Range[float64]]{}, "examplefloatmultirange")
+		conn.TypeMap().RegisterDefaultGaussdbType(gaussdbtype.Multirange[gaussdbtype.Range[float64]]{}, "examplefloatmultirange")
 
-		var inputMultiRangeType = pgtype.Multirange[pgtype.Range[float64]]{
+		var inputMultiRangeType = gaussdbtype.Multirange[gaussdbtype.Range[float64]]{
 			{
 				Lower:     1.0,
 				Upper:     2.0,
-				LowerType: pgtype.Inclusive,
-				UpperType: pgtype.Inclusive,
+				LowerType: gaussdbtype.Inclusive,
+				UpperType: gaussdbtype.Inclusive,
 				Valid:     true,
 			},
 			{
 				Lower:     3.0,
 				Upper:     4.0,
-				LowerType: pgtype.Exclusive,
-				UpperType: pgtype.Exclusive,
+				LowerType: gaussdbtype.Exclusive,
+				UpperType: gaussdbtype.Exclusive,
 				Valid:     true,
 			},
 		}
-		var outputMultiRangeType pgtype.Multirange[pgtype.Range[float64]]
+		var outputMultiRangeType gaussdbtype.Multirange[gaussdbtype.Range[float64]]
 		err = tx.QueryRow(ctx, "SELECT $1::examplefloatmultirange", inputMultiRangeType).Scan(&outputMultiRangeType)
 		require.NoError(t, err)
 		require.Equal(t, inputMultiRangeType, outputMultiRangeType)

copy_from.go

@@ -257,11 +257,11 @@ func (ct *copyFrom) buildCopyBuf(buf []byte, sd *gaussdbconn.StatementDescriptio
 // CopyFrom uses the GaussDB copy protocol to perform bulk data insertion. It returns the number of rows copied and
 // an error.
 //
-// CopyFrom requires all values use the binary format. A pgtype.Type that supports the binary format must be registered
-// for the type of each column. Almost all types implemented by pgx support the binary format.
+// CopyFrom requires all values use the binary format. A gaussdbtype.Type that supports the binary format must be registered
+// for the type of each column. Almost all types implemented by gaussdbgo support the binary format.
 //
 // Even though enum types appear to be strings they still must be registered to use with CopyFrom. This can be done with
-// Conn.LoadType and pgtype.Map.RegisterType.
+// Conn.LoadType and gaussdbtype.Map.RegisterType.
 func (c *Conn) CopyFrom(ctx context.Context, tableName Identifier, columnNames []string, rowSrc CopyFromSource) (int64, error) {
 	ct := &copyFrom{
 		conn:          c,

derived_types.go

@@ -186,7 +186,7 @@ func (c *Conn) LoadTypes(ctx context.Context, typeNames []string) ([]*gaussdbtyp
 		case "b": // array
 			dt, ok := m.TypeForOID(ti.Typelem)
 			if !ok {
-				return nil, fmt.Errorf("Array element OID %v not registered while loading pgtype %q", ti.Typelem, ti.TypeName)
+				return nil, fmt.Errorf("Array element OID %v not registered while loading gaussdbtype %q", ti.Typelem, ti.TypeName)
 			}
 			type_ = &gaussdbtype.Type{Name: ti.TypeName, OID: ti.Oid, Codec: &gaussdbtype.ArrayCodec{ElementType: dt}}
 		case "c": // composite