Providing SQL statements

src/Client/Connection.hpp

@@ -158,6 +158,33 @@ class Connection
 	template <class T>
 	rid_t call(const std::string &func, const T &args);
 	rid_t ping();
+
+	/**
+	 * Execute the SQL statement contained in the 'statement' parameter.
+	 * @param statement statement, which should conform to the rules for SQL grammar
+	 * @param parameters tuple for placeholders in the statement
+	 * @retval request id
+	 */
+
+	template <class T>
+	rid_t execute(const std::string& statement, const T& parameters);
+
+	/**
+	 * Execute the SQL statement contained in the 'statement' parameter.
+	 * @param stmt_id the statement id obtained with prepare()
+	 * @param parameters tuple for placeholders in the statement
+	 * @retval request id
+	 */
+	template <class T>
+	rid_t execute(unsigned int stmt_id, const T& parameters);
+
+    /**
+    * Prepare the SQL statement contained in the 'statement' parameter.
+    * The syntax and requirements for Connection::prepare() are the same as for Connection::execute().
+    * @param statement statement, which should conform to the rules for SQL grammar
+    * @retval request id
+    */
+    rid_t prepare(const std::string& statement);
 
 	void setError(const std::string &msg, int errno_ = 0);
 	ConnectionError& getError();
@@ -581,6 +608,34 @@ decodeGreeting(Connection<BUFFER, NetProvider> &conn)
 }
 
 ////////////////////////////BOX-like interface functions////////////////////////
+template<class BUFFER, class NetProvider>
+template <class T>
+rid_t
+Connection<BUFFER, NetProvider>::execute(const std::string& statement, const T& parameters)
+{
+    impl->enc.encodeExecute(statement, parameters);
+    impl->connector.readyToSend(*this);
+    return RequestEncoder<BUFFER>::getSync();
+}
+
+template<class BUFFER, class NetProvider>
+template <class T>
+rid_t
+Connection<BUFFER, NetProvider>::execute(unsigned int stmt_id, const T& parameters)
+{
+    impl->enc.encodeExecute(stmt_id, parameters);
+    impl->connector.readyToSend(*this);
+    return RequestEncoder<BUFFER>::getSync();
+}
+
+template<class BUFFER, class NetProvider>
+rid_t
+Connection<BUFFER, NetProvider>::prepare(const std::string& statement)
+{
+    impl->enc.encodePrepare(statement);
+    impl->connector.readyToSend(*this);
+    return RequestEncoder<BUFFER>::getSync();
+}
 
 template<class BUFFER, class NetProvider>
 template <class T>

src/Client/IprotoConstants.hpp

@@ -102,6 +102,13 @@ namespace Iproto {
 		FIELD_SPAN = 5,
 	};
 
+	enum ColumnMap {
+		FIELD_NAME_MAX = 256,
+		FIELD_TYPE_NAME_MAX = 32,
+		COLLATION_MAX = 32,
+		SPAN_MAX = 256
+	};
+
 	enum Type {
 		OK = 0,
 		SELECT = 1,
@@ -135,6 +142,12 @@ namespace Iproto {
 		TYPE_ERROR = 1 << 15
 	};
 
+	/** Keys of IPROTO_SQL_INFO map. */
+	enum SqlInfoKey {
+		SQL_INFO_ROW_COUNT = 0x00,
+		SQL_INFO_AUTOINCREMENT_IDS = 0x01
+	};
+
 	enum ErrorStack {
 		ERROR_STACK = 0x00
 	};

src/Client/RequestEncoder.hpp

@@ -83,6 +83,11 @@ class RequestEncoder {
 			    uint32_t limit = UINT32_MAX, uint32_t offset = 0,
 			    IteratorType iterator = EQ);
 	template <class T>
+	size_t encodeExecute(const std::string& statement, const T& parameters);
+	template <class T>
+	size_t encodeExecute(unsigned int stmt_id, const T& parameters);
+	size_t encodePrepare(const std::string& statement);
+	template <class T>
 	size_t encodeCall(const std::string &func, const T &args);
 
 	/** Sync value is used as request id. */
@@ -236,6 +241,57 @@ RequestEncoder<BUFFER>::encodeSelect(const T &key,
 	return request_size + PREHEADER_SIZE;
 }
 
+template<class BUFFER>
+template <class T>
+size_t
+RequestEncoder<BUFFER>::encodeExecute(const std::string& statement, const T& parameters)
+{
+	iterator_t<BUFFER> request_start = m_Buf.end();
+	m_Buf.addBack('\xce');
+	m_Buf.addBack(uint32_t{0});
+	encodeHeader(Iproto::EXECUTE);
+	m_Enc.add(mpp::as_map(std::forward_as_tuple(
+		MPP_AS_CONST(Iproto::SQL_TEXT), statement,
+		MPP_AS_CONST(Iproto::SQL_BIND), parameters,
+		MPP_AS_CONST(Iproto::OPTIONS), std::make_tuple())));
+	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	m_Buf.set(request_start + 1, __builtin_bswap32(request_size));
+	return request_size + PREHEADER_SIZE;
+}
+
+template<class BUFFER>
+template <class T>
+size_t
+RequestEncoder<BUFFER>::encodeExecute(unsigned int stmt_id, const T& parameters)
+{
+	iterator_t<BUFFER> request_start = m_Buf.end();
+	m_Buf.addBack('\xce');
+	m_Buf.addBack(uint32_t{0});
+	encodeHeader(Iproto::EXECUTE);
+	m_Enc.add(mpp::as_map(std::forward_as_tuple(
+		MPP_AS_CONST(Iproto::STMT_ID), stmt_id,
+		MPP_AS_CONST(Iproto::SQL_BIND), parameters,
+		MPP_AS_CONST(Iproto::OPTIONS), std::make_tuple())));
+	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	m_Buf.set(request_start + 1, __builtin_bswap32(request_size));
+	return request_size + PREHEADER_SIZE;
+}
+
+template<class BUFFER>
+size_t
+RequestEncoder<BUFFER>::encodePrepare(const std::string& statement)
+{
+	iterator_t<BUFFER> request_start = m_Buf.end();
+	m_Buf.addBack('\xce');
+	m_Buf.addBack(uint32_t{0});
+	encodeHeader(Iproto::PREPARE);
+	m_Enc.add(mpp::as_map(std::forward_as_tuple(
+		MPP_AS_CONST(Iproto::SQL_TEXT), statement)));
+	uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
+	m_Buf.set(request_start + 1, __builtin_bswap32(request_size));
+	return request_size + PREHEADER_SIZE;
+}
+
 template<class BUFFER>
 template <class T>
 size_t