save

pool.go

@@ -64,26 +64,26 @@ func (d *Pool) NewConn(mode connMode, pgConnString string) error {
 		return nil
 	}
 }
-func (d *Pool) newConn(mode connMode, pgConnString string) (c *conn, err error) {
-	var pool *pgxpool.Pool
+func (d *Pool) newConn(mode connMode, pgConnString string) (q *conn, err error) {
+	var pgxPool *pgxpool.Pool
 
 	if !strings.Contains(pgConnString, "default_query_exec_mode=") {
 		pgConnString += " default_query_exec_mode=simple_protocol"
 	}
 
-	if pool, err = pgxpool.New(d.ctx, pgConnString); err != nil {
-		return &conn{Pool: pool, Alive: false, Mode: mode}, err
+	if pgxPool, err = pgxpool.New(d.ctx, pgConnString); err != nil {
+		return &conn{Pool: pgxPool, Alive: false, Mode: mode}, err
 	}
 
-	c = &conn{Pool: pool, Alive: false, Mode: mode}
+	q = &conn{Pool: pgxPool, Alive: false, Mode: mode}
 
-	if err = d.testConn(c); err != nil {
-		return c, err
+	if err = d.testConn(q); err != nil {
+		return q, err
 	}
 
-	c.Alive = true
+	q.Alive = true
 
-	return c, nil
+	return q, nil
 }
 
 func (d *Pool) slave() *conn {
@@ -110,21 +110,21 @@ func (d *Pool) slaveAsync() *conn {
 
 func (d *Pool) execWrapper(pool connMode, dst any, f func(conn *conn, dst1 any) error) error {
 	for {
-		var c *conn
+		var q *conn
 
 		if pool == ConnModeSync {
-			c = d.slave()
+			q = d.slave()
 		} else {
-			c = d.slaveAsync()
+			q = d.slaveAsync()
 		}
 
-		if err := f(c, dst); err != nil {
-			if c.Mode == ConnModeMaster {
+		if err := f(q, dst); err != nil {
+			if q.Mode == ConnModeMaster {
 				return err
 			} else {
 				if strings.Contains(err.Error(), "connect") || strings.Contains(err.Error(), "EOF") {
 					d.logger.Printf("DB_EXEC_WRAPPER_ERR: %s", err.Error())
-					d.setNotAliveConn(c)
+					d.setNotAliveConn(q)
 					continue
 				} else {
 					return err
@@ -178,15 +178,15 @@ func (d *Pool) setNotAliveConn(conn *conn) {
 func (d *Pool) Test() {
 	go func() {
 		for {
-			for i, p := range d.notAliveConns {
-				if err := d.testConn(p); err == nil {
+			for i, q := range d.notAliveConns {
+				if err := d.testConn(q); err == nil {
 					d.mu.Lock()
-					p.Alive = true
+					q.Alive = true
 					d.notAliveConns = remove(d.notAliveConns, i)
-					if p.Mode == ConnModeSync {
-						d.srvSlaves = append(d.srvSlaves, p)
-					} else if p.Mode == ConnModeAsync {
-						d.srvSlavesAsync = append(d.srvSlavesAsync, p)
+					if q.Mode == ConnModeSync {
+						d.srvSlaves = append(d.srvSlaves, q)
+					} else if q.Mode == ConnModeAsync {
+						d.srvSlavesAsync = append(d.srvSlavesAsync, q)
 					}
 					d.mu.Unlock()
 				}