sqldb/v2: align sqlite idle defaults

Keep SQLite's default idle connection limit aligned with the
open connection limit so the default pool matches v1 behavior.

This is a follow-up regression fix to the restored open-connection
default in e263ea145. After that change, SQLite again defaulted to
SetMaxOpenConns(2), but SetMaxIdleConns still fell back to 6. Go
silently caps idle connections at the open limit, so nothing
crashed, but the configured idle default became misleading and no
longer matched v1.

Use cfg.MaxConns() as the inherited idle default, keep the
explicit MaxIdleConnections override, and add unit coverage for
the default and override cases. The mismatch was easy to miss
because the code still compiled and basic tests did not assert the
effective idle pool sizing.

Author: yyforyongyu

sqldb/v2/config.go

@@ -77,6 +77,16 @@ func (s *SqliteConfig) MaxConns() int {
 	return DefaultSqliteMaxConns
 }
 
+// MaxIdleConns returns the effective maximum number of idle SQLite
+// connections.
+func (s *SqliteConfig) MaxIdleConns() int {
+	if s.MaxIdleConnections > 0 {
+		return s.MaxIdleConnections
+	}
+
+	return s.MaxConns()
+}
+
 // Validate checks that the SqliteConfig values are valid.
 func (p *SqliteConfig) Validate() error {
 	if err := p.QueryConfig.Validate(true); err != nil {

sqldb/v2/config_test.go

@@ -41,3 +41,48 @@ func TestSqliteConfigMaxConns(t *testing.T) {
 		})
 	}
 }
+
+// TestSqliteConfigMaxIdleConns verifies that SQLite defaults its idle
+// connections to the open connection limit unless the caller overrides it.
+func TestSqliteConfigMaxIdleConns(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name             string
+		maxConns         int
+		maxIdleConns     int
+		expectedIdleConn int
+	}{
+		{
+			name:             "default idle limit",
+			expectedIdleConn: DefaultSqliteMaxConns,
+		},
+		{
+			name:             "inherits explicit open limit",
+			maxConns:         4,
+			expectedIdleConn: 4,
+		},
+		{
+			name:             "explicit idle limit",
+			maxConns:         4,
+			maxIdleConns:     3,
+			expectedIdleConn: 3,
+		},
+	}
+
+	for _, testCase := range testCases {
+		testCase := testCase
+
+		t.Run(testCase.name, func(t *testing.T) {
+			t.Parallel()
+
+			cfg := &SqliteConfig{
+				MaxConnections:     testCase.maxConns,
+				MaxIdleConnections: testCase.maxIdleConns,
+			}
+
+			require.Equal(t, testCase.expectedIdleConn,
+				cfg.MaxIdleConns())
+		})
+	}
+}

sqldb/v2/sqlite.go

@@ -136,18 +136,13 @@ func NewSqliteStore(cfg *SqliteConfig, dbPath string) (*SqliteStore, error) {
 			err)
 	}
 
-	maxIdleConns := defaultMaxIdleConns
-	if cfg.MaxIdleConnections > 0 {
-		maxIdleConns = cfg.MaxIdleConnections
-	}
-
 	connMaxLifetime := defaultConnMaxLifetime
 	if cfg.ConnMaxLifetime > 0 {
 		connMaxLifetime = cfg.ConnMaxLifetime
 	}
 
 	db.SetMaxOpenConns(cfg.MaxConns())
-	db.SetMaxIdleConns(maxIdleConns)
+	db.SetMaxIdleConns(cfg.MaxIdleConns())
 	db.SetConnMaxLifetime(connMaxLifetime)
 
 	s := &SqliteStore{