Merge pull request #241 from v-kigos/PHP-7.0-Linux-pooling

PDO and sqlsrv Linux connection pooling

source/pdo_sqlsrv/config.m4

@@ -57,6 +57,7 @@ if test "$PHP_PDO_SQLSRV" != "no"; then
   PHP_REQUIRE_CXX()
   PHP_ADD_LIBRARY(stdc++, 1, PDO_SQLSRV_SHARED_LIBADD)
   PHP_ADD_LIBRARY(odbc, 1, PDO_SQLSRV_SHARED_LIBADD)
+  PHP_ADD_LIBRARY(odbcinst, 1, PDO_SQLSRV_SHARED_LIBADD)
   AC_DEFINE(HAVE_PDO_SQLSRV, 1, [ ])
   PHP_ADD_INCLUDE([$pdo_sqlsrv_inc_path])
   PHP_NEW_EXTENSION(pdo_sqlsrv, $pdo_sqlsrv_src_class $shared_src_class, $ext_shared,,-I$pdo_cv_inc_path -std=c++11)

source/pdo_sqlsrv/pdo_dbh.cpp

@@ -1174,8 +1174,19 @@ char * pdo_sqlsrv_dbh_last_id( pdo_dbh_t *dbh, const char *name, _Out_ size_t* l
                           NULL /*valid_stmt_opts*/, pdo_sqlsrv_handle_stmt_error, &temp_stmt TSRMLS_CC );
         driver_stmt->set_func( __FUNCTION__ );
 
-        // execute the last insert id query
-        core::SQLExecDirect( driver_stmt, last_insert_id_query TSRMLS_CC );
+
+        sqlsrv_malloc_auto_ptr<SQLWCHAR> wsql_string;
+        unsigned int wsql_len;
+        wsql_string = utf16_string_from_mbcs_string( SQLSRV_ENCODING_CHAR, reinterpret_cast<const char*>( last_insert_id_query ),
+                                                         strlen(last_insert_id_query), &wsql_len );
+
+        CHECK_CUSTOM_ERROR( wsql_string == 0, driver_stmt, SQLSRV_ERROR_QUERY_STRING_ENCODING_TRANSLATE,
+                                get_last_error_message() ) {
+                throw core::CoreException();
+            }
+
+        // execute the last insert id query        
+        core::SQLExecDirectW( driver_stmt, wsql_string TSRMLS_CC );
 
         core::SQLFetchScroll( driver_stmt, SQL_FETCH_NEXT, 0 TSRMLS_CC );
         SQLRETURN r = core::SQLGetData( driver_stmt, 1, SQL_C_CHAR, id_str, LAST_INSERT_ID_BUFF_LEN, 

source/shared/core_conn.cpp

@@ -32,6 +32,7 @@
 
 #ifdef __linux__
 #include <sys/utsname.h>
+#include <odbcinst.h>
 #endif
 
 // *** internal variables and constants ***
@@ -92,7 +93,6 @@ sqlsrv_conn* core_sqlsrv_connect( sqlsrv_context& henv_cp, sqlsrv_context& henv_
                                   const char* server, const char* uid, const char* pwd, 
                                   HashTable* options_ht, error_callback err, const connection_option valid_conn_opts[], 
 				                  void* driver, const char* driver_func TSRMLS_DC )
-
 {
     SQLRETURN r;
     std::string conn_str;
@@ -101,10 +101,27 @@ sqlsrv_conn* core_sqlsrv_connect( sqlsrv_context& henv_cp, sqlsrv_context& henv_
     sqlsrv_malloc_auto_ptr<SQLWCHAR> wconn_string;
     unsigned int wconn_len = 0;
 
-    try {
-
+#ifndef __linux__
     sqlsrv_context* henv = &henv_cp;   // by default use the connection pooling henv
+#else
+    sqlsrv_context* henv = &henv_ncp;  // by default do not use the connection pooling henv
+#endif
+
+    try {
+    // Due to the limitations on connection pooling in unixODBC 2.3.1 driver manager, we do not concider 
+    // the connection string attributes to set (enable/disable) connection pooling. 
+    // Instead, MSPHPSQL connection pooling is set according to the ODBCINST.INI file in [ODBC] section.
+
+#ifdef __linux__
+    char pooling_string[ 128 ] = {0};
+    SQLGetPrivateProfileString( "ODBC", "Pooling", "0", pooling_string, sizeof( pooling_string ), "ODBCINST.INI" );
 
+		if ( pooling_string[ 0 ] == '1' || toupper( pooling_string[ 0 ] ) == 'Y' ||
+			 ( toupper( pooling_string[ 0 ] ) == 'O' && toupper( pooling_string[ 1 ] ) == 'N' ))
+		{
+				henv = &henv_cp;
+		}
+#else
     // check the connection pooling setting to determine which henv to use to allocate the connection handle
     // we do this earlier because we have to allocate the connection handle prior to setting attributes on
     // it in build_connection_string_and_set_conn_attr.
@@ -123,6 +140,7 @@ sqlsrv_conn* core_sqlsrv_connect( sqlsrv_context& henv_cp, sqlsrv_context& henv_
             }
         }
     }
+#endif
 
     SQLHANDLE temp_conn_h;
     core::SQLAllocHandle( SQL_HANDLE_DBC, *henv, &temp_conn_h TSRMLS_CC );
@@ -149,10 +167,19 @@ sqlsrv_conn* core_sqlsrv_connect( sqlsrv_context& henv_cp, sqlsrv_context& henv_
 
     SQLSMALLINT output_conn_size;
 #ifdef __linux__
-    r = SQLDriverConnectW( conn->handle(), NULL, reinterpret_cast<SQLWCHAR*>( wconn_string.get() ),
+	// unixODBC 2.3.1 requires a non-wide SQLDriverConnect call while pooling enabled.
+	// connection handle has been allocated using henv_cp, means pooling enabled in a PHP script
+	if ( henv == &henv_cp )
+	{
+		r = SQLDriverConnect( conn->handle(), NULL, (SQLCHAR*)conn_str.c_str(),
+                           SQL_NTS, NULL, 0, &output_conn_size, SQL_DRIVER_NOPROMPT );
+	}
+	else
+	{
+		r = SQLDriverConnectW( conn->handle(), NULL, reinterpret_cast<SQLWCHAR*>( wconn_string.get() ),
                            static_cast<SQLSMALLINT>( wconn_len ), NULL, 
                            0, &output_conn_size, SQL_DRIVER_NOPROMPT );
-
+    }
 #else
 	r = SQLDriverConnectW( conn->handle(), NULL, reinterpret_cast<SQLWCHAR*>( wconn_string.get() ),
                            static_cast<SQLSMALLINT>( wconn_len ), NULL, 
@@ -193,8 +220,18 @@ sqlsrv_conn* core_sqlsrv_connect( sqlsrv_context& henv_cp, sqlsrv_context& henv_
 
     // determine the version of the server we're connected to.  The server version is left in the 
     // connection upon return.
+    //
+    // unixODBC 2.3.1:
+    // SQLGetInfo works when r =  SQL_SUCCESS_WITH_INFO (non-pooled connection)
+    // but fails if the connection is using a pool, i.e. r= SQL_SUCCESS.
+    // Thus, in Linux, we don't call determine_server_version() for a connection that uses pool.
+#ifdef __linux__
+	if ( r == SQL_SUCCESS_WITH_INFO ) {
+#endif
     determine_server_version( conn TSRMLS_CC );
-
+#ifdef __linux__
+	}
+#endif
     }
     catch( std::bad_alloc& ) {
         memset( const_cast<char*>( conn_str.c_str()), 0, conn_str.size() );
@@ -427,12 +464,13 @@ void core_sqlsrv_get_server_info( sqlsrv_conn* conn, _Out_ zval *server_info TSR
         sqlsrv_malloc_auto_ptr<char> buffer;
         SQLSMALLINT buffer_len = 0;
 
-        // initialize the array
-        core::sqlsrv_array_init( *conn, server_info TSRMLS_CC );
-
         // Get the database name
         buffer = static_cast<char*>( sqlsrv_malloc( INFO_BUFFER_LEN ));
         core::SQLGetInfo( conn, SQL_DATABASE_NAME, buffer, INFO_BUFFER_LEN, &buffer_len TSRMLS_CC );
+
+        // initialize the array
+        core::sqlsrv_array_init( *conn, server_info TSRMLS_CC );
+
         core::sqlsrv_add_assoc_string( *conn, server_info, "CurrentDatabase", buffer, 0 /*duplicate*/ TSRMLS_CC );
         buffer.transferred();
 
@@ -465,13 +503,14 @@ void core_sqlsrv_get_client_info( sqlsrv_conn* conn, _Out_ zval *client_info TSR
 
         sqlsrv_malloc_auto_ptr<char> buffer;
         SQLSMALLINT buffer_len = 0;
-
-        // initialize the array
-        core::sqlsrv_array_init( *conn, client_info TSRMLS_CC );
-
+
         // Get the ODBC driver's dll name
         buffer = static_cast<char*>( sqlsrv_malloc( INFO_BUFFER_LEN ));
         core::SQLGetInfo( conn, SQL_DRIVER_NAME, buffer, INFO_BUFFER_LEN, &buffer_len TSRMLS_CC );
+
+        // initialize the array
+        core::sqlsrv_array_init( *conn, client_info TSRMLS_CC );
+
 #ifdef __linux__
         core::sqlsrv_add_assoc_string( *conn, client_info, "DriverName", buffer, 0 /*duplicate*/ TSRMLS_CC );
 #else

source/shared/core_results.cpp

@@ -439,8 +439,8 @@ sqlsrv_buffered_result_set::sqlsrv_buffered_result_set( sqlsrv_stmt* stmt TSRMLS
     // get the meta data and calculate the size of a row buffer
     SQLULEN offset = null_bytes;
     for( SQLSMALLINT i = 0; i < col_count; ++i ) {
-
-        core::SQLDescribeCol( stmt, i + 1, NULL, 0, NULL, &meta[i].type, &meta[i].length, &meta[i].scale, NULL TSRMLS_CC );
+				
+        core::SQLDescribeColW( stmt, i + 1, NULL, 0, NULL, &meta[i].type, &meta[i].length, &meta[i].scale, NULL TSRMLS_CC );
 
         offset = align_to<sizeof(SQLPOINTER)>( offset );
         meta[i].offset = offset;
@@ -452,7 +452,7 @@ sqlsrv_buffered_result_set::sqlsrv_buffered_result_set( sqlsrv_stmt* stmt TSRMLS
             case SQL_DECIMAL:
             case SQL_GUID:
             case SQL_NUMERIC:
-                core::SQLColAttribute( stmt, i + 1, SQL_DESC_DISPLAY_SIZE, NULL, 0, NULL,
+                core::SQLColAttributeW( stmt, i + 1, SQL_DESC_DISPLAY_SIZE, NULL, 0, NULL,
                                        reinterpret_cast<SQLLEN*>( &meta[i].length ) TSRMLS_CC );
                 meta[i].length += sizeof( char ) + sizeof( SQLULEN ); // null terminator space
                 offset += meta[i].length;
@@ -518,7 +518,7 @@ sqlsrv_buffered_result_set::sqlsrv_buffered_result_set( sqlsrv_stmt* stmt TSRMLS
             case SQL_SS_TIME2:
             case SQL_SS_TIMESTAMPOFFSET:
             case SQL_TYPE_TIMESTAMP:
-                core::SQLColAttribute( stmt, i + 1, SQL_DESC_DISPLAY_SIZE, NULL, 0, NULL, 
+                core::SQLColAttributeW( stmt, i + 1, SQL_DESC_DISPLAY_SIZE, NULL, 0, NULL, 
                                        reinterpret_cast<SQLLEN*>( &meta[i].length ) TSRMLS_CC );
                 meta[i].length += sizeof(char) + sizeof( SQLULEN );  // null terminator space
                 offset += meta[i].length;

source/shared/core_stmt.cpp

@@ -815,11 +815,11 @@ field_meta_data* core_sqlsrv_field_metadata( sqlsrv_stmt* stmt, SQLSMALLINT coln
     SQLLEN field_name_len = 0;
 
     meta_data = new ( sqlsrv_malloc( sizeof( field_meta_data ))) field_meta_data();
-    field_name_temp = static_cast<SQLWCHAR*>( sqlsrv_malloc( SS_MAXCOLNAMELEN * 2 + 1 ));
+    field_name_temp = static_cast<SQLWCHAR*>( sqlsrv_malloc( ( SS_MAXCOLNAMELEN + 1 ) * sizeof( SQLWCHAR ) ));
     SQLSRV_ENCODING encoding = ( (stmt->encoding() == SQLSRV_ENCODING_DEFAULT ) ? stmt->conn->encoding() :
         stmt->encoding());
 	try{
-        core::SQLDescribeColW( stmt, colno + 1, field_name_temp,  SS_MAXCOLNAMELEN * 2 + 1 , &field_len_temp,
+        core::SQLDescribeColW( stmt, colno + 1, field_name_temp, SS_MAXCOLNAMELEN, &field_len_temp,
             &( meta_data->field_type ), & ( meta_data->field_size ), & ( meta_data->field_scale ),
             &( meta_data->field_is_nullable ) TSRMLS_CC );
 	}
@@ -946,10 +946,10 @@ void core_sqlsrv_get_field( sqlsrv_stmt* stmt, SQLUSMALLINT field_index, sqlsrv_
 		if( sqlsrv_php_type.typeinfo.type == SQLSRV_PHPTYPE_INVALID ) {
 
 			// Get the SQL type of the field.
-			core::SQLColAttribute( stmt, field_index + 1, SQL_DESC_CONCISE_TYPE, NULL, 0, NULL, &sql_field_type TSRMLS_CC );
+			core::SQLColAttributeW( stmt, field_index + 1, SQL_DESC_CONCISE_TYPE, NULL, 0, NULL, &sql_field_type TSRMLS_CC );
 
 			// Get the length of the field.
-			core::SQLColAttribute( stmt, field_index + 1, SQL_DESC_LENGTH, NULL, 0, NULL, &sql_field_len TSRMLS_CC );
+			core::SQLColAttributeW( stmt, field_index + 1, SQL_DESC_LENGTH, NULL, 0, NULL, &sql_field_len TSRMLS_CC );
 
 			// Get the corresponding php type from the sql type.
 			sqlsrv_php_type = stmt->sql_type_to_php_type( static_cast<SQLINTEGER>( sql_field_type ), static_cast<SQLUINTEGER>( sql_field_len ), prefer_string );
@@ -1433,7 +1433,8 @@ void calc_string_size( sqlsrv_stmt* stmt, SQLUSMALLINT field_index, SQLLEN sql_t
             case SQL_SS_TIME2:
             case SQL_SS_TIMESTAMPOFFSET:
             {
-                core::SQLColAttribute( stmt, field_index + 1, SQL_DESC_DISPLAY_SIZE, NULL, 0, NULL, &size TSRMLS_CC );
+                // unixODBC 2.3.1 requires wide calls to support pooling
+                core::SQLColAttributeW( stmt, field_index + 1, SQL_DESC_DISPLAY_SIZE, NULL, 0, NULL, &size TSRMLS_CC );
                 break;
             }   
 
@@ -1442,7 +1443,8 @@ void calc_string_size( sqlsrv_stmt* stmt, SQLUSMALLINT field_index, SQLLEN sql_t
             case SQL_WCHAR:
             case SQL_WVARCHAR: 
             {
-                core::SQLColAttribute( stmt, field_index + 1, SQL_DESC_OCTET_LENGTH, NULL, 0, NULL, &size TSRMLS_CC );
+                // unixODBC 2.3.1 requires wide calls to support pooling
+                core::SQLColAttributeW( stmt, field_index + 1, SQL_DESC_OCTET_LENGTH, NULL, 0, NULL, &size TSRMLS_CC );
                 break;
             }
 
@@ -1634,7 +1636,7 @@ void core_get_field_common( _Inout_ sqlsrv_stmt* stmt, SQLUSMALLINT field_index,
 			sqlsrv_stream* ss = NULL;
 			SQLLEN sql_type;
 
-			SQLRETURN r = SQLColAttribute( stmt->handle(), field_index + 1, SQL_DESC_TYPE, NULL, 0, NULL, &sql_type );
+			SQLRETURN r = SQLColAttributeW( stmt->handle(), field_index + 1, SQL_DESC_TYPE, NULL, 0, NULL, &sql_type );
 			CHECK_SQL_ERROR_OR_WARNING( r, stmt ) {
 				throw core::CoreException();
 			}
@@ -2142,8 +2144,8 @@ void get_field_as_string( sqlsrv_stmt* stmt, SQLUSMALLINT field_index, sqlsrv_ph
 			break;
 		}
 
-		// Get the SQL type of the field.
-		core::SQLColAttribute( stmt, field_index + 1, SQL_DESC_CONCISE_TYPE, NULL, 0, NULL, &sql_field_type TSRMLS_CC );
+		// Get the SQL type of the field. unixODBC 2.3.1 requires wide calls to support pooling
+		core::SQLColAttributeW( stmt, field_index + 1, SQL_DESC_CONCISE_TYPE, NULL, 0, NULL, &sql_field_type TSRMLS_CC );
 
 		// Calculate the field size.
 		calc_string_size( stmt, field_index, sql_field_type, sql_display_size TSRMLS_CC );
@@ -2153,6 +2155,8 @@ void get_field_as_string( sqlsrv_stmt* stmt, SQLUSMALLINT field_index, sqlsrv_ph
 			sql_display_size == INT_MAX >> 1 || sql_display_size == UINT_MAX - 1 ) {
 
 			field_len_temp = INITIAL_FIELD_STRING_LEN;
+            SQLLEN initiallen = field_len_temp + extra;
+
 
 			field_value_temp = static_cast<char*>( sqlsrv_malloc( field_len_temp + extra + 1 ));
 
@@ -2176,7 +2180,13 @@ void get_field_as_string( sqlsrv_stmt* stmt, SQLUSMALLINT field_index, sqlsrv_ph
 
 				stmt->current_results->get_diag_field( 1, SQL_DIAG_SQLSTATE, state, SQL_SQLSTATE_BUFSIZE, &len TSRMLS_CC );
 
-				if( is_truncated_warning( state )) {
+                // with Linux connection pooling may not get a truncated warning back but the actual field_len_temp 
+                // can be greater than the initallen value.
+#ifdef __linux__
+                if( is_truncated_warning( state ) || initiallen < field_len_temp) {
+#else
+                if( is_truncated_warning( state ) ) {
+#endif 
 
 					SQLLEN dummy_field_len;
 
@@ -2317,7 +2327,17 @@ void get_field_as_string( sqlsrv_stmt* stmt, SQLUSMALLINT field_index, sqlsrv_ph
 		// runtime checks to see if a string is null terminated and issues a warning about it if running in debug mode.
 		// SQL_C_BINARY fields don't return a NULL terminator, so we allocate an extra byte on each field and use the ternary
 		// operator to set add 1 to fill the null terminator
-		field_value_temp[field_len_temp] = '\0';
+
+        // with unixODBC connection pooling sometimes field_len_temp can be SQL_NO_DATA.
+        // In that cause do not set null terminator and set length to 0.
+        if ( field_len_temp > 0 )
+        {          
+            field_value_temp[field_len_temp] = '\0';
+        }
+        else
+        {
+            *field_len = 0;        
+        }
 	}
 
 	catch( core::CoreException& ) {

source/shared/core_stream.cpp

@@ -116,7 +116,13 @@ size_t sqlsrv_stream_read( php_stream* stream, _Out_writes_bytes_(count) char* b
                                "did not occur." );
             }
 
+        // with unixODBC connection pooling enabled the truncated state may not be returned so check the actual length read
+        // with buffer length.
+        #ifdef __linux__
+            if( is_truncated_warning( state ) || count < read) {
+        #else
             if( is_truncated_warning( state ) ) {
+        #endif
                 switch( c_type ) {
 
                     // As per SQLGetData documentation, if the length of character data exceeds the BufferLength, 

source/sqlsrv/config.m4

@@ -33,6 +33,7 @@ if test "$PHP_SQLSRV" != "no"; then
   PHP_REQUIRE_CXX()
   PHP_ADD_LIBRARY(stdc++, 1, SQLSRV_SHARED_LIBADD)
   PHP_ADD_LIBRARY(odbc, 1, SQLSRV_SHARED_LIBADD)
+  PHP_ADD_LIBRARY(odbcinst, 1, SQLSRV_SHARED_LIBADD)
   PHP_SUBST(SQLSRV_SHARED_LIBADD)
   AC_DEFINE(HAVE_SQLSRV, 1, [ ])
   PHP_ADD_INCLUDE([$sqlsrv_inc_path])