Move sql package from codnect.io/procyon to codnect.io/procyon-data

Author: burakkoken

sql/connection.go

@@ -0,0 +1,26 @@
+package sql
+
+import (
+	"context"
+	"database/sql/driver"
+	"time"
+)
+
+type Connection interface {
+	ExecContext(ctx context.Context, query string, args ...any) (Result, error)
+	PrepareContext(ctx context.Context, query string, args ...any) (Statement, error)
+	QueryContext(ctx context.Context, query string, args ...any) (RowSet, error)
+	QueryRowContext(ctx context.Context, query string, args ...any) (Row, error)
+	PingContext(ctx context.Context) error
+
+	SetConnMaxLifetime(d time.Duration) error
+	SetConnMaxIdleTime(d time.Duration) error
+	SetMaxIdleConns(n int) error
+	SetMaxOpenConns(n int) error
+
+	BeginTransaction(ctx context.Context) (TransactionStatus, error)
+	Driver() driver.Driver
+
+	Close() error
+	IsClosed() bool
+}

sql/context.go

@@ -0,0 +1,27 @@
+package sql
+
+import (
+	"context"
+	"reflect"
+)
+
+type ctxTransactionContext struct{}
+
+var (
+	ctxTransactionContextKey = &ctxTransactionContext{}
+	rTransactionContextType  = reflect.TypeOf((*TransactionContext)(nil))
+)
+
+type TransactionContext struct {
+}
+
+func FromContext[T *TransactionContext](ctx context.Context) T {
+	var value T
+	rType := reflect.TypeOf((*T)(nil)).Elem()
+
+	if rType.ConvertibleTo(rTransactionContextType) {
+		value = ctx.Value(ctxTransactionContextKey).(T)
+	}
+
+	return value
+}

sql/datasource.go

@@ -0,0 +1,5 @@
+package sql
+
+type DataSource interface {
+	GetConnection() (Connection, error)
+}

sql/extractor.go

@@ -0,0 +1,9 @@
+package sql
+
+func ExtractRow[T any](row Row, callback func(row Row) T) (t T) {
+	return callback(row)
+}
+
+func ExtractRowSet[T any](rowSet RowSet, callback func(rowSet RowSet) []T) []T {
+	return callback(rowSet)
+}

sql/isolation.go

@@ -0,0 +1,14 @@
+package sql
+
+type IsolationLevel int
+
+const (
+	LevelDefault IsolationLevel = iota
+	LevelReadUncommitted
+	LevelReadCommitted
+	LevelWriteCommitted
+	LevelRepeatableRead
+	LevelSnapshot
+	LevelSerializable
+	LevelLinearizable
+)

sql/manager.go

@@ -0,0 +1,31 @@
+package sql
+
+import "context"
+
+type TransactionManager interface {
+	GetTransaction(ctx context.Context, options ...any) (TransactionStatus, error)
+	Commit() error
+	Rollback() error
+}
+
+type DataSourceTransactionManager struct {
+	dataSource DataSource
+}
+
+func NewDataSourceTransactionManager(dataSource DataSource) *DataSourceTransactionManager {
+	return &DataSourceTransactionManager{
+		dataSource: dataSource,
+	}
+}
+
+func (m *DataSourceTransactionManager) GetTransaction(ctx context.Context, options ...any) (TransactionStatus, error) {
+	return nil, nil
+}
+
+func (m *DataSourceTransactionManager) Commit() error {
+	return nil
+}
+
+func (m *DataSourceTransactionManager) Rollback() error {
+	return nil
+}

sql/options.go

@@ -0,0 +1,88 @@
+package sql
+
+import "time"
+
+type TransactionOption func(options *TransactionOptions)
+
+type TransactionOptions struct {
+	propagation    Propagation
+	timeout        time.Duration
+	readOnly       bool
+	isolationLevel IsolationLevel
+}
+
+func (o *TransactionOptions) Propagation() Propagation {
+	return o.propagation
+}
+
+func (o *TransactionOptions) Timeout() time.Duration {
+	return o.timeout
+}
+
+func (o *TransactionOptions) IsReadOnly() bool {
+	return o.readOnly
+}
+
+func (o *TransactionOptions) IsolationLevel() IsolationLevel {
+	return o.isolationLevel
+}
+
+func (o *TransactionOptions) Merge(options *TransactionOptions) *TransactionOptions {
+	copyOptions := new(TransactionOptions)
+	*copyOptions = *o
+
+	copyOptions.propagation = options.propagation
+	copyOptions.timeout = options.timeout
+	copyOptions.readOnly = options.readOnly
+	copyOptions.isolationLevel = options.isolationLevel
+
+	return copyOptions
+}
+
+func (o *TransactionOptions) Override(options ...TransactionOption) *TransactionOptions {
+	copyOptions := new(TransactionOptions)
+	*copyOptions = *o
+
+	for _, option := range options {
+		option(copyOptions)
+	}
+
+	return copyOptions
+}
+
+func DefaultTransactionOptions() *TransactionOptions {
+	return &TransactionOptions{
+		propagation:    PropagationRequired,
+		timeout:        -1,
+		readOnly:       false,
+		isolationLevel: LevelDefault,
+	}
+}
+
+func NewTransactionOptions(opts ...TransactionOption) *TransactionOptions {
+	return DefaultTransactionOptions().Override(opts...)
+}
+
+func WithPropagation(propagation Propagation) TransactionOption {
+	return func(options *TransactionOptions) {
+		options.propagation = propagation
+	}
+}
+
+func WithTimeout(timeout time.Duration) TransactionOption {
+	return func(options *TransactionOptions) {
+		options.timeout = timeout
+	}
+}
+
+func WithReadOnly(readOnly bool) TransactionOption {
+	return func(options *TransactionOptions) {
+		options.readOnly = readOnly
+	}
+}
+
+func WithIsolation(isolationLevel IsolationLevel) TransactionOption {
+	return func(options *TransactionOptions) {
+		options.isolationLevel = isolationLevel
+	}
+}

sql/propagation.go

@@ -0,0 +1,13 @@
+package sql
+
+type Propagation int
+
+const (
+	PropagationRequired Propagation = iota
+	PropagationSupports
+	PropagationMandatory
+	PropagationNever
+	PropagationNotSupported
+	PropagationNested
+	PropagationRequiredNew
+)

sql/register.go

@@ -0,0 +1,10 @@
+package sql
+
+import (
+	"database/sql"
+	"database/sql/driver"
+)
+
+func Register(name string, driver driver.Driver) {
+	sql.Register(name, driver)
+}

sql/result.go

@@ -0,0 +1,6 @@
+package sql
+
+type Result interface {
+	LastInsertId() (int64, error)
+	RowsAffected() (int64, error)
+}