[to sqaush]

Author: vr009

connection_pool/connection_pool.go

@@ -314,18 +314,6 @@ func (connPool *ConnectionPool) Execute(expr string, args interface{}, userMode
 	return conn.Execute(expr, args)
 }
 
-// Prepare sends a sql statement to prepare.
-//
-// Since 1.7.0
-func (connPool *ConnectionPool) Prepare(expr string, userMode Mode) (stmt *tarantool.PreparedStatement, err error) {
-	conn, err := connPool.getNextConnection(userMode)
-	if err != nil {
-		return nil, err
-	}
-
-	return conn.Prepare(expr)
-}
-
 // GetTyped performs select (with limit = 1 and offset = 0)
 // to box space and fills typed result.
 func (connPool *ConnectionPool) GetTyped(space, index interface{}, key interface{}, result interface{}, userMode ...Mode) (err error) {
@@ -572,18 +560,6 @@ func (connPool *ConnectionPool) ExecuteAsync(expr string, args interface{}, user
 	return conn.ExecuteAsync(expr, args)
 }
 
-// PrepareAsync sends a sql statement to prepare and returns PreparedStatement object.
-//
-// Since 1.7.0
-func (connPool *ConnectionPool) PrepareAsync(expr string, userMode Mode) *tarantool.PreparedStatement {
-	conn, err := connPool.getNextConnection(userMode)
-	if err != nil {
-		return nil
-	}
-
-	return conn.PrepareAsync(expr)
-}
-
 // Do sends the request and returns a response.
 func (connPool *ConnectionPool) Do(req tarantool.Request, userMode Mode) (*tarantool.Response, error) {
 	conn, err := connPool.getNextConnection(userMode)

connector.go

@@ -19,7 +19,6 @@ type Connector interface {
 	Call17(functionName string, args interface{}) (resp *Response, err error)
 	Eval(expr string, args interface{}) (resp *Response, err error)
 	Execute(expr string, args interface{}) (resp *Response, err error)
-	Prepare(expr string) (stmt *PreparedStatement, err error)
 
 	GetTyped(space, index interface{}, key interface{}, result interface{}) (err error)
 	SelectTyped(space, index interface{}, offset, limit, iterator uint32, key interface{}, result interface{}) (err error)
@@ -44,7 +43,6 @@ type Connector interface {
 	Call17Async(functionName string, args interface{}) *Future
 	EvalAsync(expr string, args interface{}) *Future
 	ExecuteAsync(expr string, args interface{}) *Future
-	PrepareAsync(expr string) *PreparedStatement
 
 	Do(req Request) (resp *Response, err error)
 	DoTyped(req Request, result interface{}) (err error)

example_test.go

@@ -653,12 +653,13 @@ func ExampleConnection_Execute() {
 }
 
 // To use prepared statements to query a tarantool instance, call Prepare.
-func ExampleConnection_Prepare() {
+func ExampleConnection_Do() {
 	// Tarantool supports SQL since version 2.0.0
 	isLess, _ := test_helpers.IsTarantoolVersionLess(2, 0, 0)
 	if isLess {
 		return
 	}
+
 	server := "127.0.0.1:3013"
 	opts := tarantool.Opts{
 		Timeout:       500 * time.Millisecond,
@@ -672,27 +673,30 @@ func ExampleConnection_Prepare() {
 		fmt.Printf("Failed to connect: %s", err.Error())
 	}
 
-	// pass a query to prepare
-	stmtResp, err := client.Prepare("SELECT id FROM SQL_TEST WHERE id=? AND name=?")
-	fmt.Println("Prepare")
-	fmt.Println("Error", err)
-	fmt.Println("Statement ID", stmtResp.StatementID)
+	prepareReq := tarantool.NewPrepareRequest(selectPosQuery2)
+	resp, err := client.Do(prepareReq)
+	if err != nil {
+		fmt.Printf("failed to prepare request: %s", err)
+	}
 
-	// pass the id of the statement to Execute
-	resp, err := stmtResp.Execute([]interface{}{1, "test_1"})
-	fmt.Println("Execute")
-	fmt.Println("Error", err)
-	fmt.Println("Code", resp.Code)
-	fmt.Println("Data", resp.Data)
-	fmt.Println("MetaData", resp.MetaData)
-	fmt.Println("SQL Info", resp.SQLInfo)
+	stmt := tarantool.NewPreparedStatement(client, resp)
+	args := []interface{}{1, "test"}
 
-	// use the same object for execute with other arguments
-	resp, err = stmtResp.Execute([]interface{}{2, "test_2"})
-	fmt.Println("Execute")
-	fmt.Println("Error", err)
-	fmt.Println("Code", resp.Code)
-	fmt.Println("Data", resp.Data)
-	fmt.Println("MetaData", resp.MetaData)
-	fmt.Println("SQL Info", resp.SQLInfo)
+	execPreparedReq := tarantool.NewPreparedExecuteRequest(stmt)
+	res2, err := client.Do(execPreparedReq.Args(args))
+	if err != nil {
+		fmt.Printf("failed to execute with prepared statement: %s", err)
+	}
+	if len(res2.MetaData) != len(args) {
+		fmt.Printf("the length of slice with meta data is wrong: %d", len(res2.MetaData))
+	}
+	if res2.Code != 0 {
+		fmt.Printf("Failed to execute: code error %d", res2.Code)
+	}
+
+	unprepareReq := tarantool.NewUnprepareRequest(stmt)
+	_, err = client.Do(unprepareReq)
+	if err != nil {
+		fmt.Printf("failed to undo the statement: %s", err)
+	}
 }

multi/multi.go

@@ -356,15 +356,6 @@ func (connMulti *ConnectionMulti) Execute(expr string, args interface{}) (resp *
 	return connMulti.getCurrentConnection().Execute(expr, args)
 }
 
-// Prepare sends a sql statement to prepare.
-//
-// Returns a PreparedStatement object for the current connection.
-//
-// Since 1.7.0
-func (connMulti *ConnectionMulti) Prepare(expr string) (resp *tarantool.PreparedStatement, err error) {
-	return connMulti.getCurrentConnection().Prepare(expr)
-}
-
 // GetTyped performs select (with limit = 1 and offset = 0) to box space and
 // fills typed result.
 func (connMulti *ConnectionMulti) GetTyped(space, index interface{}, key interface{}, result interface{}) (err error) {
@@ -503,13 +494,6 @@ func (connMulti *ConnectionMulti) ExecuteAsync(expr string, args interface{}) *t
 	return connMulti.getCurrentConnection().ExecuteAsync(expr, args)
 }
 
-// PrepareAsync passes a sql statement to prepare.
-//
-// Since 1.7.0
-func (connMulti *ConnectionMulti) PrepareAsync(expr string) *tarantool.PreparedStatement {
-	return connMulti.getCurrentConnection().PrepareAsync(expr)
-}
-
 // Do sends the request and returns a response.
 func (connMulti *ConnectionMulti) Do(req tarantool.Request) (*tarantool.Response, error) {
 	return connMulti.getCurrentConnection().Do(req)

request.go

@@ -210,16 +210,6 @@ func (conn *Connection) Execute(expr string, args interface{}) (resp *Response,
 	return conn.ExecuteAsync(expr, args).Get()
 }
 
-// Prepare sends a sql statement to prepare.
-//
-// It is equal to conn.PrepareAsync(expr).Get().
-// Since 1.7.0
-func (conn *Connection) Prepare(expr string) (stmt *PreparedStatement, err error) {
-	stmt = conn.PrepareAsync(expr)
-	err = stmt.wait()
-	return stmt, err
-}
-
 // single used for conn.GetTyped for decode one tuple.
 type single struct {
 	res   interface{}
@@ -419,16 +409,6 @@ func (conn *Connection) ExecuteAsync(expr string, args interface{}) *Future {
 	return conn.DoAsync(req)
 }
 
-// PrepareAsync sends a sql statement to prepare and returns PreparedStatement object.
-//
-// Since 1.7.0
-func (conn *Connection) PrepareAsync(expr string) *PreparedStatement {
-	req := newPrepareRequest(expr)
-	fut := conn.DoAsync(req)
-	stmt := newPreparedStatement(fut, conn)
-	return stmt
-}
-
 type PreparedStatementID uint64
 
 // PreparedStatement is a type for handling prepared statements
@@ -439,56 +419,15 @@ type PreparedStatement struct {
 	MetaData    []ColumnMetaData
 	ParamCount  uint64
 	conn        *Connection
-	fut         *Future
 }
 
-func newPreparedStatement(fut *Future, conn *Connection) *PreparedStatement {
+func NewPreparedStatement(conn *Connection, resp *Response) *PreparedStatement {
 	stmt := new(PreparedStatement)
-	stmt.fut = fut
 	stmt.conn = conn
-	return stmt
-}
-
-// wait until the prepared statement is ready and fill the statement object
-func (stmt *PreparedStatement) wait() error {
-	resp, err := stmt.fut.Get()
-	stmt.StatementID = PreparedStatementID(resp.StmtID)
-	stmt.MetaData = resp.MetaData
 	stmt.ParamCount = resp.BindCount
-	return err
-}
-
-// UnprepareAsync sends an undo request and returns Future
-func (stmt *PreparedStatement) UnprepareAsync() *Future {
-	err := stmt.wait()
-	if err != nil {
-		return NewErrorFuture(err)
-	}
-	req := newUnprepareRequest(*stmt)
-	fut := stmt.conn.DoAsync(req)
-	return fut
-}
-
-// Unprepare undo the prepared statement
-func (stmt *PreparedStatement) Unprepare() (resp *Response, err error) {
-	return stmt.UnprepareAsync().Get()
-}
-
-// ExecuteAsync sends the prepared SQL statement for execution and returns Future
-func (stmt *PreparedStatement) ExecuteAsync(args interface{}) *Future {
-	err := stmt.wait()
-	if err != nil {
-		return NewErrorFuture(err)
-	}
-	req := newPreparedExecuteRequest(*stmt)
-	req.Args(args)
-	fut := stmt.conn.DoAsync(req)
-	return fut
-}
-
-// Execute sends the prepared SQL statement for execution
-func (stmt *PreparedStatement) Execute(args interface{}) (resp *Response, err error) {
-	return stmt.ExecuteAsync(args).Get()
+	stmt.MetaData = resp.MetaData
+	stmt.StatementID = PreparedStatementID(resp.StmtID)
+	return stmt
 }
 
 // KeyValueBind is a type for encoding named SQL parameters
@@ -1084,62 +1023,62 @@ func (req *ExecuteRequest) Body(res SchemaResolver, enc *msgpack.Encoder) error
 	return fillExecute(enc, req.expr, req.args)
 }
 
-type prepareRequest struct {
+type PrepareRequest struct {
 	baseRequest
 	expr string
 }
 
-// newPrepareRequest returns a new empty prepareRequest.
-func newPrepareRequest(expr string) *prepareRequest {
-	req := new(prepareRequest)
+// NewPrepareRequest returns a new empty PrepareRequest.
+func NewPrepareRequest(expr string) *PrepareRequest {
+	req := new(PrepareRequest)
 	req.requestCode = PrepareRequestCode
 	req.expr = expr
 	return req
 }
 
 // Body fills an encoder with the execute request body.
-func (req *prepareRequest) Body(res SchemaResolver, enc *msgpack.Encoder) error {
+func (req *PrepareRequest) Body(res SchemaResolver, enc *msgpack.Encoder) error {
 	return fillPrepare(enc, req.expr)
 }
 
-type unprepareRequest struct {
+type UnprepareRequest struct {
 	baseRequest
-	stmt PreparedStatement
+	stmt *PreparedStatement
 }
 
-// newUnprepareRequest returns a new empty unprepareRequest.
-func newUnprepareRequest(stmt PreparedStatement) *unprepareRequest {
-	req := new(unprepareRequest)
+// NewUnprepareRequest returns a new empty UnprepareRequest.
+func NewUnprepareRequest(stmt *PreparedStatement) *UnprepareRequest {
+	req := new(UnprepareRequest)
 	req.requestCode = PrepareRequestCode
 	req.stmt = stmt
 	return req
 }
 
 // Body fills an encoder with the execute request body.
-func (req *unprepareRequest) Body(res SchemaResolver, enc *msgpack.Encoder) error {
-	return fillUnprepare(enc, req.stmt)
+func (req *UnprepareRequest) Body(res SchemaResolver, enc *msgpack.Encoder) error {
+	return fillUnprepare(enc, *req.stmt)
 }
 
-type preparedExecuteRequest struct {
+type PreparedExecuteRequest struct {
 	baseRequest
-	stmt PreparedStatement
+	stmt *PreparedStatement
 	args interface{}
 }
 
-// newPreparedExecuteRequest returns a new empty preparedExecuteRequest.
-func newPreparedExecuteRequest(stmt PreparedStatement) *preparedExecuteRequest {
-	req := new(preparedExecuteRequest)
+// NewPreparedExecuteRequest returns a new empty preparedExecuteRequest.
+func NewPreparedExecuteRequest(stmt *PreparedStatement) *PreparedExecuteRequest {
+	req := new(PreparedExecuteRequest)
 	req.requestCode = ExecuteRequestCode
 	req.stmt = stmt
 	return req
 }
 
-func (req *preparedExecuteRequest) Args(args interface{}) *preparedExecuteRequest {
+func (req *PreparedExecuteRequest) Args(args interface{}) *PreparedExecuteRequest {
 	req.args = args
 	return req
 }
 
 // Body fills an encoder with the execute request body.
-func (req *preparedExecuteRequest) Body(res SchemaResolver, enc *msgpack.Encoder) error {
-	return fillPreparedExecute(enc, req.stmt, req.args)
+func (req *PreparedExecuteRequest) Body(res SchemaResolver, enc *msgpack.Encoder) error {
+	return fillPreparedExecute(enc, *req.stmt, req.args)
 }