func (dbs *DBs) SetMaxIdleConns(n int) {
	_setMaxIdleConns(dbs._all, n)
}
SetMaxIdleConns sets the maximum number of connections in the idle
connection pool for all masters-slaves.

If MaxOpenConns is greater than 0 but less than the new MaxIdleConns
then the new MaxIdleConns will be reduced to match the MaxOpenConns limit

If n <= 0, no idle connections are retained.
package mssqlx
import (
	"context"
	"database/sql"
	"errors"
	"os"
	"sync"
	"time"
	"github.com/hashicorp/go-multierror"
	"github.com/jmoiron/sqlx"
)
var (
	ErrNoConnection = errors.New("no connection available")
	ErrNoConnectionOrWsrep = errors.New("no connection available or Wsrep is not ready")
)
const (
	DefaultHealthCheckPeriodInMilli = 40
)
var hostName string
func init() {
	hostName, _ = os.Hostname()
}
func ping(w *wrapper) (err error) {
	_, err = w.db.Exec("SELECT 1")
	return
}
type DBs struct {
	driverName      string
	readQuerySource ReadQuerySource
	masters *balancer
	slaves  *balancer
	all     *balancer
	_masters []*wrapper
	_slaves  []*wrapper
	_all     []*wrapper
}
func (dbs *DBs) DriverName() string {
	return dbs.driverName
}
func (dbs *DBs) getDBs(s []*wrapper) ([]*sqlx.DB, int) {
	n := len(s)
	r := make([]*sqlx.DB, n)
	for i, v := range s {
		r[i] = v.db
	}
	return r, n
}
func (dbs *DBs) readBalancer() *balancer {
	if dbs.readQuerySource == ReadQuerySourceAll {
		return dbs.all
	}
	return dbs.slaves
}
func (dbs *DBs) GetAllMasters() ([]*sqlx.DB, int) {
	return dbs.getDBs(dbs._masters)
}
func (dbs *DBs) GetAllSlaves() ([]*sqlx.DB, int) {
	return dbs.getDBs(dbs._slaves)
}
func _ping(target []*wrapper) []error {
	if target == nil {
		return nil
	}
	nn := len(target)
	if nn == 0 {
		return nil
	}
	errResult := make([]error, nn)
	var wg sync.WaitGroup
	for i := range target {
		if target[i] != nil && target[i].db != nil {
			wg.Add(1)
			go func(ind int, wg *sync.WaitGroup) {
				errResult[ind] = target[ind].db.Ping()
				wg.Done()
			}(i, &wg)
		}
	}
	wg.Wait()
	return errResult
}
func (dbs *DBs) Ping() []error {
	return _ping(dbs._all)
}
func (dbs *DBs) PingMaster() []error {
	return _ping(dbs._masters)
}
func (dbs *DBs) PingSlave() []error {
	return _ping(dbs._slaves)
}
func _close(target []*wrapper) []error {
	if target == nil {
		return nil
	}
	nn := len(target)
	if nn == 0 {
		return nil
	}
	errResult := make([]error, nn)
	var wg sync.WaitGroup
	for i, db := range target {
		if db != nil && db.db != nil {
			wg.Add(1)
			go func(db *wrapper, ind int, wg *sync.WaitGroup) {
				errResult[ind] = db.db.Close()
				wg.Done()
			}(db, i, &wg)
		}
	}
	wg.Wait()
	return errResult
}
func (dbs *DBs) Destroy() []error {
	res := _close(dbs._all)
	if dbs.masters != nil {
		dbs.masters.destroy()
	}
	if dbs.slaves != nil {
		dbs.slaves.destroy()
	}
	dbs.all.destroy()
	return res
}
func (dbs *DBs) DestroyMaster() []error {
	if dbs.masters != nil {
		dbs.masters.destroy()
	}
	return _close(dbs._masters)
}
func (dbs *DBs) DestroySlave() []error {
	if dbs.slaves != nil {
		dbs.slaves.destroy()
	}
	return _close(dbs._slaves)
}
func _setMaxIdleConns(target []*wrapper, n int) {
	if target == nil {
		return
	}
	nn := len(target)
	if nn == 0 {
		return
	}
	var wg sync.WaitGroup
	for _, db := range target {
		if db != nil && db.db != nil {
			wg.Add(1)
			go func(db *wrapper, wg *sync.WaitGroup) {
				db.db.SetMaxIdleConns(n)
				wg.Done()
			}(db, &wg)
		}
	}
	wg.Wait()
}
func (dbs *DBs) SetHealthCheckPeriod(period uint64) {
	dbs.masters.setHealthCheckPeriod(period)
	dbs.slaves.setHealthCheckPeriod(period)
}
func (dbs *DBs) SetMasterHealthCheckPeriod(period uint64) {
	dbs.masters.setHealthCheckPeriod(period)
}
func (dbs *DBs) SetSlaveHealthCheckPeriod(period uint64) {
	dbs.slaves.setHealthCheckPeriod(period)
}