Overhauled wireup.

Author: joliver

config.go

@@ -0,0 +1,101 @@
+package sqldb
+
+import (
+	"database/sql"
+	"time"
+)
+
+type configuration struct {
+	txOptions         *sql.TxOptions
+	splitStatement    bool
+	panicOnBindError  bool
+	stackTraceOnError bool
+	parameterPrefix   string
+	retrySleep        time.Duration
+}
+
+func NewPool(handle *sql.DB, options ...option) ConnectionPool {
+	var config configuration
+	Options.apply(options...)(&config)
+	return newPool(handle, config)
+}
+func NewBindingPool(handle *sql.DB, options ...option) BindingConnectionPool {
+	var config configuration
+	Options.apply(options...)(&config)
+	return newBindingPool(handle, config)
+}
+func newPool(handle *sql.DB, config configuration) ConnectionPool {
+	var pool ConnectionPool = NewLibraryConnectionPoolAdapter(handle, config.txOptions)
+
+	if config.splitStatement {
+		pool = NewSplitStatementConnectionPool(pool, config.parameterPrefix)
+	}
+
+	if config.stackTraceOnError {
+		pool = NewStackTraceConnectionPool(pool)
+	}
+
+	return pool
+}
+func newBindingPool(handle *sql.DB, config configuration) BindingConnectionPool {
+	inner := newPool(handle, config)
+	var pool BindingConnectionPool = NewBindingConnectionPoolAdapter(inner, config.panicOnBindError)
+
+	if config.retrySleep > 0 {
+		pool = NewRetryBindingConnectionPool(pool, config.retrySleep)
+	}
+
+	return pool
+}
+
+var Options singleton
+
+type singleton struct{}
+type option func(*configuration)
+
+func (singleton) TxOptions(value *sql.TxOptions) option {
+	return func(this *configuration) { this.txOptions = value }
+}
+func (singleton) PanicOnBindError(value bool) option {
+	return func(this *configuration) { this.panicOnBindError = value }
+}
+func (singleton) MySQL() option {
+	return func(this *configuration) { this.splitStatement = true; this.parameterPrefix = "?" }
+}
+func (singleton) ParameterPrefix(value string) option {
+	return func(this *configuration) { this.parameterPrefix = value }
+}
+func (singleton) SplitStatement(value bool) option {
+	return func(this *configuration) { this.splitStatement = value }
+}
+func (singleton) RetrySleep(value time.Duration) option {
+	return func(this *configuration) { this.retrySleep = value }
+}
+func (singleton) StackTraceErrDiagnostics(value bool) option {
+	return func(this *configuration) { this.stackTraceOnError = value }
+}
+
+func (singleton) apply(options ...option) option {
+	return func(this *configuration) {
+		for _, option := range Options.defaults(options...) {
+			option(this)
+		}
+	}
+}
+func (singleton) defaults(options ...option) []option {
+	var defaultTxOptions = &sql.TxOptions{Isolation: sql.LevelReadCommitted}
+	const defaultStackTraceErrDiagnostics = true
+	const defaultPanicOnBindError = true
+	const defaultSplitStatement = true
+	const defaultParameterPrefix = "?"
+	const defaultRetrySleep = 0
+
+	return append([]option{
+		Options.TxOptions(defaultTxOptions),
+		Options.PanicOnBindError(defaultPanicOnBindError),
+		Options.StackTraceErrDiagnostics(defaultStackTraceErrDiagnostics),
+		Options.ParameterPrefix(defaultParameterPrefix),
+		Options.SplitStatement(defaultSplitStatement),
+		Options.RetrySleep(defaultRetrySleep),
+	}, options...)
+}

config_tx.go

@@ -0,0 +1,82 @@
+package sqldb
+
+import (
+	"database/sql"
+)
+
+type txConfig struct {
+	splitStatement    bool
+	panicOnBindError  bool
+	stackTraceOnError bool
+	parameterPrefix   string
+}
+
+func NewTransaction(handle *sql.Tx, options ...txOption) Transaction {
+	var config txConfig
+	TxOptions.apply(options...)(&config)
+	return newTx(handle, config)
+}
+func NewBindingTransaction(handle *sql.Tx, options ...txOption) BindingTransaction {
+	var config txConfig
+	TxOptions.apply(options...)(&config)
+	return newBindingTx(handle, config)
+}
+func newTx(handle *sql.Tx, config txConfig) Transaction {
+	var tx Transaction = NewLibraryTransactionAdapter(handle)
+
+	if config.splitStatement {
+		tx = NewSplitStatementTransaction(tx, config.parameterPrefix)
+	}
+
+	if config.stackTraceOnError {
+		tx = NewStackTraceTransaction(tx)
+	}
+
+	return tx
+}
+func newBindingTx(handle *sql.Tx, config txConfig) BindingTransaction {
+	inner := newTx(handle, config)
+	return NewBindingTransactionAdapter(inner, config.panicOnBindError)
+}
+
+var TxOptions txSingleton
+
+type txSingleton struct{}
+type txOption func(*txConfig)
+
+func (txSingleton) PanicOnBindError(value bool) txOption {
+	return func(this *txConfig) { this.panicOnBindError = value }
+}
+func (txSingleton) MySQL() txOption {
+	return func(this *txConfig) { this.splitStatement = true; this.parameterPrefix = "?" }
+}
+func (txSingleton) ParameterPrefix(value string) txOption {
+	return func(this *txConfig) { this.parameterPrefix = value }
+}
+func (txSingleton) SplitStatement(value bool) txOption {
+	return func(this *txConfig) { this.splitStatement = value }
+}
+func (txSingleton) StackTraceErrDiagnostics(value bool) txOption {
+	return func(this *txConfig) { this.stackTraceOnError = value }
+}
+
+func (txSingleton) apply(txOptions ...txOption) txOption {
+	return func(this *txConfig) {
+		for _, txOption := range TxOptions.defaults(txOptions...) {
+			txOption(this)
+		}
+	}
+}
+func (txSingleton) defaults(txOptions ...txOption) []txOption {
+	const defaultStackTraceErrDiagnostics = true
+	const defaultPanicOnBindError = true
+	const defaultSplitStatement = true
+	const defaultParameterPrefix = "?"
+
+	return append([]txOption{
+		TxOptions.PanicOnBindError(defaultPanicOnBindError),
+		TxOptions.StackTraceErrDiagnostics(defaultStackTraceErrDiagnostics),
+		TxOptions.ParameterPrefix(defaultParameterPrefix),
+		TxOptions.SplitStatement(defaultSplitStatement),
+	}, txOptions...)
+}