add option to alter session after connection open

Author: sijms

v2/connection.go

@@ -11,7 +11,6 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
-	"sync"
 	"sync/atomic"
 	"time"
 
@@ -38,18 +37,13 @@ const (
 	//PROXY       LogonMode = 0x400
 )
 
-var oracleDriver = &OracleDriver{cusTyp: map[string]customType{}}
-
 // from GODROR
 const wrapResultset = "--WRAP_RESULTSET--"
 
 // Querier is the QueryContext of sql.Conn.
 type Querier interface {
 	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
 }
-type GetDriverInterface interface {
-	Driver() driver.Driver
-}
 
 /////
 
@@ -113,46 +107,16 @@ type OracleConnector struct {
 	connectString string
 	dialer        network.DialerContext
 }
-type OracleDriver struct {
-	dataCollected bool
-	cusTyp        map[string]customType
-	mu            sync.Mutex
-	sStrConv      converters.IStringConverter
-	nStrConv      converters.IStringConverter
-	//serverCharset  int
-	//serverNCharset int
-	//Conn      *Connection
-	//Server    string
-	//Port      int
-	//Instance  string
-	//Service   string
-	//DBName    string
-	UserId string
-	//SessionId int
-	//SerialNum int
-}
-
-func init() {
-	sql.Register("oracle", oracleDriver)
-}
-
-func GetDefaultDriver() *OracleDriver {
-	return oracleDriver
-}
 
-func NewDriver() *OracleDriver {
-	return &OracleDriver{cusTyp: map[string]customType{}}
-}
 func NewConnector(connString string) driver.Connector {
 	return &OracleConnector{connectString: connString, drv: NewDriver()}
 }
-func (drv *OracleDriver) OpenConnector(connString string) (driver.Connector, error) {
+func (driver *OracleDriver) OpenConnector(connString string) (driver.Connector, error) {
 	// create hash from connection string
-	return &OracleConnector{drv: drv, connectString: connString}, nil
+	return &OracleConnector{drv: driver, connectString: connString}, nil
 }
 
 func (connector *OracleConnector) Connect(ctx context.Context) (driver.Conn, error) {
-
 	conn, err := NewConnection(connector.connectString)
 	if err != nil {
 		return nil, err
@@ -169,23 +133,11 @@ func (connector *OracleConnector) Connect(ctx context.Context) (driver.Conn, err
 	if err != nil {
 		return nil, err
 	}
-	connector.drv.collectData(conn)
-	return conn, nil
-}
-
-func (driver *OracleDriver) collectData(conn *Connection) {
-	if !driver.dataCollected {
-		driver.mu.Lock()
-		defer driver.mu.Unlock()
-		driver.UserId = conn.connOption.UserID
-		if driver.sStrConv == nil {
-			driver.sStrConv = conn.sStrConv.Clone()
-		}
-		if driver.nStrConv == nil {
-			driver.nStrConv = conn.nStrConv.Clone()
-		}
-		driver.dataCollected = true
+	err = connector.drv.init(conn)
+	if err != nil {
+		return nil, err
 	}
+	return conn, nil
 }
 
 func (connector *OracleConnector) Driver() driver.Driver {
@@ -197,29 +149,21 @@ func (connector *OracleConnector) Dialer(dialer network.DialerContext) {
 }
 
 // Open return a new open connection
-func (drv *OracleDriver) Open(name string) (driver.Conn, error) {
+func (driver *OracleDriver) Open(name string) (driver.Conn, error) {
 	conn, err := NewConnection(name)
-	conn.cusTyp = drv.cusTyp
+	conn.cusTyp = driver.cusTyp
 	if err != nil {
 		return nil, err
 	}
 	err = conn.Open()
 	if err != nil {
 		return nil, err
 	}
-	drv.collectData(conn)
-
-	return conn, nil
-}
-
-// SetStringConverter this function is used to set a custom string converter interface
-// that will be used to encode and decode strings and bytearrays
-// passing nil will use driver string converter for supported langs
-func SetStringConverter(db GetDriverInterface, charset, nCharset converters.IStringConverter) {
-	if driver, ok := db.Driver().(*OracleDriver); ok {
-		driver.sStrConv = charset
-		driver.nStrConv = nCharset
+	err = driver.init(conn)
+	if err != nil {
+		return nil, err
 	}
+	return conn, nil
 }
 
 // GetNLS return NLS properties of the connection.
@@ -1302,167 +1246,6 @@ func (conn *Connection) ResetSession(ctx context.Context) error {
 	return nil
 }
 
-func RegisterType(conn *sql.DB, typeName, arrayTypeName string, typeObj interface{}) error {
-	// ping first to avoid error when calling register type after open connection
-	err := conn.Ping()
-	if err != nil {
-		return err
-	}
-
-	if driver, ok := conn.Driver().(*OracleDriver); ok {
-		return RegisterTypeWithOwner(conn, driver.UserId, typeName, arrayTypeName, typeObj)
-	}
-	return errors.New("the driver used is not a go-ora driver type")
-}
-
-func RegisterTypeWithOwner(conn *sql.DB, owner, typeName, arrayTypeName string, typeObj interface{}) error {
-	if len(owner) == 0 {
-		return errors.New("owner can't be empty")
-	}
-	if driver, ok := conn.Driver().(*OracleDriver); ok {
-
-		if typeObj == nil {
-			return errors.New("type object cannot be nil")
-		}
-		typ := reflect.TypeOf(typeObj)
-		switch typ.Kind() {
-		case reflect.Ptr:
-			return errors.New("unsupported type object: Ptr")
-		case reflect.Array:
-			return errors.New("unsupported type object: Array")
-		case reflect.Chan:
-			return errors.New("unsupported type object: Chan")
-		case reflect.Map:
-			return errors.New("unsupported type object: Map")
-		case reflect.Slice:
-			return errors.New("unsupported type object: Slice")
-		}
-		if typ.Kind() != reflect.Struct {
-			return errors.New("type object should be of structure type")
-		}
-		cust := customType{
-			owner:         owner,
-			name:          typeName,
-			arrayTypeName: arrayTypeName,
-			typ:           typ,
-			fieldMap:      map[string]int{},
-		}
-		sqlText := `SELECT type_oid FROM ALL_TYPES WHERE UPPER(OWNER)=:1 AND UPPER(TYPE_NAME)=:2`
-		err := conn.QueryRow(sqlText, strings.ToUpper(owner), strings.ToUpper(typeName)).Scan(&cust.toid)
-		if err != nil {
-			return err
-		}
-		if len(cust.arrayTypeName) > 0 {
-			err = conn.QueryRow(sqlText, strings.ToUpper(owner), strings.ToUpper(arrayTypeName)).Scan(&cust.arrayTOID)
-			if err != nil {
-				return err
-			}
-		}
-		sqlText = `SELECT ATTR_NAME, ATTR_TYPE_NAME, LENGTH, ATTR_NO 
-					FROM ALL_TYPE_ATTRS 
-					WHERE UPPER(OWNER)=:1 AND UPPER(TYPE_NAME)=:2`
-		rows, err := conn.Query(sqlText, strings.ToUpper(owner), strings.ToUpper(typeName))
-		if err != nil {
-			return err
-		}
-		var (
-			attName     sql.NullString
-			attOrder    int64
-			attTypeName sql.NullString
-			length      sql.NullInt64
-		)
-		for rows.Next() {
-			err = rows.Scan(&attName, &attTypeName, &length, &attOrder)
-			if err != nil {
-				return err
-			}
-			for int(attOrder) > len(cust.attribs) {
-				cust.attribs = append(cust.attribs, ParameterInfo{
-					Direction: Input,
-					Flag:      3,
-				})
-			}
-			param := &cust.attribs[attOrder-1]
-			param.Name = attName.String
-			param.TypeName = attTypeName.String
-			switch strings.ToUpper(attTypeName.String) {
-			case "NUMBER":
-				param.DataType = NUMBER
-				param.MaxLen = converters.MAX_LEN_NUMBER
-			case "VARCHAR2":
-				param.DataType = NCHAR
-				param.CharsetForm = 1
-				param.ContFlag = 16
-				param.MaxCharLen = int(length.Int64)
-				param.CharsetID = driver.sStrConv.GetLangID()
-				param.MaxLen = int(length.Int64) * converters.MaxBytePerChar(param.CharsetID)
-			case "NVARCHAR2":
-				param.DataType = NCHAR
-				param.CharsetForm = 2
-				param.ContFlag = 16
-				param.MaxCharLen = int(length.Int64)
-				param.CharsetID = driver.nStrConv.GetLangID()
-				param.MaxLen = int(length.Int64) * converters.MaxBytePerChar(param.CharsetID)
-			case "TIMESTAMP":
-				fallthrough
-			case "DATE":
-				param.DataType = DATE
-				param.MaxLen = 11
-			case "RAW":
-				param.DataType = RAW
-				param.MaxLen = int(length.Int64)
-			case "BLOB":
-				param.DataType = OCIBlobLocator
-				param.MaxLen = int(length.Int64)
-			case "CLOB":
-				param.DataType = OCIClobLocator
-				param.CharsetForm = 1
-				param.ContFlag = 16
-				param.CharsetID = driver.sStrConv.GetLangID()
-				param.MaxCharLen = int(length.Int64)
-				param.MaxLen = int(length.Int64) * converters.MaxBytePerChar(param.CharsetID)
-			case "NCLOB":
-				param.DataType = OCIClobLocator
-				param.CharsetForm = 2
-				param.ContFlag = 16
-				param.CharsetID = driver.nStrConv.GetLangID()
-				param.MaxCharLen = int(length.Int64)
-				param.MaxLen = int(length.Int64) * converters.MaxBytePerChar(param.CharsetID)
-			default:
-				found := false
-				for name, value := range driver.cusTyp {
-					if name == strings.ToUpper(attTypeName.String) {
-						found = true
-						param.cusType = new(customType)
-						*param.cusType = value
-						param.ToID = value.toid
-						break
-					}
-					if value.arrayTypeName == strings.ToUpper(attTypeName.String) {
-						found = true
-						param.cusType = new(customType)
-						*param.cusType = value
-						param.ToID = value.toid
-						break
-					}
-				}
-				if !found {
-					return fmt.Errorf("unsupported attribute type: %s", attTypeName.String)
-				}
-			}
-		}
-		if len(cust.attribs) == 0 {
-			return fmt.Errorf("unknown or empty type: %s", typeName)
-		}
-		cust.loadFieldMap()
-		driver.mu.Lock()
-		defer driver.mu.Unlock()
-		driver.cusTyp[strings.ToUpper(typeName)] = cust
-		return nil
-	}
-	return errors.New("the driver used is not a go-ora driver type")
-}
-
 func (conn *Connection) dataTypeNegotiation() error {
 	tracer := conn.connOption.Tracer
 	var err error