dprevot/php-sqlsrv
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Removed wrappers for Zend APIs (#1161)

Browse source
This commit is contained in:
Jenny Tam 2020-07-23 13:46:25 -07:00 committed by GitHub
parent bba1f18f0f
commit 460d9aa2df
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 107 additions and 287 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
source/pdo_sqlsrv/pdo_dbh.cpp
View file

@ -1230,8 +1230,7 @@ int pdo_sqlsrv_dbh_get_attr( _Inout_ pdo_dbh_t *dbh, _In_ zend_long attr, _Inout
//Declarations below eliminate compiler warnings about string constant to char* conversions //Declarations below eliminate compiler warnings about string constant to char* conversions
const char* extver = "ExtensionVer"; const char* extver = "ExtensionVer";
std::string filever = VER_FILEVERSION_STR; std::string filever = VER_FILEVERSION_STR;
core::sqlsrv_add_assoc_string( *driver_dbh, return_value, extver, &filever[0], 1 /*duplicate*/ add_assoc_string(return_value, extver, &filever[0]);
);
break; break;
} }

11
source/pdo_sqlsrv/pdo_init.cpp
View file

@ -279,10 +279,7 @@ namespace {
zend_class_entry* zend_class = php_pdo_get_dbh_ce(); zend_class_entry* zend_class = php_pdo_get_dbh_ce();
SQLSRV_ASSERT( zend_class != NULL, "REGISTER_PDO_SQLSRV_CLASS_CONST_LONG: php_pdo_get_dbh_ce failed"); SQLSRV_ASSERT( zend_class != NULL, "REGISTER_PDO_SQLSRV_CLASS_CONST_LONG: php_pdo_get_dbh_ce failed");
int zr = zend_declare_class_constant_long( zend_class, const_cast<char*>( name ), strlen( name ), value ); zend_declare_class_constant_long(zend_class, const_cast<char*>(name), strlen(name), value);
if( zr == FAILURE ) {
throw core::CoreException();
}
} }
void REGISTER_PDO_SQLSRV_CLASS_CONST_STRING( _In_z_ char const* name, _In_z_ char const* value ) void REGISTER_PDO_SQLSRV_CLASS_CONST_STRING( _In_z_ char const* name, _In_z_ char const* value )
@ -290,11 +287,7 @@ namespace {
zend_class_entry* zend_class = php_pdo_get_dbh_ce(); zend_class_entry* zend_class = php_pdo_get_dbh_ce();
SQLSRV_ASSERT( zend_class != NULL, "REGISTER_PDO_SQLSRV_CLASS_CONST_STRING: php_pdo_get_dbh_ce failed"); SQLSRV_ASSERT( zend_class != NULL, "REGISTER_PDO_SQLSRV_CLASS_CONST_STRING: php_pdo_get_dbh_ce failed");
int zr = zend_declare_class_constant_string( zend_class, const_cast<char*>( name ), strlen( name ), const_cast<char*>( value ) ); zend_declare_class_constant_string(zend_class, const_cast<char*>(name), strlen(name), const_cast<char*>(value));
if( zr == FAILURE ) {
throw core::CoreException();
}
} }
// array of pdo constants. // array of pdo constants.

4
source/pdo_sqlsrv/pdo_stmt.cpp
View file

@ -1065,7 +1065,7 @@ int pdo_sqlsrv_stmt_get_col_meta( _Inout_ pdo_stmt_t *stmt, _In_ zend_long colno
} }
// initialize the array to nothing, as PDO requires us to create it // initialize the array to nothing, as PDO requires us to create it
core::sqlsrv_array_init( *driver_stmt, return_value ); array_init(return_value);
field_meta_data* core_meta_data; field_meta_data* core_meta_data;
@ -1080,7 +1080,7 @@ int pdo_sqlsrv_stmt_get_col_meta( _Inout_ pdo_stmt_t *stmt, _In_ zend_long colno
// initialize the column data classification array // initialize the column data classification array
zval data_classification; zval data_classification;
ZVAL_UNDEF(&data_classification); ZVAL_UNDEF(&data_classification);
core::sqlsrv_array_init(*driver_stmt, &data_classification ); array_init(&data_classification);
data_classification::fill_column_sensitivity_array(driver_stmt, (SQLSMALLINT)colno, &data_classification); data_classification::fill_column_sensitivity_array(driver_stmt, (SQLSMALLINT)colno, &data_classification);

85
source/shared/core_conn.cpp
View file

@ -71,7 +71,6 @@ void build_connection_string_and_set_conn_attr( _Inout_ sqlsrv_conn* conn, _Inou
void* driver,_Inout_ std::string& connection_string ); void* driver,_Inout_ std::string& connection_string );
void determine_server_version( _Inout_ sqlsrv_conn* conn ); void determine_server_version( _Inout_ sqlsrv_conn* conn );
const char* get_processor_arch( void ); const char* get_processor_arch( void );
void get_server_version( _Inout_ sqlsrv_conn* conn, _Outptr_result_buffer_(len) char** server_version, _Out_ SQLSMALLINT& len );
connection_option const* get_connection_option( sqlsrv_conn* conn, _In_ const char* key, _In_ SQLULEN key_len ); connection_option const* get_connection_option( sqlsrv_conn* conn, _In_ const char* key, _In_ SQLULEN key_len );
void common_conn_str_append_func( _In_z_ const char* odbc_name, _In_reads_(val_len) const char* val, _Inout_ size_t val_len, _Inout_ std::string& conn_str ); void common_conn_str_append_func( _In_z_ const char* odbc_name, _In_reads_(val_len) const char* val, _Inout_ size_t val_len, _Inout_ std::string& conn_str );
void load_azure_key_vault( _Inout_ sqlsrv_conn* conn ); void load_azure_key_vault( _Inout_ sqlsrv_conn* conn );
@ -590,19 +589,11 @@ void core_sqlsrv_prepare( _Inout_ sqlsrv_stmt* stmt, _In_reads_bytes_(sql_len) c
void core_sqlsrv_get_server_version( _Inout_ sqlsrv_conn* conn, _Inout_ zval* server_version ) void core_sqlsrv_get_server_version( _Inout_ sqlsrv_conn* conn, _Inout_ zval* server_version )
{ {
try { try {
char buffer[INFO_BUFFER_LEN] = "";
sqlsrv_malloc_auto_ptr<char> buffer;
SQLSMALLINT buffer_len = 0; SQLSMALLINT buffer_len = 0;
core::SQLGetInfo(conn, SQL_DBMS_VER, buffer, INFO_BUFFER_LEN, &buffer_len);
get_server_version( conn, &buffer, buffer_len );
core::sqlsrv_zval_stringl(server_version, buffer, buffer_len); core::sqlsrv_zval_stringl(server_version, buffer, buffer_len);
if ( buffer != 0 ) { } catch( core::CoreException& ) {
sqlsrv_free( buffer );
}
buffer.transferred();
}
catch( core::CoreException& ) {
throw; throw;
} }
} }
@ -617,33 +608,25 @@ void core_sqlsrv_get_server_version( _Inout_ sqlsrv_conn* conn, _Inout_ zval* se
void core_sqlsrv_get_server_info( _Inout_ sqlsrv_conn* conn, _Out_ zval *server_info ) void core_sqlsrv_get_server_info( _Inout_ sqlsrv_conn* conn, _Out_ zval *server_info )
{ {
try { try {
char buffer[INFO_BUFFER_LEN] = "";
sqlsrv_malloc_auto_ptr<char> buffer;
SQLSMALLINT buffer_len = 0; SQLSMALLINT buffer_len = 0;
// Get the database name // 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); core::SQLGetInfo(conn, SQL_DATABASE_NAME, buffer, INFO_BUFFER_LEN, &buffer_len);
// initialize the array // initialize the array
core::sqlsrv_array_init( *conn, server_info ); array_init(server_info);
core::sqlsrv_add_assoc_string( *conn, server_info, "CurrentDatabase", buffer, 0 /*duplicate*/ ); add_assoc_string(server_info, "CurrentDatabase", buffer);
buffer.transferred();
// Get the server version // Get the server version
get_server_version( conn, &buffer, buffer_len ); core::SQLGetInfo(conn, SQL_DBMS_VER, buffer, INFO_BUFFER_LEN, &buffer_len);
core::sqlsrv_add_assoc_string( *conn, server_info, "SQLServerVersion", buffer, 0 /*duplicate*/ ); add_assoc_string(server_info, "SQLServerVersion", buffer);
buffer.transferred();
// Get the server name // Get the server name
buffer = static_cast<char*>( sqlsrv_malloc( INFO_BUFFER_LEN ));
core::SQLGetInfo(conn, SQL_SERVER_NAME, buffer, INFO_BUFFER_LEN, &buffer_len); core::SQLGetInfo(conn, SQL_SERVER_NAME, buffer, INFO_BUFFER_LEN, &buffer_len);
core::sqlsrv_add_assoc_string( *conn, server_info, "SQLServerName", buffer, 0 /*duplicate*/ ); add_assoc_string(server_info, "SQLServerName", buffer);
buffer.transferred(); } catch (core::CoreException&) {
}
catch( core::CoreException& ) {
throw; throw;
} }
} }
@ -657,39 +640,29 @@ void core_sqlsrv_get_server_info( _Inout_ sqlsrv_conn* conn, _Out_ zval *server_
void core_sqlsrv_get_client_info( _Inout_ sqlsrv_conn* conn, _Out_ zval *client_info ) void core_sqlsrv_get_client_info( _Inout_ sqlsrv_conn* conn, _Out_ zval *client_info )
{ {
try { try {
char buffer[INFO_BUFFER_LEN] = "";
sqlsrv_malloc_auto_ptr<char> buffer;
SQLSMALLINT buffer_len = 0; SQLSMALLINT buffer_len = 0;
// Get the ODBC driver's dll name // 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 ); core::SQLGetInfo( conn, SQL_DRIVER_NAME, buffer, INFO_BUFFER_LEN, &buffer_len );
// initialize the array // initialize the array
core::sqlsrv_array_init( *conn, client_info ); array_init(client_info);
#ifndef _WIN32 #ifndef _WIN32
core::sqlsrv_add_assoc_string( *conn, client_info, "DriverName", buffer, 0 /*duplicate*/ ); add_assoc_string(client_info, "DriverName", buffer);
#else #else
core::sqlsrv_add_assoc_string( *conn, client_info, "DriverDllName", buffer, 0 /*duplicate*/ ); add_assoc_string(client_info, "DriverDllName", buffer);
#endif // !_WIN32 #endif // !_WIN32
buffer.transferred();
// Get the ODBC driver's ODBC version // Get the ODBC driver's ODBC version
buffer = static_cast<char*>( sqlsrv_malloc( INFO_BUFFER_LEN ));
core::SQLGetInfo( conn, SQL_DRIVER_ODBC_VER, buffer, INFO_BUFFER_LEN, &buffer_len ); core::SQLGetInfo( conn, SQL_DRIVER_ODBC_VER, buffer, INFO_BUFFER_LEN, &buffer_len );
core::sqlsrv_add_assoc_string( *conn, client_info, "DriverODBCVer", buffer, 0 /*duplicate*/ ); add_assoc_string(client_info, "DriverODBCVer", buffer);
buffer.transferred();
// Get the OBDC driver's version // Get the OBDC driver's version
buffer = static_cast<char*>( sqlsrv_malloc( INFO_BUFFER_LEN ));
core::SQLGetInfo( conn, SQL_DRIVER_VER, buffer, INFO_BUFFER_LEN, &buffer_len ); core::SQLGetInfo( conn, SQL_DRIVER_VER, buffer, INFO_BUFFER_LEN, &buffer_len );
core::sqlsrv_add_assoc_string( *conn, client_info, "DriverVer", buffer, 0 /*duplicate*/ ); add_assoc_string(client_info, "DriverVer", buffer);
buffer.transferred(); } catch( core::CoreException& ) {
}
catch( core::CoreException& ) {
throw; throw;
} }
} }
@ -918,30 +891,6 @@ void build_connection_string_and_set_conn_attr( _Inout_ sqlsrv_conn* conn, _Inou
} }
} }
// get_server_version
// Helper function which returns the version of the SQL Server we are connected to.
void get_server_version( _Inout_ sqlsrv_conn* conn, _Outptr_result_buffer_(len) char** server_version, _Out_ SQLSMALLINT& len )
{
try {
sqlsrv_malloc_auto_ptr<char> buffer;
SQLSMALLINT buffer_len = 0;
buffer = static_cast<char*>( sqlsrv_malloc( INFO_BUFFER_LEN ));
core::SQLGetInfo( conn, SQL_DBMS_VER, buffer, INFO_BUFFER_LEN, &buffer_len );
*server_version = buffer;
len = buffer_len;
buffer.transferred();
}
catch( core::CoreException& ) {
throw;
}
}
// get_processor_arch // get_processor_arch
// Calls GetSystemInfo to verify the what architecture of the processor is supported // Calls GetSystemInfo to verify the what architecture of the processor is supported
// and return the string of the processor name. // and return the string of the processor name.

71
source/shared/core_sqlsrv.h
View file

@ -2498,77 +2498,6 @@ namespace core {
} }
} }
// exception thrown when a zend function wrapped here fails.
// wrappers for the zend functions called by our driver. These functions hook into the error reporting of our driver and throw
// exceptions when an error occurs. They are prefaced with sqlsrv_<zend_function_name> because many of the zend functions are
// actually macros that call other functions, so the sqlsrv_ is necessary to differentiate them from the macro system.
// If there is a zend function in the source that isn't found here, it is because it returns void and there is no error
// that can be thrown from it.
inline void sqlsrv_add_index_zval( _Inout_ sqlsrv_context& ctx, _Inout_ zval* array, _In_ zend_ulong index, _In_ zval* value)
{
int zr = add_index_zval( array, index, value );
CHECK_ZEND_ERROR( zr, ctx, SQLSRV_ERROR_ZEND_HASH ) {
throw CoreException();
}
}
inline void sqlsrv_add_next_index_zval( _Inout_ sqlsrv_context& ctx, _Inout_ zval* array, _In_ zval* value)
{
int zr = add_next_index_zval( array, value );
CHECK_ZEND_ERROR( zr, ctx, SQLSRV_ERROR_ZEND_HASH ) {
throw CoreException();
}
}
inline void sqlsrv_add_assoc_null( _Inout_ sqlsrv_context& ctx, _Inout_ zval* array_z, _In_ const char* key )
{
int zr = ::add_assoc_null( array_z, key );
CHECK_ZEND_ERROR (zr, ctx, SQLSRV_ERROR_ZEND_HASH ) {
throw CoreException();
}
}
inline void sqlsrv_add_assoc_long( _Inout_ sqlsrv_context& ctx, _Inout_ zval* array_z, _In_ const char* key, _In_ zend_long val )
{
int zr = ::add_assoc_long( array_z, key, val );
CHECK_ZEND_ERROR (zr, ctx, SQLSRV_ERROR_ZEND_HASH ) {
throw CoreException();
}
}
inline void sqlsrv_add_assoc_string( _Inout_ sqlsrv_context& ctx, _Inout_ zval* array_z, _In_ const char* key, _Inout_z_ char* val, _In_ bool duplicate )
{
int zr = ::add_assoc_string(array_z, key, val);
CHECK_ZEND_ERROR (zr, ctx, SQLSRV_ERROR_ZEND_HASH ) {
throw CoreException();
}
if (duplicate == 0) {
sqlsrv_free(val);
}
}
inline void sqlsrv_add_assoc_zval( _Inout_ sqlsrv_context& ctx, _Inout_ zval* array_z, _In_ const char* key, _In_ zval* val )
{
int zr = ::add_assoc_zval(array_z, key, val);
CHECK_ZEND_ERROR (zr, ctx, SQLSRV_ERROR_ZEND_HASH ) {
throw CoreException();
}
}
inline void sqlsrv_array_init( _Inout_ sqlsrv_context& ctx, _Out_ zval* new_array)
{
#if PHP_VERSION_ID < 70300
CHECK_ZEND_ERROR(::array_init(new_array), ctx, SQLSRV_ERROR_ZEND_HASH) {
throw CoreException();
}
#else
array_init(new_array);
#endif
}
inline void sqlsrv_php_stream_from_zval_no_verify( _Inout_ sqlsrv_context& ctx, _Outref_result_maybenull_ php_stream*& stream, _In_opt_ zval* stream_z ) inline void sqlsrv_php_stream_from_zval_no_verify( _Inout_ sqlsrv_context& ctx, _Outref_result_maybenull_ php_stream*& stream, _In_opt_ zval* stream_z )
{ {
// this duplicates the macro php_stream_from_zval_no_verify, which we can't use because it has an assignment // this duplicates the macro php_stream_from_zval_no_verify, which we can't use because it has an assignment

4
source/shared/core_stmt.cpp
View file

@ -159,7 +159,7 @@ sqlsrv_stmt::sqlsrv_stmt( _In_ sqlsrv_conn* c, _In_ SQLHANDLE handle, _In_ error
{ {
ZVAL_UNDEF( &active_stream ); ZVAL_UNDEF( &active_stream );
// initialize the input string parameters array (which holds zvals) // initialize the input string parameters array (which holds zvals)
core::sqlsrv_array_init( *conn, &param_input_strings ); array_init(&param_input_strings);
// initialize the (input only) stream parameters (which holds sqlsrv_stream structures) // initialize the (input only) stream parameters (which holds sqlsrv_stream structures)
ZVAL_NEW_ARR( &param_streams ); ZVAL_NEW_ARR( &param_streams );
@ -574,7 +574,7 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
} }
buffer = Z_STRVAL_P( &wbuffer_z ); buffer = Z_STRVAL_P( &wbuffer_z );
buffer_len = Z_STRLEN_P( &wbuffer_z ); buffer_len = Z_STRLEN_P( &wbuffer_z );
core::sqlsrv_add_index_zval( *stmt, &( stmt->param_input_strings ), param_num, &wbuffer_z ); add_index_zval(&(stmt->param_input_strings), param_num, &wbuffer_z);
} }
ind_ptr = buffer_len; ind_ptr = buffer_len;
if( direction != SQL_PARAM_INPUT ){ if( direction != SQL_PARAM_INPUT ){

26
source/shared/core_util.cpp
View file

@ -617,27 +617,27 @@ namespace data_classification {
zval data_classification; zval data_classification;
ZVAL_UNDEF(&data_classification); ZVAL_UNDEF(&data_classification);
core::sqlsrv_array_init(*stmt, &data_classification ); array_init(&data_classification);
USHORT num_pairs = meta->columns_sensitivity[colno].num_pairs; USHORT num_pairs = meta->columns_sensitivity[colno].num_pairs;
if (num_pairs == 0) { if (num_pairs == 0) {
core::sqlsrv_add_assoc_zval(*stmt, return_array, DATA_CLASS, &data_classification); add_assoc_zval(return_array, DATA_CLASS, &data_classification);
return 0; return 0;
} }
zval sensitivity_properties; zval sensitivity_properties;
ZVAL_UNDEF(&sensitivity_properties); ZVAL_UNDEF(&sensitivity_properties);
core::sqlsrv_array_init(*stmt, &sensitivity_properties); array_init(&sensitivity_properties);
for (USHORT j = 0; j < num_pairs; j++) { for (USHORT j = 0; j < num_pairs; j++) {
zval label_array, infotype_array; zval label_array, infotype_array;
ZVAL_UNDEF(&label_array); ZVAL_UNDEF(&label_array);
ZVAL_UNDEF(&infotype_array); ZVAL_UNDEF(&infotype_array);
core::sqlsrv_array_init(*stmt, &label_array); array_init(&label_array);
core::sqlsrv_array_init(*stmt, &infotype_array); array_init(&infotype_array);
USHORT labelidx = meta->columns_sensitivity[colno].label_info_pairs[j].label_idx; USHORT labelidx = meta->columns_sensitivity[colno].label_info_pairs[j].label_idx;
USHORT typeidx = meta->columns_sensitivity[colno].label_info_pairs[j].infotype_idx; USHORT typeidx = meta->columns_sensitivity[colno].label_info_pairs[j].infotype_idx;
@ -647,22 +647,22 @@ namespace data_classification {
char *infotype = meta->infotypes[typeidx]->name; char *infotype = meta->infotypes[typeidx]->name;
char *infotype_id = meta->infotypes[typeidx]->id; char *infotype_id = meta->infotypes[typeidx]->id;
core::sqlsrv_add_assoc_string(*stmt, &label_array, NAME, label, 1); add_assoc_string(&label_array, NAME, label);
core::sqlsrv_add_assoc_string(*stmt, &label_array, ID, label_id, 1); add_assoc_string(&label_array, ID, label_id);
core::sqlsrv_add_assoc_zval(*stmt, &sensitivity_properties, LABEL, &label_array); add_assoc_zval(&sensitivity_properties, LABEL, &label_array);
core::sqlsrv_add_assoc_string(*stmt, &infotype_array, NAME, infotype, 1); add_assoc_string(&infotype_array, NAME, infotype);
core::sqlsrv_add_assoc_string(*stmt, &infotype_array, ID, infotype_id, 1); add_assoc_string(&infotype_array, ID, infotype_id);
core::sqlsrv_add_assoc_zval(*stmt, &sensitivity_properties, INFOTYPE, &infotype_array); add_assoc_zval(&sensitivity_properties, INFOTYPE, &infotype_array);
// add the pair of sensitivity properties to data_classification // add the pair of sensitivity properties to data_classification
core::sqlsrv_add_next_index_zval(*stmt, &data_classification, &sensitivity_properties ); add_next_index_zval(&data_classification, &sensitivity_properties);
} }
// add data classfication as associative array // add data classfication as associative array
core::sqlsrv_add_assoc_zval(*stmt, return_array, DATA_CLASS, &data_classification); add_assoc_zval(return_array, DATA_CLASS, &data_classification);
return num_pairs; return num_pairs;
} }

21
source/sqlsrv/conn.cpp
View file

@ -967,27 +967,21 @@ PHP_FUNCTION( sqlsrv_rollback )
PHP_FUNCTION( sqlsrv_client_info ) PHP_FUNCTION( sqlsrv_client_info )
{ {
LOG_FUNCTION( "sqlsrv_client_info" ); LOG_FUNCTION( "sqlsrv_client_info" );
ss_sqlsrv_conn* conn = NULL; ss_sqlsrv_conn* conn = NULL;
PROCESS_PARAMS( conn, "r", _FN_, 0 ); PROCESS_PARAMS( conn, "r", _FN_, 0 );
try { try {
core_sqlsrv_get_client_info(conn, return_value); core_sqlsrv_get_client_info(conn, return_value);
// Add the sqlsrv driver's file version // Add the sqlsrv driver's file version
//Declarations below eliminate compiler warnings about string constant to char* conversions //Declarations below eliminate compiler warnings about string constant to char* conversions
const char* extver = "ExtensionVer"; const char* extver = "ExtensionVer";
std::string filever = VER_FILEVERSION_STR; std::string filever = VER_FILEVERSION_STR;
core::sqlsrv_add_assoc_string( *conn, return_value, extver, &filever[0], 1 /*duplicate*/ ); add_assoc_string(return_value, extver, &filever[0]);
} } catch (core::CoreException&) {
catch( core::CoreException& ) {
RETURN_FALSE; RETURN_FALSE;
} } catch (...) {
catch( ... ) {
DIE("sqlsrv_client_info: Unknown exception caught."); DIE("sqlsrv_client_info: Unknown exception caught.");
} }
} }
@ -1011,19 +1005,14 @@ PHP_FUNCTION( sqlsrv_client_info )
PHP_FUNCTION( sqlsrv_server_info ) PHP_FUNCTION( sqlsrv_server_info )
{ {
try { try {
LOG_FUNCTION("sqlsrv_server_info"); LOG_FUNCTION("sqlsrv_server_info");
ss_sqlsrv_conn* conn = NULL; ss_sqlsrv_conn* conn = NULL;
PROCESS_PARAMS(conn, "r", _FN_, 0); PROCESS_PARAMS(conn, "r", _FN_, 0);
core_sqlsrv_get_server_info(conn, return_value); core_sqlsrv_get_server_info(conn, return_value);
} } catch (core::CoreException&) {
catch( core::CoreException& ) {
RETURN_FALSE; RETURN_FALSE;
} } catch (...) {
catch( ... ) {
DIE("sqlsrv_server_info: Unknown exception caught."); DIE("sqlsrv_server_info: Unknown exception caught.");
} }
} }

43
source/sqlsrv/stmt.cpp
View file

@ -500,7 +500,7 @@ PHP_FUNCTION( sqlsrv_field_metadata )
zval result_meta_data; zval result_meta_data;
ZVAL_UNDEF(&result_meta_data); ZVAL_UNDEF(&result_meta_data);
core::sqlsrv_array_init( *stmt, &result_meta_data ); array_init(&result_meta_data);
for( SQLSMALLINT f = 0; f < num_cols; ++f ) { for( SQLSMALLINT f = 0; f < num_cols; ++f ) {
field_meta_data* core_meta_data = stmt->current_meta_data[f]; field_meta_data* core_meta_data = stmt->current_meta_data[f];
@ -508,13 +508,13 @@ PHP_FUNCTION( sqlsrv_field_metadata )
// initialize the array // initialize the array
zval field_array; zval field_array;
ZVAL_UNDEF( &field_array ); ZVAL_UNDEF( &field_array );
core::sqlsrv_array_init( *stmt, &field_array ); array_init(&field_array );
// add the field name to the associative array but keep a copy // add the field name to the associative array but keep a copy
core::sqlsrv_add_assoc_string(*stmt, &field_array, FieldMetaData::NAME, add_assoc_string(&field_array, FieldMetaData::NAME, reinterpret_cast<char*>(core_meta_data->field_name.get()));
reinterpret_cast<char*>(core_meta_data->field_name.get()), 1);
core::sqlsrv_add_assoc_long( *stmt, &field_array, FieldMetaData::TYPE, core_meta_data->field_type ); //core::sqlsrv_add_assoc_long( *stmt, &field_array, FieldMetaData::TYPE, core_meta_data->field_type );
add_assoc_long(&field_array, FieldMetaData::TYPE, core_meta_data->field_type);
switch( core_meta_data->field_type ) { switch( core_meta_data->field_type ) {
case SQL_DECIMAL: case SQL_DECIMAL:
@ -523,9 +523,9 @@ PHP_FUNCTION( sqlsrv_field_metadata )
case SQL_TYPE_DATE: case SQL_TYPE_DATE:
case SQL_SS_TIME2: case SQL_SS_TIME2:
case SQL_SS_TIMESTAMPOFFSET: case SQL_SS_TIMESTAMPOFFSET:
core::sqlsrv_add_assoc_null( *stmt, &field_array, FieldMetaData::SIZE ); add_assoc_null(&field_array, FieldMetaData::SIZE);
core::sqlsrv_add_assoc_long( *stmt, &field_array, FieldMetaData::PREC, core_meta_data->field_precision ); add_assoc_long(&field_array, FieldMetaData::PREC, core_meta_data->field_precision);
core::sqlsrv_add_assoc_long( *stmt, &field_array, FieldMetaData::SCALE, core_meta_data->field_scale ); add_assoc_long(&field_array, FieldMetaData::SCALE, core_meta_data->field_scale);
break; break;
case SQL_BIT: case SQL_BIT:
case SQL_TINYINT: case SQL_TINYINT:
@ -535,26 +535,26 @@ PHP_FUNCTION( sqlsrv_field_metadata )
case SQL_REAL: case SQL_REAL:
case SQL_FLOAT: case SQL_FLOAT:
case SQL_DOUBLE: case SQL_DOUBLE:
core::sqlsrv_add_assoc_null( *stmt, &field_array, FieldMetaData::SIZE ); add_assoc_null(&field_array, FieldMetaData::SIZE);
core::sqlsrv_add_assoc_long( *stmt, &field_array, FieldMetaData::PREC, core_meta_data->field_precision ); add_assoc_long(&field_array, FieldMetaData::PREC, core_meta_data->field_precision);
core::sqlsrv_add_assoc_null( *stmt, &field_array, FieldMetaData::SCALE ); add_assoc_null(&field_array, FieldMetaData::SCALE);
break; break;
default: default:
core::sqlsrv_add_assoc_long( *stmt, &field_array, FieldMetaData::SIZE, core_meta_data->field_size ); add_assoc_long(&field_array, FieldMetaData::SIZE, core_meta_data->field_size);
core::sqlsrv_add_assoc_null( *stmt, &field_array, FieldMetaData::PREC ); add_assoc_null(&field_array, FieldMetaData::PREC);
core::sqlsrv_add_assoc_null( *stmt, &field_array, FieldMetaData::SCALE ); add_assoc_null(&field_array, FieldMetaData::SCALE);
break; break;
} }
// add the nullability to the array // add the nullability to the array
core::sqlsrv_add_assoc_long(*stmt, &field_array, FieldMetaData::NULLABLE, core_meta_data->field_is_nullable); add_assoc_long(&field_array, FieldMetaData::NULLABLE, core_meta_data->field_is_nullable);
if (stmt->data_classification) { if (stmt->data_classification) {
data_classification::fill_column_sensitivity_array(stmt, f, &field_array); data_classification::fill_column_sensitivity_array(stmt, f, &field_array);
} }
// add this field's meta data to the result set meta data // add this field's meta data to the result set meta data
core::sqlsrv_add_next_index_zval( *stmt, &result_meta_data, &field_array ); add_next_index_zval(&result_meta_data, &field_array);
} }
// return our built collection and transfer ownership // return our built collection and transfer ownership
@ -1873,13 +1873,7 @@ void fetch_fields_common( _Inout_ ss_sqlsrv_stmt* stmt, _In_ zend_long fetch_typ
} }
int zr = SUCCESS; int zr = SUCCESS;
#if PHP_VERSION_ID < 70300
CHECK_ZEND_ERROR(array_init(&fields), stmt, SQLSRV_ERROR_ZEND_HASH) {
throw ss::SSException();
}
#else
array_init(&fields); array_init(&fields);
#endif
for( int i = 0; i < num_cols; ++i ) { for( int i = 0; i < num_cols; ++i ) {
SQLLEN field_len = -1; SQLLEN field_len = -1;
@ -1908,10 +1902,7 @@ void fetch_fields_common( _Inout_ ss_sqlsrv_stmt* stmt, _In_ zend_long fetch_typ
if( stmt->fetch_field_names[i].len > 0 || allow_empty_field_names ) { if( stmt->fetch_field_names[i].len > 0 || allow_empty_field_names ) {
zr = add_assoc_zval( &fields, stmt->fetch_field_names[i].name, &field ); add_assoc_zval(&fields, stmt->fetch_field_names[i].name, &field);
CHECK_ZEND_ERROR( zr, stmt, SQLSRV_ERROR_ZEND_HASH ) {
throw ss::SSException();
}
} }
} }
//only addref when the fetch_type is BOTH because this is the only case when fields(hashtable) //only addref when the fetch_type is BOTH because this is the only case when fields(hashtable)

36
source/sqlsrv/util.cpp
View file

@ -519,13 +519,7 @@ PHP_FUNCTION( sqlsrv_errors )
} }
zval err_z; zval err_z;
ZVAL_UNDEF(&err_z); ZVAL_UNDEF(&err_z);
#if PHP_VERSION_ID < 70300
if (array_init(&err_z) == FAILURE) {
RETURN_FALSE;
}
#else
array_init(&err_z); array_init(&err_z);
#endif
if( flags == SQLSRV_ERR_ALL || flags == SQLSRV_ERR_ERRORS ) { if( flags == SQLSRV_ERR_ALL || flags == SQLSRV_ERR_ERRORS ) {
if( Z_TYPE( SQLSRV_G( errors )) == IS_ARRAY && !sqlsrv_merge_zend_hash( &err_z, &SQLSRV_G( errors ) )) { if( Z_TYPE( SQLSRV_G( errors )) == IS_ARRAY && !sqlsrv_merge_zend_hash( &err_z, &SQLSRV_G( errors ) )) {
@ -763,13 +757,7 @@ sqlsrv_error_const* get_error_message( _In_ unsigned int sqlsrv_error_code ) {
void copy_error_to_zval( _Inout_ zval* error_z, _In_ sqlsrv_error_const* error, _Inout_ zval* reported_chain, _Inout_ zval* ignored_chain, void copy_error_to_zval( _Inout_ zval* error_z, _In_ sqlsrv_error_const* error, _Inout_ zval* reported_chain, _Inout_ zval* ignored_chain,
_In_ bool warning ) _In_ bool warning )
{ {
#if PHP_VERSION_ID < 70300
if (array_init(error_z) == FAILURE) {
DIE( "Fatal error during error processing" );
}
#else
array_init(error_z); array_init(error_z);
#endif
// sqlstate // sqlstate
zval temp; zval temp;
@ -780,18 +768,14 @@ void copy_error_to_zval( _Inout_ zval* error_z, _In_ sqlsrv_error_const* error,
DIE( "Fatal error during error processing" ); DIE( "Fatal error during error processing" );
} }
if( add_assoc_zval( error_z, "SQLSTATE", &temp ) == FAILURE ) { add_assoc_zval(error_z, "SQLSTATE", &temp);
DIE( "Fatal error during error processing" );
}
// native_code // native_code
if( add_next_index_long( error_z, error->native_code ) == FAILURE ) { if( add_next_index_long( error_z, error->native_code ) == FAILURE ) {
DIE( "Fatal error during error processing" ); DIE( "Fatal error during error processing" );
} }
if( add_assoc_long( error_z, "code", error->native_code ) == FAILURE ) { add_assoc_long(error_z, "code", error->native_code);
DIE( "Fatal error during error processing" );
}
// native_message // native_message
ZVAL_UNDEF(&temp); ZVAL_UNDEF(&temp);
@ -801,9 +785,7 @@ void copy_error_to_zval( _Inout_ zval* error_z, _In_ sqlsrv_error_const* error,
DIE( "Fatal error during error processing" ); DIE( "Fatal error during error processing" );
} }
if( add_assoc_zval( error_z, "message", &temp ) == FAILURE ) { add_assoc_zval(error_z, "message", &temp);
DIE( "Fatal error during error processing" );
}
// If it is an error or if warning_return_as_errors is true than // If it is an error or if warning_return_as_errors is true than
// add the error or warning to the reported_chain. // add the error or warning to the reported_chain.
@ -854,13 +836,7 @@ bool handle_errors_and_warnings( _Inout_ sqlsrv_context& ctx, _Inout_ zval* repo
if( Z_TYPE_P( reported_chain ) == IS_NULL ) { if( Z_TYPE_P( reported_chain ) == IS_NULL ) {
reported_chain_was_null = true; reported_chain_was_null = true;
#if PHP_VERSION_ID < 70300
if (array_init(reported_chain) == FAILURE) {
DIE( "Fatal error during error processing" );
}
#else
array_init(reported_chain); array_init(reported_chain);
#endif
} }
else { else {
prev_reported_cnt = zend_hash_num_elements( Z_ARRVAL_P( reported_chain )); prev_reported_cnt = zend_hash_num_elements( Z_ARRVAL_P( reported_chain ));
@ -872,13 +848,7 @@ bool handle_errors_and_warnings( _Inout_ sqlsrv_context& ctx, _Inout_ zval* repo
if( Z_TYPE_P( ignored_chain ) == IS_NULL ) { if( Z_TYPE_P( ignored_chain ) == IS_NULL ) {
ignored_chain_was_null = true; ignored_chain_was_null = true;
#if PHP_VERSION_ID < 70300
if (array_init(ignored_chain) == FAILURE) {
DIE( "Fatal error in handle_errors_and_warnings" );
}
#else
array_init( ignored_chain ); array_init( ignored_chain );
#endif
} }
} }