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

Merge branch 'dev' into patch-1

Browse source
This commit is contained in:
Jenny Tam 2017-11-14 11:38:03 -08:00 committed by GitHub
parent 258fdcd282 07ac237def
commit b07f0c1e93
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
135 changed files with 4709 additions and 5156 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
appveyor.yml
View file

@ -27,16 +27,16 @@ environment:
PHP_SDK_DIR: c:\projects\php\x86
PHP_INSTALL_DIR: c:\projects\php\x86\bin
platform: x86
- BUILD_PLATFORM: x64
- BUILD_PLATFORM: x86
TEST_PHP_SQL_SERVER: (local)\SQL2012SP1
SQL_INSTANCE: SQL2012SP1
PHP_VC: 14
PHP_MAJOR_VER: 7.0
PHP_MINOR_VER: latest
PHP_SDK_DIR: c:\projects\php\x64
PHP_INSTALL_DIR: c:\projects\php\x64\bin
PHP_SDK_DIR: c:\projects\php\x86
PHP_INSTALL_DIR: c:\projects\php\x86\bin
PHP_ZTS: --disable-zts
platform: x64
platform: x86
- BUILD_PLATFORM: x86
TEST_PHP_SQL_SERVER: (local)\SQL2014
SQL_INSTANCE: SQL2014

51
issue_template.md
View file

@ -1,26 +1,27 @@
## Driver version or file name
Please tell us what the PHP driver version or file name is.
## SQL Server version
Please tell us what the SQL Server version is.
## Client operating system
Please tell us what oprating system the client program is running on.
## PHP version
Please tell us which version of PHP you are running.
## Microsoft ODBC Driver version
Please tell us which version of the Microsoft ODBC Driver you are using.
## Table schema
Please tell us the table schema
## Problem description
Please share more details with us.
## Expected behavior and actual behavior
Please tell us what should happen and what happened instead
## Repro code
Please share repro code with us, or tell us how to reproduce the issue.
+## Driver version or file name
+Please tell us what the PHP driver version or file name is.
+
+## SQL Server version
+Please tell us what the SQL Server version is.
+
+## Client operating system
+Please tell us what oprating system the client program is running on.
+
+## PHP version
+Please tell us which version of PHP you are running.
+
+## Microsoft ODBC Driver version
+Please tell us which version of the Microsoft ODBC Driver you are using.
+
+## Table schema
+Please tell us the table schema
+
+## Problem description
+Please share more details with us.
+
+## Expected behavior and actual behavior
+Please tell us what should happen and what happened instead
+
+## Repro code
+Please share repro code with us, or tell us how to reproduce the issue.

16
source/pdo_sqlsrv/pdo_stmt.cpp
View file

@ -1146,9 +1146,19 @@ int pdo_sqlsrv_stmt_param_hook( _Inout_ pdo_stmt_t *stmt,
// since the param isn't reliable, we don't do anything here
case PDO_PARAM_EVT_ALLOC:
if ( stmt->supports_placeholders == PDO_PLACEHOLDER_NONE && (param->param_type & PDO_PARAM_INPUT_OUTPUT )) {
sqlsrv_stmt* driver_stmt = reinterpret_cast<sqlsrv_stmt*>( stmt->driver_data );
THROW_PDO_ERROR( driver_stmt, PDO_SQLSRV_ERROR_EMULATE_INOUT_UNSUPPORTED );
{
pdo_sqlsrv_stmt* driver_stmt = reinterpret_cast<pdo_sqlsrv_stmt*>(stmt->driver_data);
if (driver_stmt->conn->ce_option.enabled) {
if (driver_stmt->direct_query) {
THROW_PDO_ERROR(driver_stmt, PDO_SQLSRV_ERROR_CE_DIRECT_QUERY_UNSUPPORTED);
}
if (stmt->supports_placeholders == PDO_PLACEHOLDER_NONE) {
THROW_PDO_ERROR(driver_stmt, PDO_SQLSRV_ERROR_CE_EMULATE_PREPARE_UNSUPPORTED);
}
}
if (stmt->supports_placeholders == PDO_PLACEHOLDER_NONE && (param->param_type & PDO_PARAM_INPUT_OUTPUT)) {
THROW_PDO_ERROR(driver_stmt, PDO_SQLSRV_ERROR_EMULATE_INOUT_UNSUPPORTED);
}
}
break;
case PDO_PARAM_EVT_FREE:

12
source/pdo_sqlsrv/pdo_util.cpp
View file

@ -409,6 +409,18 @@ pdo_error PDO_ERRORS[] = {
SQLSRV_ERROR_SPECIFIED_DRIVER_NOT_FOUND,
{ IMSSP, (SQLCHAR*) "The specified ODBC Driver is not found.", -80, false }
},
{
PDO_SQLSRV_ERROR_CE_DIRECT_QUERY_UNSUPPORTED,
{ IMSSP, (SQLCHAR*) "Parameterized statement with attribute PDO::SQLSRV_ATTR_DIRECT_QUERY is not supported in a Column Encryption enabled Connection.", -81, false }
},
{
PDO_SQLSRV_ERROR_CE_EMULATE_PREPARE_UNSUPPORTED,
{ IMSSP, (SQLCHAR*) "Parameterized statement with attribute PDO::ATTR_EMULATE_PREPARES is not supported in a Column Encryption enabled Connection.", -82, false }
},
{
SQLSRV_ERROR_OUTPUT_PARAM_TYPES_NOT_SUPPORTED,
{ IMSSP, (SQLCHAR*) "Stored Procedures do not support text, ntext or image as OUTPUT parameters.", -83, false }
},
{ UINT_MAX, {} }
};

6
source/pdo_sqlsrv/php_pdo_sqlsrv.h
View file

@ -310,7 +310,7 @@ inline void pdo_reset_dbh_error( _Inout_ pdo_dbh_t* dbh TSRMLS_DC )
// release the last statement from the dbh so that error handling won't have a statement passed to it
if( dbh->query_stmt ) {
dbh->query_stmt = NULL;
zend_objects_store_del( Z_OBJ_P(&dbh->query_stmt_zval TSRMLS_CC) );
zval_ptr_dtor( &dbh->query_stmt_zval );
}
// if the driver isn't valid, just return (PDO calls close sometimes more than once?)
@ -393,7 +393,9 @@ enum PDO_ERROR_CODES {
PDO_SQLSRV_ERROR_INVALID_OUTPUT_PARAM_TYPE,
PDO_SQLSRV_ERROR_INVALID_CURSOR_WITH_SCROLL_TYPE,
PDO_SQLSRV_ERROR_EMULATE_INOUT_UNSUPPORTED,
PDO_SQLSRV_ERROR_INVALID_AUTHENTICATION_OPTION
PDO_SQLSRV_ERROR_INVALID_AUTHENTICATION_OPTION,
PDO_SQLSRV_ERROR_CE_DIRECT_QUERY_UNSUPPORTED,
PDO_SQLSRV_ERROR_CE_EMULATE_PREPARE_UNSUPPORTED
};
extern pdo_error PDO_ERRORS[];

1
source/shared/core_sqlsrv.h
View file

@ -1689,6 +1689,7 @@ enum SQLSRV_ERROR_CODES {
SQLSRV_ERROR_KEYSTORE_PATH_MISSING,
SQLSRV_ERROR_KEYSTORE_KEY_MISSING,
SQLSRV_ERROR_KEYSTORE_INVALID_VALUE,
SQLSRV_ERROR_OUTPUT_PARAM_TYPES_NOT_SUPPORTED,
// Driver specific error codes starts from here.
SQLSRV_ERROR_DRIVER_SPECIFIC = 1000,

232
source/shared/core_stmt.cpp
View file

@ -357,18 +357,18 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
try {
// check is only < because params are 0 based
CHECK_CUSTOM_ERROR( param_num >= SQL_SERVER_MAX_PARAMS, stmt, SQLSRV_ERROR_MAX_PARAMS_EXCEEDED, param_num + 1 ) {
CHECK_CUSTOM_ERROR( param_num >= SQL_SERVER_MAX_PARAMS, stmt, SQLSRV_ERROR_MAX_PARAMS_EXCEEDED, param_num + 1 ){
throw core::CoreException();
}
// resize the statements array of int_ptrs if the parameter isn't already set.
if( stmt->param_ind_ptrs.size() < static_cast<size_t>(param_num + 1) ) {
if( stmt->param_ind_ptrs.size() < static_cast<size_t>( param_num + 1 )){
stmt->param_ind_ptrs.resize( param_num + 1, SQL_NULL_DATA );
}
SQLLEN& ind_ptr = stmt->param_ind_ptrs[ param_num ];
zval* param_ref = param_z;
if ( Z_ISREF_P( param_z ) ) {
if( Z_ISREF_P( param_z )){
ZVAL_DEREF( param_z );
}
bool zval_was_null = ( Z_TYPE_P( param_z ) == IS_NULL );
@ -379,24 +379,24 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
// we always let that match if they want a string back.
if( direction == SQL_PARAM_INPUT_OUTPUT ) {
bool match = false;
switch( php_out_type ) {
switch( php_out_type ){
case SQLSRV_PHPTYPE_INT:
if( zval_was_null || zval_was_bool ) {
if( zval_was_null || zval_was_bool ){
convert_to_long( param_z );
}
if( zval_was_long ){
convert_to_string( param_z );
if ( encoding != SQLSRV_ENCODING_SYSTEM && encoding != SQLSRV_ENCODING_UTF8 && encoding != SQLSRV_ENCODING_BINARY ) {
if( encoding != SQLSRV_ENCODING_SYSTEM && encoding != SQLSRV_ENCODING_UTF8 && encoding != SQLSRV_ENCODING_BINARY ){
encoding = SQLSRV_ENCODING_SYSTEM;
}
match = Z_TYPE_P( param_z ) == IS_STRING;
}
else {
else{
match = Z_TYPE_P( param_z ) == IS_LONG;
}
break;
case SQLSRV_PHPTYPE_FLOAT:
if( zval_was_null ) {
if( zval_was_null ){
convert_to_double( param_z );
}
match = Z_TYPE_P( param_z ) == IS_DOUBLE;
@ -415,23 +415,30 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
SQLSRV_ASSERT( false, "Unknown SQLSRV_PHPTYPE_* constant given." );
break;
}
CHECK_CUSTOM_ERROR( !match, stmt, SQLSRV_ERROR_INPUT_OUTPUT_PARAM_TYPE_MATCH, param_num + 1 ) {
CHECK_CUSTOM_ERROR( !match, stmt, SQLSRV_ERROR_INPUT_OUTPUT_PARAM_TYPE_MATCH, param_num + 1 ){
throw core::CoreException();
}
}
// if it's an output parameter and the user asks for a certain type, we have to convert the zval to that type so
// when the buffer is filled, the type is correct
if( direction == SQL_PARAM_OUTPUT ) {
// If the user specifies a certain type for an output parameter, we have to convert the zval
// to that type so that when the buffer is filled, the type is correct. But first,
// should check if a LOB type is specified.
CHECK_CUSTOM_ERROR( direction != SQL_PARAM_INPUT && ( sql_type == SQL_LONGVARCHAR
|| sql_type == SQL_WLONGVARCHAR || sql_type == SQL_LONGVARBINARY ),
stmt, SQLSRV_ERROR_OUTPUT_PARAM_TYPES_NOT_SUPPORTED ){
throw core::CoreException();
}
if( direction == SQL_PARAM_OUTPUT ){
switch( php_out_type ) {
case SQLSRV_PHPTYPE_INT:
if( zval_was_long ){
convert_to_string( param_z );
if ( encoding != SQLSRV_ENCODING_SYSTEM && encoding != SQLSRV_ENCODING_UTF8 && encoding != SQLSRV_ENCODING_BINARY ) {
if( encoding != SQLSRV_ENCODING_SYSTEM && encoding != SQLSRV_ENCODING_UTF8 && encoding != SQLSRV_ENCODING_BINARY ){
encoding = SQLSRV_ENCODING_SYSTEM;
}
}
else {
else{
convert_to_long( param_z );
}
break;
@ -456,20 +463,20 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
( encoding == SQLSRV_ENCODING_SYSTEM || encoding == SQLSRV_ENCODING_UTF8 ||
encoding == SQLSRV_ENCODING_BINARY ), "core_sqlsrv_bind_param: invalid encoding" );
if ( stmt->conn->ce_option.enabled && ( sql_type == SQL_UNKNOWN_TYPE || column_size == SQLSRV_UNKNOWN_SIZE )) {
if( stmt->conn->ce_option.enabled && ( sql_type == SQL_UNKNOWN_TYPE || column_size == SQLSRV_UNKNOWN_SIZE )){
ae_get_sql_type_info( stmt, param_num, direction, param_z, encoding, sql_type, column_size, decimal_digits TSRMLS_CC );
// change long to double if the sql type is decimal
if ( sql_type == SQL_DECIMAL && Z_TYPE_P( param_z ) == IS_LONG )
convert_to_double( param_z );
if(( sql_type == SQL_DECIMAL || sql_type == SQL_NUMERIC ) && Z_TYPE_P(param_z) == IS_LONG )
convert_to_double( param_z );
}
else {
else{
// if the sql type is unknown, then set the default based on the PHP type passed in
if ( sql_type == SQL_UNKNOWN_TYPE ) {
if( sql_type == SQL_UNKNOWN_TYPE ){
default_sql_type( stmt, param_num, param_z, encoding, sql_type TSRMLS_CC );
}
// if the size is unknown, then set the default based on the PHP type passed in
if ( column_size == SQLSRV_UNKNOWN_SIZE ) {
if( column_size == SQLSRV_UNKNOWN_SIZE ){
default_sql_size_and_scale( stmt, static_cast<unsigned int>(param_num), param_z, encoding, column_size, decimal_digits TSRMLS_CC );
}
}
@ -477,7 +484,7 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
c_type = default_c_type( stmt, param_num, param_z, encoding TSRMLS_CC );
// set the buffer based on the PHP parameter type
switch( Z_TYPE_P( param_z )) {
switch( Z_TYPE_P( param_z )){
case IS_NULL:
{
@ -491,12 +498,12 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
case IS_FALSE:
case IS_LONG:
{
// if it is boolean, set the lval to 0 or 1
convert_to_long( param_z );
// if it is boolean, set the lval to 0 or 1
convert_to_long( param_z );
buffer = &param_z->value;
buffer_len = sizeof( Z_LVAL_P( param_z ));
ind_ptr = buffer_len;
if( direction != SQL_PARAM_INPUT ) {
if( direction != SQL_PARAM_INPUT ){
// save the parameter so that 1) the buffer doesn't go away, and 2) we can set it to NULL if returned
sqlsrv_output_param output_param( param_ref, static_cast<int>( param_num ), zval_was_bool );
save_output_param_for_later( stmt, output_param TSRMLS_CC );
@ -508,7 +515,7 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
buffer = &param_z->value;
buffer_len = sizeof( Z_DVAL_P( param_z ));
ind_ptr = buffer_len;
if( direction != SQL_PARAM_INPUT ) {
if( direction != SQL_PARAM_INPUT ){
// save the parameter so that 1) the buffer doesn't go away, and 2) we can set it to NULL if returned
sqlsrv_output_param output_param( param_ref, static_cast<int>( param_num ), false );
save_output_param_for_later( stmt, output_param TSRMLS_CC );
@ -516,82 +523,115 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
}
break;
case IS_STRING:
buffer = Z_STRVAL_P( param_z );
buffer_len = Z_STRLEN_P( param_z );
// if the encoding is UTF-8, translate from UTF-8 to UTF-16 (the type variables should have already been adjusted)
if( direction == SQL_PARAM_INPUT && encoding == CP_UTF8 ) {
zval wbuffer_z;
ZVAL_NULL( &wbuffer_z );
bool converted = convert_input_param_to_utf16( param_z, &wbuffer_z );
CHECK_CUSTOM_ERROR( !converted, stmt, SQLSRV_ERROR_INPUT_PARAM_ENCODING_TRANSLATE,
param_num + 1, get_last_error_message() ) {
throw core::CoreException();
{
buffer = Z_STRVAL_P( param_z );
buffer_len = Z_STRLEN_P( param_z );
if( stmt->conn->ce_option.enabled && ( sql_type == SQL_DECIMAL || sql_type == SQL_NUMERIC )){
// get the double value
double dval = zend_strtod( ZSTR_VAL( Z_STR_P( param_z )), NULL );
// find the precision: number of digits before decimal place + decimal_digits
size_t numDigitsBeforeDec = 0;
double temp = dval;
if( abs( dval ) < 1){
numDigitsBeforeDec = 0;
}
else{
while( abs( temp ) > 1 ){
temp /= 10;
numDigitsBeforeDec++;
}
}
size_t precision = numDigitsBeforeDec + decimal_digits;
// when passing a precision 0 to strppintf, it still returns a string with precision of 1
// work around it by manually rounding the zval
if( precision == 0 && abs( dval ) < 1 ){
if( dval < 0.5 )
dval = 0;
else
dval = 1;
}
// reformat it with the right number of decimal digits
zend_string *str = strpprintf( 0, "%.*G", ( int )precision, dval );
zend_string_release( Z_STR_P( param_z ));
ZVAL_NEW_STR( param_z, str );
}
buffer = Z_STRVAL_P( &wbuffer_z );
buffer_len = Z_STRLEN_P( &wbuffer_z );
core::sqlsrv_add_index_zval(*stmt, &(stmt->param_input_strings), param_num, &wbuffer_z TSRMLS_CC);
}
ind_ptr = buffer_len;
if( direction != SQL_PARAM_INPUT ) {
// PHP 5.4 added interned strings, so since we obviously want to change that string here in some fashion,
// we reallocate the string if it's interned
if ( ZSTR_IS_INTERNED( Z_STR_P( param_z ))) {
core::sqlsrv_zval_stringl( param_z, static_cast<const char*>(buffer), buffer_len );
buffer = Z_STRVAL_P( param_z );
buffer_len = Z_STRLEN_P( param_z );
}
// if it's a UTF-8 input output parameter (signified by the C type being SQL_C_WCHAR)
// or if the PHP type is a binary encoded string with a N(VAR)CHAR/NTEXTSQL type,
// convert it to wchar first
if( direction == SQL_PARAM_INPUT_OUTPUT &&
( c_type == SQL_C_WCHAR ||
( c_type == SQL_C_BINARY &&
( sql_type == SQL_WCHAR ||
sql_type == SQL_WVARCHAR ||
sql_type == SQL_WLONGVARCHAR )))) {
// if the encoding is UTF-8, translate from UTF-8 to UTF-16 (the type variables should have already been adjusted)
if( direction == SQL_PARAM_INPUT && encoding == CP_UTF8 ){
bool converted = convert_input_param_to_utf16( param_z, param_z );
CHECK_CUSTOM_ERROR( !converted, stmt, SQLSRV_ERROR_INPUT_PARAM_ENCODING_TRANSLATE,
param_num + 1, get_last_error_message() ) {
zval wbuffer_z;
ZVAL_NULL( &wbuffer_z );
bool converted = convert_input_param_to_utf16( param_z, &wbuffer_z );
CHECK_CUSTOM_ERROR( !converted, stmt, SQLSRV_ERROR_INPUT_PARAM_ENCODING_TRANSLATE,
param_num + 1, get_last_error_message() ){
throw core::CoreException();
}
buffer = Z_STRVAL_P( param_z );
buffer_len = Z_STRLEN_P( param_z );
ind_ptr = buffer_len;
buffer = Z_STRVAL_P( &wbuffer_z );
buffer_len = Z_STRLEN_P( &wbuffer_z );
core::sqlsrv_add_index_zval( *stmt, &( stmt->param_input_strings ), param_num, &wbuffer_z TSRMLS_CC );
}
ind_ptr = buffer_len;
if( direction != SQL_PARAM_INPUT ){
// PHP 5.4 added interned strings, so since we obviously want to change that string here in some fashion,
// we reallocate the string if it's interned
if( ZSTR_IS_INTERNED( Z_STR_P( param_z ))){
core::sqlsrv_zval_stringl( param_z, static_cast<const char*>(buffer), buffer_len );
buffer = Z_STRVAL_P( param_z );
buffer_len = Z_STRLEN_P( param_z );
}
// since this is an output string, assure there is enough space to hold the requested size and
// set all the variables necessary (param_z, buffer, buffer_len, and ind_ptr)
resize_output_buffer_if_necessary( stmt, param_z, param_num, encoding, c_type, sql_type, column_size, decimal_digits,
buffer, buffer_len TSRMLS_CC );
// if it's a UTF-8 input output parameter (signified by the C type being SQL_C_WCHAR)
// or if the PHP type is a binary encoded string with a N(VAR)CHAR/NTEXTSQL type,
// convert it to wchar first
if( direction == SQL_PARAM_INPUT_OUTPUT &&
( c_type == SQL_C_WCHAR ||
( c_type == SQL_C_BINARY &&
( sql_type == SQL_WCHAR ||
sql_type == SQL_WVARCHAR ||
sql_type == SQL_WLONGVARCHAR )))){
// save the parameter to be adjusted and/or converted after the results are processed
sqlsrv_output_param output_param( param_ref, encoding, param_num, static_cast<SQLUINTEGER>( buffer_len ), zval_was_long );
bool converted = convert_input_param_to_utf16( param_z, param_z );
CHECK_CUSTOM_ERROR( !converted, stmt, SQLSRV_ERROR_INPUT_PARAM_ENCODING_TRANSLATE,
param_num + 1, get_last_error_message() ){
throw core::CoreException();
}
buffer = Z_STRVAL_P( param_z );
buffer_len = Z_STRLEN_P( param_z );
ind_ptr = buffer_len;
}
save_output_param_for_later( stmt, output_param TSRMLS_CC );
// since this is an output string, assure there is enough space to hold the requested size and
// set all the variables necessary (param_z, buffer, buffer_len, and ind_ptr)
resize_output_buffer_if_necessary( stmt, param_z, param_num, encoding, c_type, sql_type, column_size, decimal_digits,
buffer, buffer_len TSRMLS_CC );
// For output parameters, if we set the column_size to be same as the buffer_len,
// then if there is a truncation due to the data coming from the server being
// greater than the column_size, we don't get any truncation error. In order to
// avoid this silent truncation, we set the column_size to be "MAX" size for
// string types. This will guarantee that there is no silent truncation for
// output parameters.
// if column encryption is enabled, at this point the correct column size has been set by SQLDescribeParam
if( direction == SQL_PARAM_OUTPUT && !stmt->conn->ce_option.enabled ) {
switch( sql_type ) {
// save the parameter to be adjusted and/or converted after the results are processed
sqlsrv_output_param output_param( param_ref, encoding, param_num, static_cast<SQLUINTEGER>( buffer_len ), zval_was_long );
save_output_param_for_later( stmt, output_param TSRMLS_CC );
// For output parameters, if we set the column_size to be same as the buffer_len,
// then if there is a truncation due to the data coming from the server being
// greater than the column_size, we don't get any truncation error. In order to
// avoid this silent truncation, we set the column_size to be "MAX" size for
// string types. This will guarantee that there is no silent truncation for
// output parameters.
// if column encryption is enabled, at this point the correct column size has been set by SQLDescribeParam
if( direction == SQL_PARAM_OUTPUT && !stmt->conn->ce_option.enabled ){
switch( sql_type ){
case SQL_VARBINARY:
case SQL_VARCHAR:
case SQL_WVARCHAR:
case SQL_WVARCHAR:
column_size = SQL_SS_LENGTH_UNLIMITED;
break;
default:
break;
}
}
}
}
@ -624,36 +664,36 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
zend_class_entry *class_entry = Z_OBJCE_P( param_z TSRMLS_CC );
while( class_entry != NULL ) {
while( class_entry != NULL ){
SQLSRV_ASSERT( class_entry->name != NULL, "core_sqlsrv_bind_param: class_entry->name is NULL." );
if( class_entry->name->len == DateTime::DATETIME_CLASS_NAME_LEN && class_entry->name != NULL &&
stricmp( class_entry->name->val, DateTime::DATETIME_CLASS_NAME ) == 0 ) {
stricmp( class_entry->name->val, DateTime::DATETIME_CLASS_NAME ) == 0 ){
valid_class_name_found = true;
break;
}
else {
else{
// Check the parent
class_entry = class_entry->parent;
}
}
CHECK_CUSTOM_ERROR( !valid_class_name_found, stmt, SQLSRV_ERROR_INVALID_PARAMETER_PHPTYPE, param_num + 1 ) {
CHECK_CUSTOM_ERROR( !valid_class_name_found, stmt, SQLSRV_ERROR_INVALID_PARAMETER_PHPTYPE, param_num + 1 ){
throw core::CoreException();
}
// if the user specifies the 'date' sql type, giving it the normal format will cause a 'date overflow error'
// meaning there is too much information in the character string. If the user specifies the 'datetimeoffset'
// sql type, it lacks the timezone.
if( sql_type == SQL_SS_TIMESTAMPOFFSET ) {
if( sql_type == SQL_SS_TIMESTAMPOFFSET ){
core::sqlsrv_zval_stringl( &format_z, const_cast<char*>( DateTime::DATETIMEOFFSET_FORMAT ),
DateTime::DATETIMEOFFSET_FORMAT_LEN );
}
else if( sql_type == SQL_TYPE_DATE ) {
else if( sql_type == SQL_TYPE_DATE ){
core::sqlsrv_zval_stringl( &format_z, const_cast<char*>( DateTime::DATE_FORMAT ), DateTime::DATE_FORMAT_LEN );
}
else {
else{
core::sqlsrv_zval_stringl( &format_z, const_cast<char*>( DateTime::DATETIME_FORMAT ), DateTime::DATETIME_FORMAT_LEN );
}
// call the DateTime::format member function to convert the object to a string that SQL Server understands
@ -664,12 +704,12 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
int zr = call_user_function( EG( function_table ), param_z, &function_z, &buffer_z, 1, params TSRMLS_CC );
zend_string_release( Z_STR( format_z ));
zend_string_release( Z_STR( function_z ));
CHECK_CUSTOM_ERROR( zr == FAILURE, stmt, SQLSRV_ERROR_INVALID_PARAMETER_PHPTYPE, param_num + 1 ) {
CHECK_CUSTOM_ERROR( zr == FAILURE, stmt, SQLSRV_ERROR_INVALID_PARAMETER_PHPTYPE, param_num + 1 ){
throw core::CoreException();
}
buffer = Z_STRVAL( buffer_z );
zr = add_next_index_zval( &( stmt->param_datetime_buffers ), &buffer_z );
CHECK_CUSTOM_ERROR( zr == FAILURE, stmt, SQLSRV_ERROR_INVALID_PARAMETER_PHPTYPE, param_num + 1 ) {
CHECK_CUSTOM_ERROR( zr == FAILURE, stmt, SQLSRV_ERROR_INVALID_PARAMETER_PHPTYPE, param_num + 1 ){
throw core::CoreException();
}
buffer_len = Z_STRLEN( buffer_z ) - 1;
@ -685,7 +725,7 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
break;
}
if( zval_was_null ) {
if( zval_was_null ){
ind_ptr = SQL_NULL_DATA;
}
@ -693,13 +733,13 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
c_type, sql_type, column_size, decimal_digits, buffer, buffer_len, &ind_ptr TSRMLS_CC );
if ( stmt->conn->ce_option.enabled && sql_type == SQL_TYPE_TIMESTAMP )
{
if ( decimal_digits == 3 )
if( decimal_digits == 3 )
core::SQLSetDescField( stmt, param_num + 1, SQL_CA_SS_SERVER_TYPE, (SQLPOINTER)SQL_SS_TYPE_DATETIME, 0 );
else if (decimal_digits == 0)
core::SQLSetDescField( stmt, param_num + 1, SQL_CA_SS_SERVER_TYPE, (SQLPOINTER)SQL_SS_TYPE_SMALLDATETIME, 0 );
}
}
catch( core::CoreException& e ) {
catch( core::CoreException& e ){
stmt->free_param_data( TSRMLS_C );
SQLFreeStmt( stmt->handle(), SQL_RESET_PARAMS );
throw e;

5
source/sqlsrv/util.cpp
View file

@ -408,6 +408,11 @@ ss_error SS_ERRORS[] = {
SQLSRV_ERROR_SPECIFIED_DRIVER_NOT_FOUND,
{ IMSSP, (SQLCHAR*) "The specified ODBC Driver is not found.", -107, false }
},
{
SQLSRV_ERROR_OUTPUT_PARAM_TYPES_NOT_SUPPORTED,
{ IMSSP, (SQLCHAR*) "Stored Procedures do not support text, ntext or image as OUTPUT parameters.", -108, false }
},
// terminate the list of errors/warnings
{ UINT_MAX, {} }
};

12
test/functional/pdo_sqlsrv/AEData.inc
View file

@ -62,11 +62,11 @@ $pdoParamTypes = array(
// Checks if the current error is the incompatible types error
// if so, state which sql type is incompatible with which data type
function is_incompatible_types_error( $stmt, $dataType, $pdoParamType ) {
if ( $stmt->errorInfo()[0] == "22018" )
function isIncompatibleTypesError($stmt, $dataType, $pdoParamType)
{
if ($stmt->errorInfo()[0] == "22018") {
echo "PDO param type $pdoParamType is incompatible with encrypted $dataType\n";
else
var_dump( $stmt->errorInfo() );
} else {
var_dump($stmt->errorInfo());
}
}
?>

154
test/functional/pdo_sqlsrv/MsCommon.inc
View file

@ -12,7 +12,6 @@
// looks like an additional file (in addition to pdo_test_base.inc) may be needed for these PHPTs
// to be runnable from the MSSQL teams' internal proprietary test running system
//
require 'MsData.inc';
function IsAEQualified($conn)
{
@ -35,9 +34,7 @@ function connect($options=array())
require 'MsSetup.inc';
$conn = new PDO( "sqlsrv:Server=$server;database=$databaseName;ConnectionPooling=false;" , $uid, $pwd, $options);
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
create_and_insert_table1($conn);
create_and_insert_table2($conn);
return $conn;
return $conn;
}
catch( PDOException $e )
@ -447,155 +444,6 @@ function is_col_enc()
return true;
}
// Create and insert
function create_and_insert_table1( $conn )
{
global $string_col, $date_col, $large_string_col, $xml_col, $binary_col, $int_col, $decimal_col, $guid_col, $null_col, $comma, $closing_brace, $table1;
try
{
$create_query =
"IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'" . $table1 . "') AND type in (N'U'))
DROP TABLE " . $table1 .
" CREATE TABLE [dbo].[" . $table1 . "](
[IntCol] [int] NULL,
[CharCol] [char](10) NULL,
[NCharCol] [nchar](10) NULL,
[DateTimeCol] [datetime] NULL,
[VarcharCol] [varchar](50) NULL,
[NVarCharCol] [nvarchar](50) NULL,
[FloatCol] [float] NULL,
[XmlCol] [xml] NULL
) ON [PRIMARY]
";
$conn->query( $create_query );
for ($i = 0 ; $i <= 1; ++ $i)
{
$insert_query =
"INSERT INTO PDO_Types_1 VALUES (".
$int_col[$i] . $comma .
$string_col[$i] . $comma .
$string_col[$i] . $comma .
"Convert(datetime, ". $date_col[$i] . ")" . $comma .
$string_col[$i] . $comma .
$string_col[$i] . $comma .
$decimal_col[$i] . $comma .
$xml_col[$i] .
")";
$conn->query ( $insert_query );
}
}
catch(Exception $e)
{
var_dump( $e);
exit;
}
}
function create_and_insert_table2( $conn )
{
try
{
//Timestamp is not present.
//VARIANT is not supported.
global $string_col, $date_col, $large_string_col, $xml_col, $binary_col, $int_col, $decimal_col, $guid_col, $null_col, $comma, $closing_brace, $table1, $table2;
$create_query =
"IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'".$table2."') AND type in (N'U')) DROP TABLE " . $table2 .
" CREATE TABLE " .$table2 . " (
[BigIntCol] [bigint] NULL,
[BinaryCol] [binary](5) NULL,
[BitCol] [bit] NULL,
[CharCol] [char](10) NULL,
[DateCol] [date] NULL,
[DateTimeCol] [datetime] NULL,
[DateTime2Col] [datetime2](7) NULL,
[DTOffsetCol] [datetimeoffset](7) NULL,
[DecimalCol] [decimal](18, 0) NULL,
[FloatCol] [float] NULL,
[ImageCol] [image] NULL,
[IntCol] [int] NULL,
[MoneyCol] [money] NULL,
[NCharCol] [nchar](10) NULL,
[NTextCol] [ntext] NULL,
[NumCol] [numeric](18, 0) NULL,
[NVarCharCol] [nvarchar](50) NULL,
[NVarCharMaxCol] [nvarchar](max) NULL,
[RealCol] [real] NULL,
[SmallDTCol] [smalldatetime] NULL,
[SmallIntCol] [smallint] NULL,
[SmallMoneyCol] [smallmoney] NULL,
[TextCol] [text] NULL,
[TimeCol] [time](7) NULL,
[TinyIntCol] [tinyint] NULL,
[Guidcol] [uniqueidentifier] NULL,
[VarbinaryCol] [varbinary](50) NULL,
[VarbinaryMaxCol] [varbinary](max) NULL,
[VarcharCol] [varchar](50) NULL,
[VarcharMaxCol] [varchar](max) NULL,
[XmlCol] [xml] NULL
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
";
$stmt = $conn->query( $create_query );
for ($i =0; $i<= 0 ; ++ $i)
{
$insert_query =
" INSERT INTO " .$table2 . " VALUES (".
$int_col[$i] . $comma .
$binary_col[$i] . $comma .
"0" . $comma .
$string_col[$i] . $comma .
"Convert(date, ". $date_col[$i] . $closing_brace .
"Convert(datetime, ". $date_col[$i] . $closing_brace .
"Convert(datetime2(7),". $date_col[$i] . $closing_brace .
"Convert(datetimeoffset(7)," . $date_col[$i] . $closing_brace .
$decimal_col[$i] . $comma .
$decimal_col[$i] .$comma .
$binary_col[$i] . $comma .
$int_col[$i] . $comma .
$decimal_col[$i] . $comma .
$string_col[$i]. $comma .
$large_string_col[$i]. $comma.
$int_col[$i]. $comma .
$string_col[$i]. $comma .
$large_string_col[$i]. $comma .
$decimal_col[$i]. $comma .
"Convert(smalldatetime, ". $date_col[$i]. $closing_brace .
$int_col[$i]. $comma .
$decimal_col[$i]. $comma .
$large_string_col[$i]. $comma .
"Convert(time(7), ". $date_col[$i] . $closing_brace .
$int_col[$i] . $comma .
$guid_col[$i] . $comma .
$binary_col[$i] . $comma .
$binary_col[$i] . $comma .
$string_col[$i] . $comma .
$large_string_col[$i] . $comma .
$xml_col[$i] .
")";
$stmt = $conn->query ($insert_query );
}
}
catch(Exception $e)
{
var_dump( $e);
exit;
}
}
function teardown()
{
// TBD

181
test/functional/pdo_sqlsrv/MsCommon_mid-refactor.inc
View file

@ -12,7 +12,6 @@
// looks like an additional file (in addition to pdo_test_base.inc) may be needed for these PHPTs
// to be runnable from the MSSQL teams' internal proprietary test running system
//
require 'MsData.inc';
function isAEQualified($conn)
{
@ -127,19 +126,21 @@ class ColumnMeta
{
public $dataType; //a string that includes the size of the type if necessary (e.g., decimal(10,5))
public $colName; //column name
public $encType; //randomized or deterministic; default is deterministic
public $options; //a string that is null by default (e.g. NOT NULL Identity (1,1) )
public $encType; //randomized or deterministic; default is deterministic
public $forceEncrypt; //force encryption on a datatype no supported by Column Encrypton
public function __construct($dataType, $colName = null, $options = null, $encType = "deterministic")
public function __construct($dataType, $colName = null, $options = null, $encType = "deterministic", $forceEncrypt = false)
{
if (is_null($colName)) {
$this->colName = get_default_colname($dataType);
$this->colName = getDefaultColName($dataType);
} else {
$this->colName = $colName;
}
$this->dataType = $dataType;
$this->encType = $encType;
$this->options = $options;
$this->encType = $encType;
$this->forceEncrypt = $forceEncrypt;
}
/**
* @return string column definition for creating a table
@ -150,7 +151,7 @@ class ColumnMeta
$append = " ";
// an identity column is not encrypted because a select query with identity column as the where clause is often run and the user want to have to bind parameter every time
if (isColEncrypted() && stripos($this->options, "identity") === false) {
if (isColEncrypted() && $this->isEncryptableType() && stripos($this->options, "identity") === false) {
$cekName = getCekName();
if (stripos($this->dataType, "char") !== false) {
$append .= "COLLATE Latin1_General_BIN2 ";
@ -161,6 +162,19 @@ class ColumnMeta
$colDef = "[" . $this->colName . "] " . $this->dataType . $append;
return $colDef;
}
/**
* @return bool if the datatype for this column is encryptable
*/
public function isEncryptableType()
{
$unsupportedTypes = array("money", "smallmoney", "image", "ntext", "text", "xml", "sql_variant");
if (!$this->forceEncrypt && in_array(strtolower($this->dataType), $unsupportedTypes)) {
return false;
} else {
return true;
}
}
}
@ -183,9 +197,10 @@ function getDefaultColName($dataType)
* @param array $inputs : an associative array column name and its value; value may be a literal value or a ColumnMeta object
* @param bool $disableCE : flag for disabling column encryption even when keystore is NOT none
* for creating table with datatypes not support for encryption
* @param string $tableOption : table options appended to the end of a create table statement
* @return int reporting the number of rows affected (should always be 0 for creating table)
*/
function createTable($conn, $tbname, $columnMetaArr, $disableCE = false)
function createTable($conn, $tbname, $columnMetaArr, $tableOption = '', $disableCE = false)
{
try {
dropTable($conn, $tbname);
@ -202,7 +217,7 @@ function createTable($conn, $tbname, $columnMetaArr, $disableCE = false)
}
}
$colDef = rtrim($colDef, ", ");
$createSql = "CREATE TABLE $tbname ($colDef)";
$createSql = "CREATE TABLE $tbname ($colDef) $tableOption";
$numRows = $conn->exec($createSql);
return $numRows;
} catch (PDOException $e) {
@ -231,14 +246,14 @@ class BindParamOp
$this->variable = $variable;
$pdoParams = array("PDO::PARAM_BOOL", "PDO::PARAM_NULL", "PDO::PARAM_INT", "PDO::PARAM_STR", "PDO::PARAM_LOB");
if (in_array($pdoType, $pdoParams)) {
if (in_array($pdoType, $pdoParams) || is_null($pdoType)) {
$this->pdoType = $pdoType;
} else {
prinft("BindParamOp construct: The pdoType provided must be one of PDO::PARAM_BOOL, PDO::PARAM_NULL, PDO::PARAM_INT, PDO::PARAM_STR, or PDO::PARAM_LOB.\n");
printf("BindParamOp construct: The pdoType provided must be one of PDO::PARAM_BOOL, PDO::PARAM_NULL, PDO::PARAM_INT, PDO::PARAM_STR, or PDO::PARAM_LOB.\n");
exit;
}
if ($length >= 0) {
if ($length >= 0 || is_null($length)) {
$this->length = $length;
} else {
printf("BindParamOp construct: The length provided must be greater or equal to 0.\n");
@ -246,7 +261,7 @@ class BindParamOp
}
$encodingAttrs = array("PDO::SQLSRV_ENCODING_BINARY", "PDO::SQLSRV_ENCODING_SYSTEM", "PDO::SQLSRV_ENCODING_UTF8", "PDO::SQLSRV_ENCODING_DEFAULT");
if (in_array($options, $encodingAttrs)) {
if (in_array($options, $encodingAttrs) || is_null($options)) {
$this->options = $options;
} else {
printf("BindParamOp construct: The option provided must be one of PDO::SQLSRV_ENCODING_BINARY, PDO::SQLSRV_ENCODING_SYSTEM, PDO::SQLSRV_ENCODING_UTF8, PDO::SQLSRV_ENCODING_DEFAULT");
@ -508,146 +523,6 @@ function isColEncrypted()
}
}
// Create and insert
function create_and_insert_table1($conn)
{
global $string_col, $date_col, $large_string_col, $xml_col, $binary_col, $int_col, $decimal_col, $guid_col, $null_col, $comma, $closing_brace, $table1;
try {
$create_query =
"IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'" . $table1 . "') AND type in (N'U'))
DROP TABLE " . $table1 .
" CREATE TABLE [dbo].[" . $table1 . "](
[IntCol] [int] NULL,
[CharCol] [char](10) NULL,
[NCharCol] [nchar](10) NULL,
[DateTimeCol] [datetime] NULL,
[VarcharCol] [varchar](50) NULL,
[NVarCharCol] [nvarchar](50) NULL,
[FloatCol] [float] NULL,
[XmlCol] [xml] NULL
) ON [PRIMARY]
";
$conn->query($create_query);
for ($i = 0 ; $i <= 1; ++ $i) {
$insert_query =
"INSERT INTO PDO_Types_1 VALUES (".
$int_col[$i] . $comma .
$string_col[$i] . $comma .
$string_col[$i] . $comma .
"Convert(datetime, ". $date_col[$i] . ")" . $comma .
$string_col[$i] . $comma .
$string_col[$i] . $comma .
$decimal_col[$i] . $comma .
$xml_col[$i] .
")";
$conn->query($insert_query);
}
} catch (Exception $e) {
var_dump($e);
exit;
}
}
function create_and_insert_table2($conn)
{
try {
//Timestamp is not present.
//VARIANT is not supported.
global $string_col, $date_col, $large_string_col, $xml_col, $binary_col, $int_col, $decimal_col, $guid_col, $null_col, $comma, $closing_brace, $table1, $table2;
$create_query =
"IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'".$table2."') AND type in (N'U')) DROP TABLE " . $table2 .
" CREATE TABLE " .$table2 . " (
[BigIntCol] [bigint] NULL,
[BinaryCol] [binary](5) NULL,
[BitCol] [bit] NULL,
[CharCol] [char](10) NULL,
[DateCol] [date] NULL,
[DateTimeCol] [datetime] NULL,
[DateTime2Col] [datetime2](7) NULL,
[DTOffsetCol] [datetimeoffset](7) NULL,
[DecimalCol] [decimal](18, 0) NULL,
[FloatCol] [float] NULL,
[ImageCol] [image] NULL,
[IntCol] [int] NULL,
[MoneyCol] [money] NULL,
[NCharCol] [nchar](10) NULL,
[NTextCol] [ntext] NULL,
[NumCol] [numeric](18, 0) NULL,
[NVarCharCol] [nvarchar](50) NULL,
[NVarCharMaxCol] [nvarchar](max) NULL,
[RealCol] [real] NULL,
[SmallDTCol] [smalldatetime] NULL,
[SmallIntCol] [smallint] NULL,
[SmallMoneyCol] [smallmoney] NULL,
[TextCol] [text] NULL,
[TimeCol] [time](7) NULL,
[TinyIntCol] [tinyint] NULL,
[Guidcol] [uniqueidentifier] NULL,
[VarbinaryCol] [varbinary](50) NULL,
[VarbinaryMaxCol] [varbinary](max) NULL,
[VarcharCol] [varchar](50) NULL,
[VarcharMaxCol] [varchar](max) NULL,
[XmlCol] [xml] NULL
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
";
$stmt = $conn->query($create_query);
for ($i =0; $i<= 0 ; ++ $i) {
$insert_query =
" INSERT INTO " .$table2 . " VALUES (".
$int_col[$i] . $comma .
$binary_col[$i] . $comma .
"0" . $comma .
$string_col[$i] . $comma .
"Convert(date, ". $date_col[$i] . $closing_brace .
"Convert(datetime, ". $date_col[$i] . $closing_brace .
"Convert(datetime2(7),". $date_col[$i] . $closing_brace .
"Convert(datetimeoffset(7)," . $date_col[$i] . $closing_brace .
$decimal_col[$i] . $comma .
$decimal_col[$i] .$comma .
$binary_col[$i] . $comma .
$int_col[$i] . $comma .
$decimal_col[$i] . $comma .
$string_col[$i]. $comma .
$large_string_col[$i]. $comma.
$int_col[$i]. $comma .
$string_col[$i]. $comma .
$large_string_col[$i]. $comma .
$decimal_col[$i]. $comma .
"Convert(smalldatetime, ". $date_col[$i]. $closing_brace .
$int_col[$i]. $comma .
$decimal_col[$i]. $comma .
$large_string_col[$i]. $comma .
"Convert(time(7), ". $date_col[$i] . $closing_brace .
$int_col[$i] . $comma .
$guid_col[$i] . $comma .
$binary_col[$i] . $comma .
$binary_col[$i] . $comma .
$string_col[$i] . $comma .
$large_string_col[$i] . $comma .
$xml_col[$i] .
")";
$stmt = $conn->query($insert_query);
}
} catch (Exception $e) {
var_dump($e);
exit;
}
}
function teardown()
{
// TBD
@ -1366,7 +1241,7 @@ function CreateTableEx($conn, $tableName, $dataType)
{
Trace("Creating table $tableName ...");
$tsql = "CREATE TABLE [$tableName] ($dataType)";
DropTable($conn, $tableName);
dropTable($conn, $tableName);
if (IsPdoMode()) {
$outcome = $conn->exec($tsql);

65
test/functional/pdo_sqlsrv/MsData.inc
View file

@ -1,65 +0,0 @@
<?php
/*
Microsoft SQL Server Driver for PHP - Unit Test Framework
Copyright (c) Microsoft Corporation. All rights reserved.
Description:
Random data generator for INSERT statements.
*/
// globals
$table1 = "PDO_Types_1";
$table2= "PDO_AllTypes";
$large_string = "This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.";
$string_col = array("'STRINGCOL1'", "'STRINGCOL2'");
$date_col = array("'2000-11-11 11:11:11.111'", "'2000-11-11 11:11:11.222'");
$large_string_col = array("' 1 " . $large_string . "'", "' 2 " . $large_string . "'");
$xml_col = array("'<xml> 1 " . $large_string . "</xml>'", "'<xml> 2 " . $large_string . "</xml>'");
$binary_col = array('0x0', '0x0');
$int_col = array ( 1, 2);
$decimal_col = array (111.111, 222.222);
$guid_col = array("'AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA'", "'BBBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB'");
$null_col = 'null';
$comma = ",";
$closing_brace = "),";
class PDO_Types_1_Class{
var $IntCol;
var $CharCol;
var $NCharCol;
var $DateTimeCol;
var $VarcharCol;
var $NVarCharCol;
var $FloatCol;
var $XmlCol;
function dumpAll()
{
var_dump($this->IntCol);
var_dump($this->CharCol);
var_dump($this->NCharCol);
var_dump($this->DateTimeCol);
var_dump($this->VarcharCol);
var_dump($this->NVarCharCol);
var_dump($this->FloatCol);
var_dump($this->XmlCol);
}
}
$table1_class = 'PDO_Types_1_Class';
?>

205
test/functional/pdo_sqlsrv/MsData_PDO_AllTypes.inc Normal file
View file

@ -0,0 +1,205 @@
<?php
/*
Microsoft SQL Server Driver for PHP - Unit Test Framework
Copyright (c) Microsoft Corporation. All rights reserved.
Description:
Random data generator for INSERT statements.
*/
// globals
$int_col = array(1, 2);
$bin = fopen('php://memory', 'a');
fwrite($bin, '00');
rewind($bin);
$binary_col = array($bin, $bin);
$string_col = array("STRINGCOL1", "STRINGCOL2");
$decimal_col = array(111.111, 222.222);
$large_string = "This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.";
$date_col = array('2000-11-11', '2000-11-11');
$datetime_col = array('2000-11-11 11:11:11.111', '2000-11-11 11:11:11.222');
$datetime2_col = array('2000-11-11 11:11:11.111', '2000-11-11 11:11:11.222');
$dtoffset_col = array('2000-11-11 11:11:11.111 +00:00', '2000-11-11 11:11:11.222 +00:00');
$smalldt_col = array('2000-11-11 11:11:00', '2000-11-11 11:11:00');
$timeCol = array('11:11:11.111', '11:11:11.222');
$large_string_col = array(" 1 " . $large_string . "", " 2 " . $large_string . "");
$guid_col = array("AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA", "BBBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB");
$xml_col = array("<xml> 1 " . $large_string . "</xml>", "<xml> 2 " . $large_string . "</xml>");
$null_col = 'null';
$mainTypesClass = 'PDO_MainTypesClass';
class PDO_MainTypesClass
{
public $IntCol;
public $CharCol;
public $NCharCol;
public $DateTimeCol;
public $VarcharCol;
public $NVarCharCol;
public $FloatCol;
public $XmlCol;
public function dumpAll()
{
var_dump($this->IntCol);
var_dump($this->CharCol);
var_dump($this->NCharCol);
var_dump($this->DateTimeCol);
var_dump($this->VarcharCol);
var_dump($this->NVarCharCol);
var_dump($this->FloatCol);
var_dump($this->XmlCol);
}
}
function createTableMainTypes($conn, $tbname)
{
try {
require_once("MsCommon_mid-refactor.inc");
$columnMetaArr = array("IntCol" => "int",
"CharCol" => "char(10)",
"NCharCol" => "nchar(10)",
"DateTimeCol" => "datetime",
"VarcharCol" => "varchar(50)",
"NVarCharCol" => "nvarchar(50)",
"FloatCol" => "float",
"XmlCol" => "xml");
createTable($conn, $tbname, $columnMetaArr, "ON [PRIMARY]");
} catch (Exception $e) {
var_dump($e);
exit;
}
}
function insertIntoTableMainTypes($conn, $tbname, $rownum)
{
try {
require_once("MsCommon_mid-refactor.inc");
global $string_col, $date_col, $large_string_col, $xml_col, $binary_col, $int_col, $decimal_col, $guid_col, $datetime_col, $datetime2_col, $dtoffset_col, $smalldt_col, $timeCol;
$inputs = array("IntCol" => $int_col[$rownum],
"CharCol" => $string_col[$rownum],
"NCharCol" => $string_col[$rownum],
"DateTimeCol" => $datetime_col[$rownum],
"VarcharCol" => $string_col[$rownum],
"NVarCharCol" => $string_col[$rownum],
"FloatCol" => $decimal_col[$rownum],
"XmlCol" => $xml_col[$rownum]);
$stmt = insertRow($conn, $tbname, $inputs, "prepareBindParam");
} catch (Exception $e) {
var_dump($e);
exit;
}
}
function createAndInsertTableMainTypes($conn, $tbname, $rows = array(0, 1))
{
createTableMainTypes($conn, $tbname);
foreach ($rows as $rownum) {
insertIntoTableMainTypes($conn, $tbname, $rownum);
}
}
function createTableAllTypes($conn, $tbname)
{
try {
require_once("MsCommon_mid-refactor.inc");
$columnMetaArr = array("BigIntCol" => "bigint",
"BinaryCol" => "binary(5)",
"BitCol" => "bit",
"CharCol" => "char(10)",
"DateCol" => "date",
"DateTimeCol" => "datetime",
"DateTime2Col" => "datetime2(7)",
"DTOffsetCol" => "datetimeoffset(7)",
"DecimalCol" => "decimal(18,0)",
"FloatCol" => "float",
"ImageCol" => "image",
"IntCol" => "int",
"MoneyCol" => "money",
"NCharCol" => "nchar(10)",
"NTextCol" => "ntext",
"NumCol" => "numeric(18,0)",
"NVarCharCol" => "nvarchar(50)",
"NVarCharMaxCol" => "nvarchar(max)",
"RealCol" => "real",
"SmallDTCol" => "smalldatetime",
"SmallIntCol" => "smallint",
"SmallMoneyCol" => "smallmoney",
"TextCol" => "text",
"TimeCol" => "time(7)",
"TinyIntCol" => "tinyint",
"Guidcol" => "uniqueidentifier",
"VarbinaryCol" => "varbinary(50)",
"VarbinaryMaxCol" => "varbinary(max)",
"VarcharCol" => "varchar(50)",
"VarcharMaxCol" => "varchar(max)",
"XmlCol" => "xml");
createTable($conn, $tbname, $columnMetaArr, "ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]");
} catch (Exception $e) {
var_dump($e);
exit;
}
}
function insertIntoTableAllTypes($conn, $tbname, $rownum)
{
try {
require_once("MsCommon_mid-refactor.inc");
global $string_col, $date_col, $large_string_col, $xml_col, $binary_col, $int_col, $decimal_col, $guid_col, $datetime_col, $datetime2_col, $dtoffset_col, $smalldt_col, $timeCol;
$inputs = array("BigIntCol" => $int_col[$rownum],
"BinaryCol" => new BindParamOp(2, $binary_col[$rownum], "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"BitCol" => 0,
"CharCol" => $string_col[$rownum],
"DateCol" => $date_col[$rownum],
"DateTimeCol" => $datetime_col[$rownum],
"DateTime2Col" => $datetime2_col[$rownum],
"DTOffsetCol" => $dtoffset_col[$rownum],
"DecimalCol" => $decimal_col[$rownum],
"FloatCol" => $decimal_col[$rownum],
"ImageCol" => new BindParamOp(11, $binary_col[$rownum], "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"IntCol" => $int_col[$rownum],
"MoneyCol" => $decimal_col[$rownum],
"NCharCol" => $string_col[$rownum],
"NTextCol" => $large_string_col[$rownum],
"NumCol" => $int_col[$rownum],
"NVarCharCol" => $string_col[$rownum],
"NVarCharMaxCol" => $large_string_col[$rownum],
"RealCol" => $decimal_col[$rownum],
"SmallDTCol" => $smalldt_col[$rownum],
"SmallIntCol" => $int_col[$rownum],
"SmallMoneyCol" => $decimal_col[$rownum],
"TextCol" => $large_string_col[$rownum],
"TimeCol" => $timeCol[$rownum],
"TinyIntCol" => $int_col[$rownum],
"Guidcol" => $guid_col[$rownum],
"VarbinaryCol" => new BindParamOp(27, $binary_col[$rownum], "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"VarbinaryMaxCol" => new BindParamOp(28, $binary_col[$rownum], "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"VarcharCol" => $string_col[$rownum],
"VarcharMaxCol" => $large_string_col[$rownum],
"XmlCol" => $xml_col[$rownum]);
$stmt = insertRow($conn, $tbname, $inputs, "prepareBindParam");
} catch (Exception $e) {
var_dump($e);
exit;
}
}
function createAndInsertTableAllTypes($conn, $tbname, $rows = array(0))
{
createTableAllTypes($conn, $tbname);
foreach ($rows as $rownum) {
insertIntoTableAllTypes($conn, $tbname, $rownum);
}
}

55
test/functional/pdo_sqlsrv/PDO11_Drivers.phpt
View file

@ -1,60 +1,23 @@
--TEST--
PDO Drivers Info Test
--DESCRIPTION--
Verifies the functionality of "PDO:getAvailableDrivers()”.
Verifies the functionality of "PDO:getAvailableDrivers()".
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
function DriversInfo()
{
include 'MsSetup.inc';
$testName = "PDO - Drivers";
StartTest($testName);
try {
$drivers = PDO::getAvailableDrivers();
if (in_array("sqlsrv", $drivers))
{
$count = count($drivers);
for ($i = 0; $i < $count; $i++)
{
Trace("Driver #".($i + 1).": ".$drivers[$i]."\n");
}
}
else
{
if (!in_array("sqlsrv", $drivers)) {
printf("$PhpDriver is missing.\n");
} else {
printf("Done\n");
}
EndTest($testName);
} catch (Exception $e) {
echo $e->getMessage();
}
//--------------------------------------------------------------------
// Repro
//
//--------------------------------------------------------------------
function Repro()
{
try
{
DriversInfo();
}
catch (Exception $e)
{
echo $e->getMessage();
}
}
Repro();
?>
--EXPECT--
Test "PDO - Drivers" completed successfully.
Done

51
test/functional/pdo_sqlsrv/PDO12_Info.phpt
View file

@ -5,57 +5,26 @@ Verifies the functionality of PDO with phpinfo().
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
function DriversInfo()
{
include 'MsSetup.inc';
$testName = "PDO - phpinfo";
StartTest($testName);
try {
ob_start();
phpinfo();
$info = ob_get_contents();
ob_end_clean();
// Check phpinfo() data
if (stristr($info, "PDO support => enabled") === false)
{
if (stristr($info, "PDO support => enabled") === false) {
printf("PDO is not enabled\n");
} elseif (stristr($info, "pdo_sqlsrv support => enabled") === false) {
printf("Cannot find PDO_SQLSRV driver in phpinfo() output\n");
} else {
printf("Done\n");
}
else if (stristr($info, "pdo_sqlsrv support => enabled") === false)
{
printf("Cannot find PDO driver line in phpinfo() output\n");
}
EndTest($testName);
} catch (Exception $e) {
echo $e->getMessage();
}
//--------------------------------------------------------------------
// Repro
//
//--------------------------------------------------------------------
function Repro()
{
try
{
DriversInfo();
}
catch (Exception $e)
{
echo $e->getMessage();
}
}
Repro();
?>
--EXPECT--
Test "PDO - phpinfo" completed successfully.
Done

65
test/functional/pdo_sqlsrv/PDO21_Connection.phpt
View file

@ -6,57 +6,32 @@ Verifies as well that invalid connection attempts fail as expected.
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
function ConnectionTest()
{
include 'MsSetup.inc';
$testName = "PDO Connection";
StartTest($testName);
require_once("MsSetup.inc");
require_once("MsCommon_mid-refactor.inc");
try {
// Invalid connection attempt => errors are expected
Trace("Invalid connection attempt (to a non-existing server) ....\n");
$conn1 = PDOConnect('PDO', "InvalidServerName", $uid, $pwd, false);
if ($conn1)
{
$serverName="InvalidServerName";
$dsn = getDSN($serverName, $databaseName);
$conn1 = new PDO($dsn, $uid, $pwd, $connectionOptions);
if ($conn1) {
printf("Invalid connection attempt should have failed.\n");
}
$conn1 = null;
unset($conn1);
} catch (Exception $e) {
unset($conn1);
echo "Done\n";
}
try {
// Valid connection attempt => no errors are expected
Trace("\nValid connection attempt (to $server) ....\n");
$conn2 = Connect();
$conn2 = null;
EndTest($testName);
$conn2 = connect();
unset($conn2);
} catch (Exception $e) {
echo $e->getMessage();
}
//--------------------------------------------------------------------
// Repro
//
//--------------------------------------------------------------------
function Repro()
{
try
{
ConnectionTest();
}
catch (Exception $e)
{
echo $e->getMessage();
}
}
Repro();
?>
--EXPECT--
Test "PDO Connection" completed successfully.
Done

74
test/functional/pdo_sqlsrv/PDO24_ErrorCode.phpt
View file

@ -5,76 +5,46 @@ Verification of PDO::errorCode()
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
function CheckErrorCode()
{
include 'MsSetup.inc';
$testName = "PDO Connection - Error Code";
StartTest($testName);
$conn1 = Connect();
CheckError(1, $conn1, '00000');
require_once("MsCommon_mid-refactor.inc");
try {
$conn1 = connect();
checkError(1, $conn1);
// Prepare test table
$table1 = $tableName."1";
$table2 = $tableName."2";
CreateTableEx($conn1, $table1, "id int NOT NULL PRIMARY KEY, label VARCHAR(10)", null);
$table1 = "Table1";
createTable($conn1, $table1, array(new ColumnMeta("int", "id", "NOT NULL PRIMARY KEY"), "label" => "varchar(10)"));
// Check errors when executing SELECT queries
$stmt1 = $conn1->prepare("SELECT id, label FROM [$table1]");
CheckError(2, $conn1);
CheckError(3, $stmt1);
checkError(2, $conn1);
checkError(3, $stmt1);
$stmt1->execute();
$stmt2 = &$stmt1;
CheckError(4, $stmt1);
checkError(4, $stmt1);
$stmt1->closeCursor();
DropTable($conn1, $table1);
CheckError(5, $conn1);
dropTable($conn1, $table1);
checkError(5, $conn1);
// Cleanup
$stmt1 = null;
$conn1 = null;
EndTest($testName);
unset($stmt);
unset($conn);
echo "Done\n";
} catch (Exception $e) {
echo $e->getMessage();
}
function CheckError($offset, &$obj, $expected = '00000')
function checkError($offset, &$obj)
{
$code = $obj->errorCode();
if (($code != $expected) && (($expected != '00000') || ($code !='')))
{
printf("[%03d] Expecting error code '%s' got code '%s'\n",
$offset, $expected, $code);
$expected = '00000';
if ($code != $expected && !empty($code)) {
printf("[%03d] Expecting error code '%s' got code '%s'\n", $offset, $expected, $code);
}
}
//--------------------------------------------------------------------
// Repro
//
//--------------------------------------------------------------------
function Repro()
{
try
{
CheckErrorCode();
}
catch (Exception $e)
{
echo $e->getMessage();
}
}
Repro();
?>
--EXPECT--
Test "PDO Connection - Error Code" completed successfully.
Done

115
test/functional/pdo_sqlsrv/PDO25_ErrorInfo.phpt
View file

@ -5,112 +5,81 @@ Verification of PDO::errorInfo()
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
function CheckErrorInfo()
{
include 'MsSetup.inc';
$testName = "PDO Connection - Error Info";
StartTest($testName);
$conn1 = Connect();
CheckError(1, $conn1, '00000');
try {
$conn1 = connect("", array(), PDO::ERRMODE_SILENT);
checkError(1, $conn1, '00000');
// Prepare test table
$table1 = $tableName."1";
$table2 = $tableName."2";
CreateTableEx($conn1, $table1, "id int NOT NULL PRIMARY KEY, label VARCHAR(10)", null);
$table1 = "Table1";
$table2 = "Table2";
createTable($conn1, $table1, array(new ColumnMeta("int", "id", "NOT NULL PRIMARY KEY"), "label" => "varchar(10)"));
// Check errors when executing SELECT queries
$stmt1 = $conn1->prepare("SELECT id, label FROM [$table1]");
CheckError(2, $conn1);
CheckError(3, $stmt1);
checkError(2, $conn1);
checkError(3, $stmt1);
$stmt1->execute();
$stmt2 = &$stmt1;
CheckError(4, $stmt1);
checkError(4, $stmt1);
$stmt1->closeCursor();
//DropTable($conn1, $table1);
dropTable($conn1, $table1);
@$stmt1->execute();
CheckError(5, $conn1);
//CheckError(6, $stmt1, '42S02');
//CheckError(7, $stmt2, '42S02');
checkError(5, $conn1);
checkError(6, $stmt1, '42S02');
checkError(7, $stmt2, '42S02');
$stmt1->closeCursor();
DropTable($conn1, $table2);
dropTable($conn1, $table2);
$conn2 = &$conn1;
//@$conn1->query("SELECT id, label FROM [$table2]");
//CheckError(8, $conn1, '42S02');
//CheckError(9, $conn2, '42S02');
@$conn1->query("SELECT id, label FROM [$table2]");
checkError(8, $conn1, '42S02');
checkError(9, $conn2, '42S02');
createTable($conn1, $table1, array(new ColumnMeta("int", "id", "NOT NULL PRIMARY KEY"), "label" => "varchar(10)"));
CreateTableEx($conn1, $table1, "id int NOT NULL PRIMARY KEY, label VARCHAR(10)", null);
$stmt1 = $conn1->query("SELECT id, label FROM [$table1]");
CheckError(10, $conn1);
CheckError(11, $stmt1);
checkError(10, $conn1);
checkError(11, $stmt1);
$stmt1->closeCursor();
// @$conn1->query("SELECT id, label FROM [$table2]");
// CheckError(12, $conn1, '42S02');
// CheckError(13, $conn2, '42S02');
CheckError(14, $stmt1);
@$conn1->query("SELECT id, label FROM [$table2]");
checkError(12, $conn1, '42S02');
checkError(13, $conn2, '42S02');
checkError(14, $stmt1);
// Cleanup
DropTable($conn1, $table1);
$stmt1 = null;
$conn1 = null;
EndTest($testName);
dropTable($conn1, $table1);
unset($stmt1);
unset($conn1);
echo "Done\n";
} catch (Exception $e) {
echo $e->getMessage();
}
function CheckError($offset, &$obj, $expected = '00000')
function checkError($offset, &$obj, $expected = '00000')
{
$info = $obj->errorInfo();
$code = $info[0];
if (($code != $expected) && (($expected != '00000') || ($code != '')))
{
printf("[%03d] Expecting error code '%s' got code '%s'\n",
$offset, $expected, $code);
if (($code != $expected) && (($expected != '00000') || ($code != ''))) {
printf("[%03d] Expecting error code '%s' got code '%s'\n", $offset, $expected, $code);
}
if ($expected != '00000')
{
if (!isset($info[1]) || ($info[1] == ''))
{
if ($expected != '00000') {
if (!isset($info[1]) || ($info[1] == '')) {
printf("[%03d] Driver-specific error code not set\n", $offset);
}
if (!isset($info[2]) || ($info[2] == ''))
{
printf("[%03d] Driver-specific error message.not set\n", $offset);
if (!isset($info[2]) || ($info[2] == '')) {
printf("[%03d] Driver-specific error message not set\n", $offset);
}
}
}
//--------------------------------------------------------------------
// Repro
//
//--------------------------------------------------------------------
function Repro()
{
try
{
CheckErrorInfo();
}
catch (Exception $e)
{
echo $e->getMessage();
}
}
Repro();
?>
--EXPECT--
Test "PDO Connection - Error Info" completed successfully.
Done

94
test/functional/pdo_sqlsrv/break_pdo.php
View file

@ -3,7 +3,7 @@ require_once("MsSetup.inc");
// Using the test database for two tables specifically constructed
// for the connection resiliency tests
$dbName = $databaseName;
$dbName = $databaseName;
$tableName1 = "test_connres1";
$tableName2 = "test_connres2";
@ -12,73 +12,69 @@ $tableName2 = "test_connres2";
// Using generated tables will eventually allow us to put the
// connection resiliency tests on Github, since the integrated testing
// from AppVeyor does not have AdventureWorks.
function GenerateTables( $server, $uid, $pwd, $dbName, $tableName1, $tableName2 )
function generateTables($server, $uid, $pwd, $dbName, $tableName1, $tableName2)
{
$conn = new PDO( "sqlsrv:server = $server ; Database = $dbName ;", $uid, $pwd );
if ( $conn === false )
{
die ( print_r( sqlsrv_errors() ) );
try {
$conn = new PDO("sqlsrv:server = $server ; Database = $dbName ;", $uid, $pwd);
// Create table
$sql = "CREATE TABLE $tableName1 (c1 INT, c2 VARCHAR(40))";
$stmt = $conn->query($sql);
// Insert data
$sql = "INSERT INTO $tableName1 VALUES ( ?, ? )";
for ($t = 100; $t < 116; $t++) {
$stmt = $conn->prepare($sql);
$ts = substr(sha1($t), 0, 5);
$params = array( $t,$ts );
$stmt->execute($params);
}
// Create table
$sql = "CREATE TABLE $tableName2 ( c1 INT, c2 VARCHAR(40) )";
$stmt = $conn->query($sql);
// Insert data
$sql = "INSERT INTO $tableName2 VALUES ( ?, ? )";
for ($t = 200; $t < 209; $t++) {
$stmt = $conn->prepare($sql);
$ts = substr(sha1($t), 0, 5);
$params = array( $t,$ts );
$stmt->execute($params);
}
unset($conn);
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
// Create table
$sql = "CREATE TABLE $tableName1 ( c1 INT, c2 VARCHAR(40) )";
$stmt = $conn->query( $sql );
// Insert data
$sql = "INSERT INTO $tableName1 VALUES ( ?, ? )";
for( $t = 100; $t < 116; $t++ )
{
$stmt = $conn->prepare( $sql );
$ts = substr( sha1( $t ),0,5 );
$params = array( $t,$ts );
$stmt->execute( $params );
}
// Create table
$sql = "CREATE TABLE $tableName2 ( c1 INT, c2 VARCHAR(40) )";
$stmt = $conn->query( $sql );
// Insert data
$sql = "INSERT INTO $tableName2 VALUES ( ?, ? )";
for( $t = 200; $t < 209; $t++ )
{
$stmt = $conn->prepare( $sql );
$ts = substr( sha1( $t ),0,5 );
$params = array( $t,$ts );
$stmt->execute( $params );
}
$conn = null;
}
// Break connection by getting the session ID and killing it.
// Note that breaking a connection and testing reconnection requires a
// TCP/IP protocol connection (as opposed to a Shared Memory protocol).
function BreakConnection( $conn, $conn_break )
function breakConnection($conn, $conn_break)
{
$stmt1 = $conn->query( "SELECT @@SPID" );
$obj = $stmt1->fetch( PDO::FETCH_NUM );
$stmt1 = $conn->query("SELECT @@SPID");
$obj = $stmt1->fetch(PDO::FETCH_NUM);
$spid = $obj[0];
$stmt2 = $conn_break->query( "KILL ".$spid );
$stmt2 = $conn_break->query("KILL ".$spid);
sleep(1);
}
// Remove any databases previously created by GenerateDatabase
function DropTables( $server, $uid, $pwd, $tableName1, $tableName2 )
function dropTables($server, $uid, $pwd, $tableName1, $tableName2)
{
global $dbName;
$conn = new PDO( "sqlsrv:server = $server ; Database = $dbName ;", $uid, $pwd );
$conn = new PDO("sqlsrv:server = $server ; Database = $dbName ;", $uid, $pwd);
$query="IF OBJECT_ID('$tableName1', 'U') IS NOT NULL DROP TABLE $tableName1";
$stmt=$conn->query( $query );
$stmt=$conn->query($query);
$query="IF OBJECT_ID('$tableName2', 'U') IS NOT NULL DROP TABLE $tableName2";
$stmt=$conn->query( $query );
$stmt=$conn->query($query);
}
DropTables( $server, $uid, $pwd, $tableName1, $tableName2 );
GenerateTables( $server, $uid, $pwd, $dbName, $tableName1, $tableName2 );
?>
dropTables($server, $uid, $pwd, $tableName1, $tableName2);
generateTables($server, $uid, $pwd, $dbName, $tableName1, $tableName2);

21
test/functional/pdo_sqlsrv/pdo_TNIR.phpt
View file

@ -1,7 +1,7 @@
--TEST--
Test the TNIR keyword with enabled and disabled options and the MultiSubnetFailover keyword with true and false options
--SKIPIF--
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
// The way SYN packets are sent from the host is different depending on the combination of the TNIR and MultiSubnetFailover values
@ -12,23 +12,20 @@ Test the TNIR keyword with enabled and disabled options and the MultiSubnetFailo
// TNIR is enabled by default
// MultiSubnetFailover is disabled by default
require_once("MsSetup.inc");
$GLOBALS['uid'] = $uid;
$GLOBALS['pwd'] = $pwd;
$GLOBALS['server'] = $server;
require_once("MsCommon_mid-refactor.inc");
function test_tnir( $TNIRValue, $MSFValue ) {
function test_tnir($TNIRValue, $MSFValue)
{
$MSFValueStr = ($MSFValue) ? 'true' : 'false';
$connectionString = "sqlsrv:Server=$GLOBALS[server]; TransparentNetworkIPResolution=$TNIRValue; MultiSubnetFailover=$MSFValueStr";
try {
$start = microtime(true);
$conn = new PDO($connectionString, $GLOBALS['uid'], $GLOBALS['pwd'], array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION));
$conn = connect("TransparentNetworkIPResolution=$TNIRValue; MultiSubnetFailover=$MSFValueStr;");
echo "Connection successful with TNIR $TNIRValue and MultiSubnetFailover $MSFValueStr.\n";
$connect_time = round(microtime(true) - $start, 2);
echo "Time to connect is $connect_time sec.\n\n";
$conn = NULL;
}
catch(PDOException $e) {
unset($conn);
} catch (PDOException $e) {
echo "Connection failed with TNIR $TNIRValue and MultiSubnetFailover $MSFValueStr.\n";
print_r($e->errorInfo);
}
@ -57,4 +54,4 @@ Connection successful with TNIR Disabled and MultiSubnetFailover false\.
Time to connect is [0-9]+.?[0-9]* sec\.
Connection successful with TNIR Disabled and MultiSubnetFailover true\.
Time to connect is [0-9]+.?[0-9]* sec\.
Time to connect is [0-9]+.?[0-9]* sec\.

46
test/functional/pdo_sqlsrv/pdo_ae_insert_datetime.phpt
View file

@ -3,44 +3,40 @@ Test for inserting and retrieving encrypted data of datetime types
--DESCRIPTION--
No PDO::PARAM_ type specified when binding parameters
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
include 'AEData.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("AEData.inc");
$dataTypes = array( "date", "datetime", "datetime2", "smalldatetime", "time", "datetimeoffset" );
try
{
$conn = ae_connect();
try {
$conn = connect();
foreach ( $dataTypes as $dataType ) {
foreach ($dataTypes as $dataType) {
echo "\nTesting $dataType:\n";
// create table
$tbname = GetTempTableName( "", false );
$colMetaArr = array( new columnMeta( $dataType, "c_det" ), new columnMeta( $dataType, "c_rand", null, "randomized" ));
create_table( $conn, $tbname, $colMetaArr );
$tbname = getTableName();
$colMetaArr = array( new ColumnMeta($dataType, "c_det"), new ColumnMeta($dataType, "c_rand", null, "randomized"));
createTable($conn, $tbname, $colMetaArr);
// insert a row
$inputValues = array_slice( ${explode( "(", $dataType )[0] . "_params"}, 1, 2 );
$inputValues = array_slice(${explode("(", $dataType)[0] . "_params"}, 1, 2);
$r;
$stmt = insert_row( $conn, $tbname, array( $colMetaArr[0]->colName => $inputValues[0], $colMetaArr[1]->colName => $inputValues[1] ), $r );
if ( $r === false ) {
is_incompatible_types_error( $stmt, $dataType, "default type" );
}
else {
$stmt = insertRow($conn, $tbname, array("c_det" => $inputValues[0], "c_rand" => $inputValues[1] ), null, $r);
if ($r === false) {
isIncompatibleTypesError($stmt, $dataType, "default type");
} else {
echo "****Encrypted default type is compatible with encrypted $dataType****\n";
fetch_all( $conn, $tbname );
fetchAll($conn, $tbname);
}
DropTable( $conn, $tbname );
dropTable($conn, $tbname);
}
unset( $stmt );
unset( $conn );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn);
} catch (PDOException $e) {
echo $e->getMessage();
}
?>

81
test/functional/pdo_sqlsrv/pdo_ae_insert_money.phpt
View file

@ -3,77 +3,62 @@ Test for inserting and retrieving encrypted data of money types
--DESCRIPTION--
No PDO::PARAM_ tpe specified when binding parameters
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
include 'AEData.inc';
$dataTypes = array( "smallmoney", "money" );
try
{
$conn = ae_connect();
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT );
foreach ( $dataTypes as $dataType ) {
require_once("MsCommon_mid-refactor.inc");
require_once("AEData.inc");
$dataTypes = array("smallmoney", "money");
try {
//set to ERRMODE_SILENT to compare actual error and expected unsupport money types in encrypted columns error
$conn = connect('', array(), PDO::ERRMODE_SILENT);
foreach ($dataTypes as $dataType) {
echo "\nTesting $dataType:\n";
$success = true;
// create table
$tbname = GetTempTableName( "", false );
$colMetaArr = array( new columnMeta( $dataType, "c_det" ), new columnMeta( $dataType, "c_rand", null, "randomized" ));
create_table( $conn, $tbname, $colMetaArr );
$tbname = getTableName();
$colMetaArr = array(new columnMeta($dataType, "c_det", null, "deterministic", true),
new columnMeta($dataType, "c_rand", null, "randomized", true));
createTable($conn, $tbname, $colMetaArr);
// insert a row
$inputValues = array_slice( ${explode( "(", $dataType )[0] . "_params"}, 1, 2 );
$inputValues = array_slice(${explode("(", $dataType)[0] . "_params"}, 1, 2);
$r;
$stmt = insert_row( $conn, $tbname, array( $colMetaArr[0]->colName => $inputValues[0], $colMetaArr[1]->colName => $inputValues[1] ), $r );
if ( !is_col_enc() )
{
if ( $r === false )
{
$stmt = insertRow($conn, $tbname, array("c_det" => $inputValues[0], "c_rand" => $inputValues[1] ), null, $r);
if (!isColEncrypted()) {
if ($r === false) {
echo "Default type should be compatible with $dataType.\n";
$success = false;
}
else
{
} else {
$sql = "SELECT * FROM $tbname";
$stmt = $conn->query( $sql );
$row = $stmt->fetch( PDO::FETCH_ASSOC );
if ( $row["c_det"] != $inputValues[0] || $row["c_rand"] != $inputValues[1] )
{
$stmt = $conn->query($sql);
$row = $stmt->fetch(PDO::FETCH_ASSOC);
if ($row["c_det"] != $inputValues[0] || $row["c_rand"] != $inputValues[1]) {
echo "Incorrect output retrieved for datatype $dataType.\n";
$success = false;
}
}
}
else
{
if ( $r === false )
{
if ( $stmt->errorInfo()[0] != "22018" )
{
} else {
if ($r === false) {
if ($stmt->errorInfo()[0] != "22018") {
echo "Incorrect error returned.\n";
$success = false;
}
}
else
{
} else {
echo "$dataType is not compatible with any type.\n";
$success = false;
}
}
if ( $success )
if ($success) {
echo "Test successfully done.\n";
DropTable( $conn, $tbname );
}
dropTable($conn, $tbname);
}
unset( $stmt );
unset( $conn );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn);
} catch (PDOException $e) {
echo $e->getMessage();
}
?>

51
test/functional/pdo_sqlsrv/pdo_ae_insert_numeric.phpt
View file

@ -3,44 +3,37 @@ Test for inserting and retrieving encrypted data of numeric types
--DESCRIPTION--
No PDO::PARAM_ tpe specified when binding parameters
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
include 'AEData.inc';
$dataTypes = array( "bit", "tinyint", "smallint", "int", "bigint", "decimal(18,5)", "numeric(10,5)", "float", "real" );
try
{
$conn = ae_connect();
foreach ( $dataTypes as $dataType ) {
require_once("MsCommon_mid-refactor.inc");
require_once("AEData.inc");
$dataTypes = array("bit", "tinyint", "smallint", "int", "bigint", "decimal(18,5)", "numeric(10,5)", "float", "real");
try {
$conn = connect();
foreach ($dataTypes as $dataType) {
echo "\nTesting $dataType:\n";
// create table
$tbname = GetTempTableName( "", false );
$colMetaArr = array( new columnMeta( $dataType, "c_det" ), new columnMeta( $dataType, "c_rand", null, "randomized" ));
create_table( $conn, $tbname, $colMetaArr );
$tbname = getTableName();
$colMetaArr = array( new ColumnMeta($dataType, "c_det"), new ColumnMeta($dataType, "c_rand", null, "randomized"));
createTable($conn, $tbname, $colMetaArr);
// insert a row
$inputValues = array_slice( ${explode( "(", $dataType )[0] . "_params"}, 1, 2 );
$inputValues = array_slice(${explode("(", $dataType)[0] . "_params"}, 1, 2);
$r;
$stmt = insert_row( $conn, $tbname, array( $colMetaArr[0]->colName => $inputValues[0], $colMetaArr[1]->colName => $inputValues[1] ), $r );
if ( $r === false ) {
is_incompatible_types_error( $stmt, $dataType, "default type" );
}
else {
$stmt = insertRow($conn, $tbname, array( "c_det" => $inputValues[0], "c_rand" => $inputValues[1] ), null, $r);
if ($r === false) {
isIncompatibleTypesError($stmt, $dataType, "default type");
} else {
echo "****Encrypted default type is compatible with encrypted $dataType****\n";
fetch_all( $conn, $tbname );
fetchAll($conn, $tbname);
}
DropTable( $conn, $tbname );
dropTable($conn, $tbname);
}
unset( $stmt );
unset( $conn );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn);
} catch (PDOException $e) {
echo $e->getMessage();
}
?>

53
test/functional/pdo_sqlsrv/pdo_ae_insert_pdoparam_datetime.phpt
View file

@ -3,49 +3,42 @@ Test for inserting and retrieving encrypted data of datetime types
--DESCRIPTION--
Use PDOstatement::bindParam with all PDO::PARAM_ types
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
include 'AEData.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("AEData.inc");
$dataTypes = array( "date", "datetime", "datetime2", "smalldatetime", "time", "datetimeoffset" );
try
{
$conn = ae_connect();
foreach ( $dataTypes as $dataType ) {
try {
$conn = connect();
foreach ($dataTypes as $dataType) {
echo "\nTesting $dataType:\n";
// create table
$tbname = GetTempTableName( "", false );
$colMetaArr = array( new columnMeta( $dataType, "c_det" ), new columnMeta( $dataType, "c_rand", null, "randomized" ));
create_table( $conn, $tbname, $colMetaArr );
$tbname = getTableName();
$colMetaArr = array( new ColumnMeta($dataType, "c_det"), new ColumnMeta($dataType, "c_rand", null, "randomized"));
createTable($conn, $tbname, $colMetaArr);
// prepare statement for inserting into table
foreach ( $pdoParamTypes as $pdoParamType ) {
foreach ($pdoParamTypes as $pdoParamType) {
// insert a row
$inputValues = array_slice( ${explode( "(", $dataType )[0] . "_params"}, 1, 2 );
$inputValues = array_slice(${explode("(", $dataType)[0] . "_params"}, 1, 2);
$r;
$stmt = insert_row( $conn, $tbname, array( $colMetaArr[0]->colName => $inputValues[0], $colMetaArr[1]->colName => $inputValues[1] ), $r, "prepareBindParam", array( new bindParamOption( 1, $pdoParamType ), new bindParamOption( 2, $pdoParamType )));
if ( $r === false )
{
is_incompatible_types_error( $stmt, $dataType, $pdoParamType );
}
else {
$stmt = insertRow($conn, $tbname, array( "c_det" => new BindParamOp(1, $inputValues[0], $pdoParamType), "c_rand" => new BindParamOp(2, $inputValues[1], $pdoParamType)), "prepareBindParam", $r);
if ($r === false) {
isIncompatibleTypesError($stmt, $dataType, $pdoParamType);
} else {
echo "****PDO param type $pdoParamType is compatible with encrypted $dataType****\n";
fetch_all( $conn, $tbname );
fetchAll($conn, $tbname);
}
$conn->query( "TRUNCATE TABLE $tbname" );
$conn->query("TRUNCATE TABLE $tbname");
}
DropTable( $conn, $tbname );
dropTable($conn, $tbname);
}
unset( $stmt );
unset( $conn );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn);
} catch (PDOException $e) {
echo $e->getMessage();
}
?>

89
test/functional/pdo_sqlsrv/pdo_ae_insert_pdoparam_money.phpt
View file

@ -3,84 +3,69 @@ Test for inserting and retrieving encrypted data of money types
--DESCRIPTION--
Use PDOstatement::bindParam with all PDO::PARAM_ types
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
include 'AEData.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("AEData.inc");
$dataTypes = array( "smallmoney", "money" );
try
{
$conn = ae_connect();
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT );
foreach ( $dataTypes as $dataType ) {
try {
//set to ERRMODE_SILENT to compare actual error and expected unsupport money types in encrypted columns error
$conn = connect('', array(), PDO::ERRMODE_SILENT);
foreach ($dataTypes as $dataType) {
echo "\nTesting $dataType:\n";
$success = true;
// create table
$tbname = GetTempTableName( "", false );
$colMetaArr = array( new columnMeta( $dataType, "c_det" ), new columnMeta( $dataType, "c_rand", null, "randomized" ));
create_table( $conn, $tbname, $colMetaArr );
$tbname = getTableName();
$colMetaArr = array(new ColumnMeta($dataType, "c_det", null, "deterministic", true),
new ColumnMeta($dataType, "c_rand", null, "randomized", true));
createTable($conn, $tbname, $colMetaArr);
// test each PDO::PARAM_ type
foreach ( $pdoParamTypes as $pdoParamType ) {
foreach ($pdoParamTypes as $pdoParamType) {
// insert a row
$inputValues = array_slice( ${explode( "(", $dataType )[0] . "_params"}, 1, 2 );
$inputValues = array_slice(${explode("(", $dataType)[0] . "_params"}, 1, 2);
$r;
$stmt = insert_row( $conn, $tbname, array( $colMetaArr[0]->colName => $inputValues[0], $colMetaArr[1]->colName => $inputValues[1] ), $r, "prepareBindParam", array( new bindParamOption( 1, $pdoParamType ), new bindParamOption( 2, $pdoParamType )));
if ( !is_col_enc() )
{
if ( $r === false )
{
$stmt = insertRow($conn, $tbname, array("c_det" => new BindParamOp(1, (string)$inputValues[0], $pdoParamType), "c_rand" => new BindParamOp(2, (string)$inputValues[1], $pdoParamType)), "prepareBindParam", $r);
if (!isColEncrypted()) {
if ($r === false) {
echo "$pdoParamType should be compatible with $dataType.\n";
$success = false;
}
else
{
} else {
$sql = "SELECT * FROM $tbname";
$stmt = $conn->query( $sql );
$row = $stmt->fetch( PDO::FETCH_ASSOC );
if ( ( $row["c_det"] != $inputValues[0] || $row["c_rand"] != $inputValues[1] ) && $pdoParamType != "PDO::PARAM_NULL" )
{
$stmt = $conn->query($sql);
$row = $stmt->fetch(PDO::FETCH_ASSOC);
if (($row["c_det"] != $inputValues[0] || $row["c_rand"] != $inputValues[1]) && $pdoParamType != "PDO::PARAM_NULL") {
echo "Incorrect output retrieved for datatype $dataType.\n";
var_dump( $inputValues );
var_dump( $row );
var_dump($inputValues);
var_dump($row);
$success = false;
}
}
}
else
{
if ( $r === false )
{
if ( $stmt->errorInfo()[0] != "22018" )
{
} else {
if ($r === false) {
if ($stmt->errorInfo()[0] != "22018") {
echo "Incorrect error returned.\n";
$success = false;
}
}
else
{
} else {
echo "$dataType is not compatible with any type.\n";
$success = false;
}
}
$conn->query( "TRUNCATE TABLE $tbname" );
$conn->query("TRUNCATE TABLE $tbname");
}
if ( $success )
if ($success) {
echo "Test successfully done.\n";
DropTable( $conn, $tbname );
}
dropTable($conn, $tbname);
}
unset( $stmt );
unset( $conn );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn);
} catch (PDOException $e) {
echo $e->getMessage();
}
?>

68
test/functional/pdo_sqlsrv/pdo_ae_insert_pdoparam_numeric.phpt
View file

@ -3,49 +3,45 @@ Test for inserting and retrieving encrypted data of numeric types
--DESCRIPTION--
Use PDOstatement::bindParam with all PDO::PARAM_ types
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
include 'AEData.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("AEData.inc");
$dataTypes = array( "bit", "tinyint", "smallint", "int", "decimal(18,5)", "numeric(10,5)", "float", "real" );
try
{
$conn = ae_connect();
foreach ( $dataTypes as $dataType ) {
try {
$conn = connect();
foreach ($dataTypes as $dataType) {
echo "\nTesting $dataType:\n";
// create table
$tbname = GetTempTableName( "", false );
$colMetaArr = array( new columnMeta( $dataType, "c_det" ), new columnMeta( $dataType, "c_rand", null, "randomized" ));
create_table( $conn, $tbname, $colMetaArr );
$tbname = getTableName();
$colMetaArr = array(new ColumnMeta($dataType, "c_det"), new ColumnMeta($dataType, "c_rand", null, "randomized"));
createTable($conn, $tbname, $colMetaArr);
// test each PDO::PARAM_ type
foreach ( $pdoParamTypes as $pdoParamType ) {
foreach ($pdoParamTypes as $pdoParamType) {
// insert a row
$inputValues = array_slice( ${explode( "(", $dataType )[0] . "_params"}, 1, 2 );
$inputValues = array_slice(${explode("(", $dataType)[0] . "_params"}, 1, 2);
$r;
$stmt = insert_row( $conn, $tbname, array( $colMetaArr[0]->colName => $inputValues[0], $colMetaArr[1]->colName => $inputValues[1] ), $r, "prepareBindParam", array( new bindParamOption( 1, $pdoParamType ), new bindParamOption( 2, $pdoParamType )));
if ( $r === false )
{
is_incompatible_types_error( $stmt, $dataType, $pdoParamType );
if ($dataType == "decimal(18,5)") {
$stmt = insertRow($conn, $tbname, array( "c_det" => new BindParamOp(1, (string)$inputValues[0], $pdoParamType), "c_rand" => new BindParamOp(2, (string)$inputValues[1], $pdoParamType)), "prepareBindParam", $r);
} else {
$stmt = insertRow($conn, $tbname, array( "c_det" => new BindParamOp(1, $inputValues[0], $pdoParamType), "c_rand" => new BindParamOp(2, $inputValues[1], $pdoParamType)), "prepareBindParam", $r);
}
else {
if ($r === false) {
isIncompatibleTypesError($stmt, $dataType, $pdoParamType);
} else {
echo "****PDO param type $pdoParamType is compatible with encrypted $dataType****\n";
fetch_all( $conn, $tbname );
fetchAll($conn, $tbname);
}
$conn->query( "TRUNCATE TABLE $tbname" );
$conn->query("TRUNCATE TABLE $tbname");
}
DropTable( $conn, $tbname );
dropTable($conn, $tbname);
}
unset( $stmt );
unset( $conn );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn);
} catch (PDOException $e) {
echo $e->getMessage();
}
?>
@ -121,20 +117,20 @@ c_rand: 2147483647
Testing decimal(18,5):
****PDO param type PDO::PARAM_BOOL is compatible with encrypted decimal(18,5)****
c_det: -9223372036854.80078
c_rand: 9223372036854.80078
c_det: -9223372036854.80000
c_rand: 9223372036854.80000
****PDO param type PDO::PARAM_NULL is compatible with encrypted decimal(18,5)****
c_det:
c_rand:
****PDO param type PDO::PARAM_INT is compatible with encrypted decimal(18,5)****
c_det: -9223372036854.80078
c_rand: 9223372036854.80078
c_det: -9223372036854.80000
c_rand: 9223372036854.80000
****PDO param type PDO::PARAM_STR is compatible with encrypted decimal(18,5)****
c_det: -9223372036854.80000
c_rand: 9223372036854.80000
****PDO param type PDO::PARAM_LOB is compatible with encrypted decimal(18,5)****
c_det: -9223372036854.80078
c_rand: 9223372036854.80078
c_det: -9223372036854.80000
c_rand: 9223372036854.80000
Testing numeric(10,5):
****PDO param type PDO::PARAM_BOOL is compatible with encrypted numeric(10,5)****

57
test/functional/pdo_sqlsrv/pdo_ae_insert_pdoparam_string.phpt
View file

@ -3,50 +3,41 @@ Test for inserting and retrieving encrypted data of string types
--DESCRIPTION--
Use PDOstatement::bindParam with all PDO::PARAM_ types
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
include 'AEData.inc';
$dataTypes = array( "char(5)", "varchar(max)", "nchar(5)", "nvarchar(max)" );
try
{
$conn = ae_connect();
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT );
foreach ( $dataTypes as $dataType ) {
require_once("MsCommon_mid-refactor.inc");
require_once("AEData.inc");
$dataTypes = array("char(5)", "varchar(max)", "nchar(5)", "nvarchar(max)");
try {
$conn = connect('', array(), PDO::ERRMODE_SILENT);
foreach ($dataTypes as $dataType) {
echo "\nTesting $dataType:\n";
// create table
$tbname = GetTempTableName( "", false );
$colMetaArr = array( new columnMeta( $dataType, "c_det" ), new columnMeta( $dataType, "c_rand", null, "randomized" ));
create_table( $conn, $tbname, $colMetaArr );
$tbname = getTableName();
$colMetaArr = array(new ColumnMeta($dataType, "c_det"), new ColumnMeta($dataType, "c_rand", null, "randomized"));
createTable($conn, $tbname, $colMetaArr);
// prepare statement for inserting into table
foreach ( $pdoParamTypes as $pdoParamType ) {
foreach ($pdoParamTypes as $pdoParamType) {
// insert a row
$inputValues = array_slice( ${explode( "(", $dataType )[0] . "_params"}, 1, 2 );
$inputValues = array_slice(${explode("(", $dataType)[0] . "_params"}, 1, 2);
$r;
$stmt = insert_row( $conn, $tbname, array( $colMetaArr[0]->colName => $inputValues[0], $colMetaArr[1]->colName => $inputValues[1] ), $r, "prepareBindParam", array( new bindParamOption( 1, $pdoParamType ), new bindParamOption( 2, $pdoParamType )));
if ( $r === false )
{
is_incompatible_types_error( $stmt, $dataType, $pdoParamType );
}
else {
$stmt = insertRow($conn, $tbname, array( "c_det" => new BindParamOp(1, $inputValues[0], $pdoParamType),"c_rand" => new BindParamOp(2, $inputValues[1], $pdoParamType)), "prepareBindParam", $r);
if ($r === false) {
isIncompatibleTypesError($stmt, $dataType, $pdoParamType);
} else {
echo "****PDO param type $pdoParamType is compatible with encrypted $dataType****\n";
fetch_all( $conn, $tbname );
fetchAll($conn, $tbname);
}
$conn->query( "TRUNCATE TABLE $tbname" );
$conn->query("TRUNCATE TABLE $tbname");
}
DropTable( $conn, $tbname );
dropTable($conn, $tbname);
}
unset( $stmt );
unset( $conn );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn);
} catch (PDOException $e) {
echo $e->getMessage();
}
?>

77
test/functional/pdo_sqlsrv/pdo_ae_insert_retrieve.phpt
View file

@ -3,73 +3,60 @@ Test for inserting encrypted data and retrieving both encrypted and decrypted da
--DESCRIPTION--
Retrieving SQL query contains encrypted filter
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
try
{
$conn = ae_connect();
require_once("MsCommon_mid-refactor.inc");
try {
$conn = connect();
// Create the table
$tbname = 'Patients';
$colMetaArr = array( new columnMeta( "int", "PatientId", "IDENTITY(1,1)" ),
new columnMeta( "char(11)", "SSN"),
new columnMeta( "nvarchar(50)", "FirstName", "NULL" ),
new columnMeta( "nvarchar(50)", "LastName", "NULL"),
new columnMeta( "date", "BirthDate", null, "randomized" ));
create_table( $conn, $tbname, $colMetaArr );
$colMetaArr = array( new ColumnMeta("int", "PatientId", "IDENTITY(1,1)"),
new ColumnMeta("char(11)", "SSN"),
new ColumnMeta("nvarchar(50)", "FirstName", "NULL"),
new ColumnMeta("nvarchar(50)", "LastName", "NULL"),
new ColumnMeta("date", "BirthDate", null, "randomized"));
createTable($conn, $tbname, $colMetaArr);
// insert a row
$SSN = "795-73-9838";
$inputs = array( "SSN" => $SSN, "FirstName" => "Catherine", "LastName" => "Abel", "BirthDate" => "1996-10-19" );
$stmt = insert_row( $conn, $tbname, $inputs );
$stmt = insertRow($conn, $tbname, $inputs);
echo "Retrieving plaintext data:\n";
$selectSql = "SELECT SSN, FirstName, LastName, BirthDate FROM $tbname WHERE SSN = ?";
$stmt = $conn->prepare( $selectSql );
$stmt->bindParam( 1, $SSN );
$stmt = $conn->prepare($selectSql);
$stmt->bindParam(1, $SSN);
$stmt->execute();
$decrypted_row = $stmt->fetch( PDO::FETCH_ASSOC );
foreach ( $decrypted_row as $key => $value )
{
$decrypted_row = $stmt->fetch(PDO::FETCH_ASSOC);
foreach ($decrypted_row as $key => $value) {
print "$key: $value\n";
}
unset( $stmt );
}
catch( PDOException $e )
{
unset($stmt);
} catch (PDOException $e) {
echo $e->getMessage();
}
// for AE only
echo "\nChecking ciphertext data:\n";
if ( is_col_enc() )
{
try
{
$conn1 = ae_connect( null, null, true );
if (isColEncrypted()) {
try {
$conn1 = connect('', array(), PDO::ERRMODE_EXCEPTION, true);
$selectSql = "SELECT SSN, FirstName, LastName, BirthDate FROM $tbname";
$stmt = $conn1->query( $selectSql );
$encrypted_row = $stmt->fetch( PDO::FETCH_ASSOC );
foreach ( $encrypted_row as $key => $value )
{
if ( ctype_print( $value ))
$stmt = $conn1->query($selectSql);
$encrypted_row = $stmt->fetch(PDO::FETCH_ASSOC);
foreach ($encrypted_row as $key => $value) {
if (ctype_print($value)) {
print "Error: expected a binary array for $key\n";
}
}
unset( $stmt );
unset( $conn1 );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn1);
} catch (PDOException $e) {
echo $e->getMessage();
}
}
DropTable( $conn, $tbname );
unset( $conn );
dropTable($conn, $tbname);
unset($conn);
echo "Done\n";
?>
--EXPECT--

104
test/functional/pdo_sqlsrv/pdo_ae_insert_retrieve_fixed_size.phpt
View file

@ -1,80 +1,64 @@
--TEST--
Test for inserting encrypted fixed size types data and retrieve both encrypted and decrypted data
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
try
{
$conn = ae_connect();
require_once("MsCommon_mid-refactor.inc");
try {
$conn = connect();
// Create the table
$tbname = 'FixedSizeAnalysis';
$colMetaArr = array( new columnMeta( "tinyint", "TinyIntData" ),
new columnMeta( "smallint", "SmallIntData" ),
new columnMeta( "int", "IntData" ),
new columnMeta( "bigint", "BigIntData" ),
new columnMeta( "decimal(38,0)", "DecimalData" ),
new columnMeta( "bit", "BitData" ),
new columnMeta( "datetime", "DateTimeData" ),
new columnMeta( "datetime2", "DateTime2Data" ));
create_table( $conn, $tbname, $colMetaArr );
// insert a row
$inputs = array( "TinyIntData" => 255,
"SmallIntData" => 32767,
"IntData" => 2147483647,
"BigIntData" => 92233720368547,
"DecimalData" => 79228162514264,
"BitData" => true,
"DateTimeData" => '9999-12-31 23:59:59.997',
"DateTime2Data" => '9999-12-31 23:59:59.9999999');
$paramOptions = array( new bindParamOption( 4, "PDO::PARAM_INT" ) );
$r;
$stmt = insert_row( $conn, $tbname, $inputs, $r, "prepareBindParam", $paramOptions );
print "Decrypted values:\n";
fetch_all( $conn, $tbname );
$colMetaArr = array("TinyIntData" => "tinyint",
"SmallIntData" => "smallint",
"IntData" => "int",
"BigIntData" => "bigint",
"DecimalData" => "decimal(18,0)",
"BitData" => "bit",
"DateTimeData" => "datetime",
"DateTime2Data" => "datetime2");
createTable($conn, $tbname, $colMetaArr);
unset( $stmt );
}
catch( PDOException $e )
{
// insert a row
$inputs = array( "TinyIntData" => 255,
"SmallIntData" => 32767,
"IntData" => 2147483647,
"BigIntData" => 92233720368547,
"DecimalData" => 79228162514264,
"BitData" => true,
"DateTimeData" => '9999-12-31 23:59:59.997',
"DateTime2Data" => '9999-12-31 23:59:59.9999999');
//$paramOptions = array( new bindParamOption(4, "PDO::PARAM_INT") );
$r;
$stmt = insertRow($conn, $tbname, $inputs, "prepareBindParam", $r);
print "Decrypted values:\n";
fetchAll($conn, $tbname);
unset($stmt);
} catch (PDOException $e) {
echo $e->getMessage();
}
// for AE only
if ( is_col_enc() )
{
try
{
$conn1 = ae_connect( null, null, true );
if (isColEncrypted()) {
try {
$conn1 = connect('', array(), PDO::ERRMODE_EXCEPTION, true);
$selectSql = "SELECT * FROM $tbname";
$stmt = $conn1->query( $selectSql );
$encrypted_row = $stmt->fetch( PDO::FETCH_ASSOC );
foreach ( $encrypted_row as $key => $value )
{
if ( ctype_print( $value ))
{
$stmt = $conn1->query($selectSql);
$encrypted_row = $stmt->fetch(PDO::FETCH_ASSOC);
foreach ($encrypted_row as $key => $value) {
if (ctype_print($value)) {
print "Error: expected a binary array for $key\n";
}
}
unset( $stmt );
unset( $conn1 );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn1);
} catch (PDOException $e) {
echo $e->getMessage();
}
}
DropTable( $conn, $tbname );
unset( $conn );
dropTable($conn, $tbname);
unset($conn);
echo "Done\n";
?>
--EXPECT--
@ -87,4 +71,4 @@ DecimalData: 79228162514264
BitData: 1
DateTimeData: 9999-12-31 23:59:59.997
DateTime2Data: 9999-12-31 23:59:59.9999999
Done
Done

79
test/functional/pdo_sqlsrv/pdo_ae_insert_retrieve_nvarchar.phpt
View file

@ -1,79 +1,60 @@
--TEST--
Test for inserting encrypted nvarchar data of variable lengths and retrieving encrypted and decrypted data
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
$testPass = true;
try
{
$conn = ae_connect();
try {
$conn = connect();
// Create the table
$tbname = 'NVarcharAnalysis';
$colMetaArr = array( new columnMeta( "int", "CharCount", "IDENTITY(0,1)" ), new columnMeta( "nvarchar(1000)" ));
create_table( $conn, $tbname, $colMetaArr );
$colMetaArr = array( new ColumnMeta("int", "CharCount", "IDENTITY(0,1)"), new columnMeta("nvarchar(1000)"));
createTable($conn, $tbname, $colMetaArr);
// insert 1000 rows
for ( $i = 0; $i < 1000; $i++ )
{
$data = str_repeat( "*", $i );
$stmt = insert_row( $conn, $tbname, array( get_default_colname( "nvarchar(1000)" ) => $data ) );
for ($i = 0; $i < 1000; $i++) {
$data = str_repeat("*", $i);
$stmt = insertRow($conn, $tbname, array(getDefaultColName("nvarchar(1000)") => $data));
}
$selectSql = "SELECT * FROM $tbname";
$stmt = $conn->query( $selectSql );
while ( $decrypted_row = $stmt->fetch( PDO::FETCH_ASSOC ))
{
if ( $decrypted_row[ 'CharCount' ] != strlen( $decrypted_row[ get_default_colname( "nvarchar(1000)" ) ] ))
{
$rowInd = $decrypted_row[ 'CharCount' ] + 1;
$stmt = $conn->query($selectSql);
while ($decrypted_row = $stmt->fetch(PDO::FETCH_ASSOC)) {
if ($decrypted_row['CharCount'] != strlen($decrypted_row[getDefaultColName("nvarchar(1000)")])) {
$rowInd = $decrypted_row['CharCount'] + 1;
echo "Failed to decrypted at row $rowInd\n";
$testPass = false;
}
}
unset( $stmt );
}
catch( PDOException $e )
{
unset($stmt);
} catch (PDOException $e) {
echo $e->getMessage();
}
// for AE only
if ( is_col_enc() )
{
try
{
$conn1 = ae_connect( null, null, true );
$stmt = $conn1->query( $selectSql );
while ( $decrypted_row = $stmt->fetch( PDO::FETCH_ASSOC ))
{
if ( $decrypted_row[ 'CharCount' ] == strlen( $decrypted_row[ get_default_colname( "nvarchar(1000)" ) ] ))
{
if (isColEncrypted()) {
try {
$conn1 = connect('', array(), PDO::ERRMODE_EXCEPTION, true);
$stmt = $conn1->query($selectSql);
while ($decrypted_row = $stmt->fetch(PDO::FETCH_ASSOC)) {
if ($decrypted_row['CharCount'] == strlen($decrypted_row[getDefaultColName("nvarchar(1000)")])) {
$rowInd = $decrypted_row[ 'CharCount' ] + 1;
echo "Failed to encrypted at row $rowInd\n";
$testPass = false;
}
}
unset( $stmt );
unset( $conn1 );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn1);
} catch (PDOException $e) {
echo $e->getMessage();
}
}
DropTable( $conn, $tbname );
unset( $conn );
if ( $testPass ) {
dropTable($conn, $tbname);
unset($conn);
if ($testPass) {
echo "Test successfully done.\n";
}
?>
--EXPECT--
Test successfully done.
Test successfully done.

78
test/functional/pdo_sqlsrv/pdo_ae_insert_retrieve_varchar.phpt
View file

@ -1,78 +1,60 @@
--TEST--
Test for inserting encrypted varchar data of variable lengths and retrieving encrypted and decrypted data
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
$testPass = true;
try
{
$conn = ae_connect();
try {
$conn = connect();
// Create the table
$tbname = 'VarcharAnalysis';
$colMetaArr = array( new columnMeta( "int", "CharCount", "IDENTITY(0,1)" ), new columnMeta( "varchar(1000)" ));
create_table( $conn, $tbname, $colMetaArr );
$colMetaArr = array( new ColumnMeta("int", "CharCount", "IDENTITY(0,1)"), new ColumnMeta("varchar(1000)"));
createTable($conn, $tbname, $colMetaArr);
// insert 1000 rows
for( $i = 0; $i < 1000; $i++ )
{
$data = str_repeat( "*", $i );
$stmt = insert_row( $conn, $tbname, array( get_default_colname( "varchar(1000)" ) => $data ) );
for ($i = 0; $i < 1000; $i++) {
$data = str_repeat("*", $i);
$stmt = insertRow($conn, $tbname, array(getDefaultColname("varchar(1000)") => $data));
}
$selectSql = "SELECT * FROM $tbname";
$stmt = $conn->query( $selectSql );
while ( $decrypted_row = $stmt->fetch( PDO::FETCH_ASSOC ))
{
if ( $decrypted_row[ 'CharCount' ] != strlen( $decrypted_row[ get_default_colname( "varchar(1000)" ) ] ))
{
$rowInd = $decrypted_row[ 'CharCount' ] + 1;
$stmt = $conn->query($selectSql);
while ($decrypted_row = $stmt->fetch(PDO::FETCH_ASSOC)) {
if ($decrypted_row['CharCount'] != strlen($decrypted_row[getDefaultColname("varchar(1000)")])) {
$rowInd = $decrypted_row['CharCount'] + 1;
echo "Failed to decrypted at row $rowInd\n";
$testPass = false;
}
}
unset( $stmt );
}
catch( PDOException $e )
{
unset($stmt);
} catch (PDOException $e) {
echo $e->getMessage();
}
// for AE only
if ( is_col_enc() )
{
try
{
$conn1 = ae_connect( null, null, true );
$stmt = $conn1->query( $selectSql );
while ( $decrypted_row = $stmt->fetch( PDO::FETCH_ASSOC ))
{
if ( $decrypted_row[ 'CharCount' ] == strlen( $decrypted_row[ get_default_colname( "varchar(1000)" ) ] ))
{
if (isColEncrypted()) {
try {
$conn1 = connect('', array(), PDO::ERRMODE_EXCEPTION, true);
$stmt = $conn1->query($selectSql);
while ($decrypted_row = $stmt->fetch(PDO::FETCH_ASSOC)) {
if ($decrypted_row['CharCount'] == strlen($decrypted_row[getDefaultColname("varchar(1000)")])) {
$rowInd = $decrypted_row[ 'CharCount' ] + 1;
echo "Failed to encrypted at row $rowInd\n";
$testPass = false;
}
}
unset( $stmt );
unset( $conn1 );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn1);
} catch (PDOException $e) {
echo $e->getMessage();
}
}
DropTable( $conn, $tbname );
unset( $conn );
if ( $testPass ) {
dropTable($conn, $tbname);
unset($conn);
if ($testPass) {
echo "Test successfully done.\n";
}
?>
--EXPECT--
Test successfully done.
Test successfully done.

51
test/functional/pdo_sqlsrv/pdo_ae_insert_string.phpt
View file

@ -3,44 +3,37 @@ Test for inserting and retrieving encrypted data of string types
--DESCRIPTION--
No PDO::PARAM_ type specified when binding parameters
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
include 'AEData.inc';
$dataTypes = array( "char(5)", "varchar(max)", "nchar(5)", "nvarchar(max)" );
try
{
$conn = ae_connect();
foreach ( $dataTypes as $dataType ) {
require_once("MsCommon_mid-refactor.inc");
require_once("AEData.inc");
$dataTypes = array("char(5)", "varchar(max)", "nchar(5)", "nvarchar(max)");
try {
$conn = connect();
foreach ($dataTypes as $dataType) {
echo "\nTesting $dataType:\n";
// create table
$tbname = GetTempTableName( "", false );
$colMetaArr = array( new columnMeta( $dataType, "c_det" ), new columnMeta( $dataType, "c_rand", null, "randomized" ));
create_table( $conn, $tbname, $colMetaArr );
$tbname = getTableName();
$colMetaArr = array(new ColumnMeta($dataType, "c_det"), new ColumnMeta($dataType, "c_rand", null, "randomized"));
createTable($conn, $tbname, $colMetaArr);
// insert a row
$inputValues = array_slice( ${explode( "(", $dataType )[0] . "_params"}, 1, 2 );
$inputValues = array_slice(${explode("(", $dataType)[0] . "_params"}, 1, 2);
$r;
$stmt = insert_row( $conn, $tbname, array( $colMetaArr[0]->colName => $inputValues[0], $colMetaArr[1]->colName => $inputValues[1] ), $r );
if ( $r === false ) {
is_incompatible_types_error( $stmt, $dataType, "default type" );
}
else {
$stmt = insertRow($conn, $tbname, array("c_det" => $inputValues[0], "c_rand" => $inputValues[1] ), null, $r);
if ($r === false) {
isIncompatibleTypesError($stmt, $dataType, "default type");
} else {
echo "****Encrypted default type is compatible with encrypted $dataType****\n";
fetch_all( $conn, $tbname );
fetchAll($conn, $tbname);
}
DropTable( $conn, $tbname );
dropTable($conn, $tbname);
}
unset( $stmt );
unset( $conn );
}
catch( PDOException $e )
{
unset($stmt);
unset($conn);
} catch (PDOException $e) {
echo $e->getMessage();
}
?>

157
test/functional/pdo_sqlsrv/pdo_ae_output_param_all.phpt
View file

@ -1,84 +1,78 @@
--TEST--
Test for binding output params for encrypted data for all types
--SKIPIF--
<?php require('skipif_versions_old.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
$conn = ae_connect();
require_once("MsCommon_mid-refactor.inc");
$conn = connect();
// Create the table
$tbname = GetTempTableName( "", false );
$colMetaArr = array( new columnMeta( "int", "c1_int" ),
new columnMeta( "smallint", "c2_smallint" ),
new columnMeta( "tinyint", "c3_tinyint" ),
new columnMeta( "bit", "c4_bit" ),
new columnMeta( "bigint", "c5_bigint" ),
new columnMeta( "decimal(18,5)", "c6_decimal" ),
new columnMeta( "numeric(10,5)", "c7_numeric" ),
new columnMeta( "float", "c8_float" ),
new columnMeta( "real", "c9_real" ),
new columnMeta( "date", "c10_date" ),
new columnMeta( "datetime", "c11_datetime" ),
new columnMeta( "datetime2", "c12_datetime2" ),
new columnMeta( "datetimeoffset", "c13_datetimeoffset" ),
new columnMeta( "time", "c14_time" ),
new columnMeta( "char(5)", "c15_char" ),
new columnMeta( "varchar(max)", "c16_varchar" ),
new columnMeta( "nchar(5)", "c17_nchar" ),
new columnMeta( "nvarchar(max)", "c18_nvarchar" ));
create_table( $conn, $tbname, $colMetaArr );
$tbname = getTableName();
$colMetaArr = array("c1_int" => "int",
"c2_smallint" => "smallint",
"c3_tinyint" => "tinyint",
"c4_bit" => "bit",
"c5_bigint" => "bigint",
"c6_decimal" => "decimal(18,5)",
"c7_numeric" => "numeric(10,5)",
"c8_float" => "float",
"c9_real" => "real",
"c10_date" => "date",
"c11_datetime" => "datetime",
"c12_datetime2" => "datetime2",
"c13_datetimeoffset" => "datetimeoffset",
"c14_time" => "time",
"c15_char" => "char(5)",
"c16_varchar" => "varchar(max)",
"c17_nchar" => "nchar(5)",
"c18_nvarchar" => "nvarchar(max)");
createTable($conn, $tbname, $colMetaArr);
// Create a Store Procedure
$spname = 'selectAllColumns';
$spSql = "CREATE PROCEDURE $spname (
@c1_int int OUTPUT, @c2_smallint smallint OUTPUT,
@c3_tinyint tinyint OUTPUT, @c4_bit bit OUTPUT,
@c1_int int OUTPUT, @c2_smallint smallint OUTPUT,
@c3_tinyint tinyint OUTPUT, @c4_bit bit OUTPUT,
@c5_bigint bigint OUTPUT, @c6_decimal decimal(18,5) OUTPUT,
@c7_numeric numeric(10,5) OUTPUT, @c8_float float OUTPUT,
@c7_numeric numeric(10,5) OUTPUT, @c8_float float OUTPUT,
@c9_real real OUTPUT, @c10_date date OUTPUT,
@c11_datetime datetime OUTPUT, @c12_datetime2 datetime2 OUTPUT,
@c13_datetimeoffset datetimeoffset OUTPUT, @c14_time time OUTPUT,
@c15_char char(5) OUTPUT, @c16_varchar varchar(max) OUTPUT,
@c17_nchar nchar(5) OUTPUT, @c18_nvarchar nvarchar(max) OUTPUT) AS
SELECT @c1_int = c1_int, @c2_smallint = c2_smallint,
@c3_tinyint = c3_tinyint, @c4_bit = c4_bit,
@c5_bigint = c5_bigint, @c6_decimal = c6_decimal,
@c7_numeric = c7_numeric, @c8_float = c8_float,
@c9_real = c9_real, @c10_date = c10_date,
SELECT @c1_int = c1_int, @c2_smallint = c2_smallint,
@c3_tinyint = c3_tinyint, @c4_bit = c4_bit,
@c5_bigint = c5_bigint, @c6_decimal = c6_decimal,
@c7_numeric = c7_numeric, @c8_float = c8_float,
@c9_real = c9_real, @c10_date = c10_date,
@c11_datetime = c11_datetime, @c12_datetime2 = c12_datetime2,
@c13_datetimeoffset = c13_datetimeoffset, @c14_time = c14_time,
@c15_char = c15_char, @c16_varchar = c16_varchar,
@c17_nchar = c17_nchar, @c18_nvarchar = c18_nvarchar
FROM $tbname";
$conn->query( $spSql );
$conn->query($spSql);
// Insert data
$inputs = array( "c1_int" => 2147483647,
"c2_smallint" => 32767,
"c3_tinyint" => 255,
"c4_bit" => 1,
"c5_bigint" => 922337203685479936,
"c6_decimal" => 9223372036854.80000,
"c7_numeric" => 21474.83647,
$inputs = array( "c1_int" => 2147483647,
"c2_smallint" => 32767,
"c3_tinyint" => 255,
"c4_bit" => 1,
"c5_bigint" => 922337203685479936,
"c6_decimal" => 9223372036854.80000,
"c7_numeric" => 21474.83647,
"c8_float" => 9223372036.8548,
"c9_real" => 2147.483,
"c10_date" => '9999-12-31',
"c11_datetime" => '9999-12-31 23:59:59.997',
"c12_datetime2" => '9999-12-31 23:59:59.9999999',
"c13_datetimeoffset" => '9999-12-31 23:59:59.9999999 +14:00',
"c14_time" => '23:59:59.9999999',
"c15_char" => 'th, n',
"c16_varchar" => 'This large row size can cause errors (such as error 512) during some normal operations, such as a clustered index key update, or sorts of the full column set, which users cannot anticipate until performing an operation.',
"c17_nchar" => 'th Un',
"c9_real" => 2147.483,
"c10_date" => '9999-12-31',
"c11_datetime" => '9999-12-31 23:59:59.997',
"c12_datetime2" => '9999-12-31 23:59:59.9999999',
"c13_datetimeoffset" => '9999-12-31 23:59:59.9999999 +14:00',
"c14_time" => '23:59:59.9999999',
"c15_char" => 'th, n',
"c16_varchar" => 'This large row size can cause errors (such as error 512) during some normal operations, such as a clustered index key update, or sorts of the full column set, which users cannot anticipate until performing an operation.',
"c17_nchar" => 'th Un',
"c18_nvarchar" => 'When prefixing a string constant with the letter N, the implicit conversion will result in a Unicode string if the constant to convert does not exceed the max length for a Unicode string data type (4,000).' );
$paramOptions = array( new bindParamOption( 5, "PDO::PARAM_INT" ) );
$r;
$stmt = insert_row( $conn, $tbname, $inputs, $r, "prepareBindParam", $paramOptions );
$stmt = insertRow($conn, $tbname, $inputs, null, $r);
// Call store procedure
$outSql = get_callProcSql_placeholders( $spname, count( $inputs ));
$outSql = getCallProcSqlPlaceholders($spname, count($inputs));
$intOut = 0;
$smallintOut = 0;
$tinyintOut = 0;
@ -97,7 +91,7 @@ $charOut = '';
$varcharOut = '';
$ncharOut = '';
$nvarcharOut = '';
$stmt = $conn->prepare( $outSql );
$stmt = $conn->prepare($outSql);
$stmt->bindParam(1, $intOut, PDO::PARAM_INT, PDO::SQLSRV_PARAM_OUT_DEFAULT_SIZE);
$stmt->bindParam(2, $smallintOut, PDO::PARAM_INT, PDO::SQLSRV_PARAM_OUT_DEFAULT_SIZE);
$stmt->bindParam(3, $tinyintOut, PDO::PARAM_INT, PDO::SQLSRV_PARAM_OUT_DEFAULT_SIZE);
@ -117,31 +111,28 @@ $stmt->bindParam(16, $varcharOut, PDO::PARAM_STR, 2048);
$stmt->bindParam(17, $ncharOut, PDO::PARAM_STR, 2048);
$stmt->bindParam(18, $nvarcharOut, PDO::PARAM_STR, 2048);
$stmt->execute();
print ( "intOut: " . $intOut . "\n" );
print ( "smallintOut: " . $smallintOut . "\n" );
print ( "tinyintOut: " . $tinyintOut . "\n" );
print ( "bitOut: " . $bitOut . "\n" );
print ( "bigintOut: " . $bigintOut . "\n" );
print ( "decimalOut: " . $decimalOut . "\n" );
print ( "numericOut: " . $numericOut . "\n" );
print ( "floatOut: " . $floatOut . "\n" );
print ( "realOut: " . $realOut . "\n" );
print ( "dateOut: " . $dateOut . "\n" );
print ( "datetimeOut: " . $datetimeOut . "\n" );
print ( "datetime2Out: " . $datetime2Out . "\n" );
print ( "datetimeoffsetOut: " . $datetimeoffsetOut . "\n" );
print ( "timeOut: " . $timeOut . "\n" );
print ( "charOut: " . $charOut . "\n" );
print ( "varcharOut: " . $varcharOut . "\n" );
print ( "ncharOut: " . $ncharOut . "\n" );
print ( "nvarcharOut: " . $nvarcharOut . "\n" );
$conn->query( "DROP PROCEDURE $spname" );
$conn->query( "DROP TABLE $tbname" );
unset( $stmt );
unset( $conn );
print("intOut: " . $intOut . "\n");
print("smallintOut: " . $smallintOut . "\n");
print("tinyintOut: " . $tinyintOut . "\n");
print("bitOut: " . $bitOut . "\n");
print("bigintOut: " . $bigintOut . "\n");
print("decimalOut: " . $decimalOut . "\n");
print("numericOut: " . $numericOut . "\n");
print("floatOut: " . $floatOut . "\n");
print("realOut: " . $realOut . "\n");
print("dateOut: " . $dateOut . "\n");
print("datetimeOut: " . $datetimeOut . "\n");
print("datetime2Out: " . $datetime2Out . "\n");
print("datetimeoffsetOut: " . $datetimeoffsetOut . "\n");
print("timeOut: " . $timeOut . "\n");
print("charOut: " . $charOut . "\n");
print("varcharOut: " . $varcharOut . "\n");
print("ncharOut: " . $ncharOut . "\n");
print("nvarcharOut: " . $nvarcharOut . "\n");
dropProc($conn, $spname);
dropTable($conn, $tbname);
unset($stmt);
unset($conn);
?>
--EXPECTREGEX--
intOut: 2147483647
@ -161,4 +152,4 @@ timeOut: 23:59:59\.9999999
charOut: th\, n
varcharOut: This large row size can cause errors \(such as error 512\) during some normal operations\, such as a clustered index key update\, or sorts of the full column set\, which users cannot anticipate until performing an operation\.
ncharOut: th Un
nvarcharOut: When prefixing a string constant with the letter N\, the implicit conversion will result in a Unicode string if the constant to convert does not exceed the max length for a Unicode string data type \(4,000\).
nvarcharOut: When prefixing a string constant with the letter N\, the implicit conversion will result in a Unicode string if the constant to convert does not exceed the max length for a Unicode string data type \(4,000\).

66
test/functional/pdo_sqlsrv/pdo_ae_unsupported_stmt_attr.phpt Normal file
View file

@ -0,0 +1,66 @@
--TEST--
Test error from preparing a parameterized query with direct query or emulate prepare when Column Encryption is enabled
--SKIPIF--
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsCommon_mid-refactor.inc");
try {
$connection = connect();
$tbname = "TEST";
createTable($connection, $tbname, array(new ColumnMeta("int", "id", "IDENTITY(1,1) NOT NULL"), "name" => "nvarchar(max)"));
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
try {
$name = "Edward";
$st = $connection->prepare("INSERT INTO $tbname (name) VALUES (:p0)", array(PDO::SQLSRV_ATTR_DIRECT_QUERY => true));
$st->execute(array("p0" => $name));
} catch (PDOException $e) {
$error = $e->errorInfo;
// expects an exception if Column Encryption is enabled
if (isColEncrypted()) {
if ($error[0] != "IMSSP" ||
$error[1] != -81 ||
$error[2] != "Parameterized statement with attribute PDO::SQLSRV_ATTR_DIRECT_QUERY is not supported in a Column Encryption enabled Connection.") {
echo "An unexpected exception was caught.\n";
var_dump($error);
}
} else {
var_dump($error);
}
}
try {
$name = "Alphonse";
$st = $connection->prepare("INSERT INTO $tbname (name) VALUES (:p0)", array(PDO::ATTR_EMULATE_PREPARES => true));
$st->execute(array("p0" => $name));
} catch (PDOException $e) {
$error = $e->errorInfo;
// expects an exception if Column Encryption is enabled
if (isColEncrypted()) {
if ($error[0] != "IMSSP" ||
$error[1] != -82 ||
$error[2] != "Parameterized statement with attribute PDO::ATTR_EMULATE_PREPARES is not supported in a Column Encryption enabled Connection.") {
echo "An unexpected exception was caught.\n";
var_dump($error);
}
} else {
var_dump($error);
}
}
try {
dropTable($connection, $tbname);
unset($st);
unset($connection);
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
echo "Done\n";
?>
--EXPECT--
Done

1
test/functional/pdo_sqlsrv/pdo_bigint_outparam.phpt
View file

@ -14,6 +14,7 @@ createTable($conn, $tbname, array("c1_bigint" => "bigint"));
// Create a Stored Procedure
$spname = "selectBigint";
dropProc($conn, $spname);
$spSql = "CREATE PROCEDURE $spname (@c1_bigint bigint OUTPUT) AS
SELECT @c1_bigint = c1_bigint FROM $tbname";
$conn->query($spSql);

1
test/functional/pdo_sqlsrv/pdo_bool_outparam.phpt
View file

@ -14,6 +14,7 @@ createTable($conn, $tbname, array("c1_bool" => "int"));
// Create a Stored Procedure
$spname = "selectBool";
dropProc($conn, $spname);
$spSql = "CREATE PROCEDURE $spname (@c1_bool int OUTPUT) AS
SELECT @c1_bool = c1_bool FROM $tbname";
$conn->query($spSql);

206
test/functional/pdo_sqlsrv/pdo_connection_resiliency.phpt
View file

@ -17,218 +17,194 @@ non-MARS connection. This should fail too.
// when exiting the helper method? Do the associated cursors remain active? It is an
// unnecessary complication, so I have left the code like this.
require_once( "break_pdo.php" );
require_once("break_pdo.php");
require_once("MsCommon_mid-refactor.inc");
$conn_break = new PDO( "sqlsrv:server = $server ; Database = $dbName ;", $uid, $pwd );
$conn_break = connect();
///////////////////////////////////////////////////////////////////////////////
// Part 1
// Part 1
// Expected to successfully execute second query because buffered cursor for
// first query means connection is idle when broken
///////////////////////////////////////////////////////////////////////////////
$connectionInfo = "ConnectRetryCount = 10; ConnectRetryInterval = 10;";
try
{
$conn = new PDO( "sqlsrv:server = $server ; Database = $dbName ; $connectionInfo", $uid, $pwd );
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
}
catch( PDOException $e )
{
try {
// TODO: Idle connection resiliency does not work with Column Encryption at this point
// Do not connect with ColumnEncryption for now
$conn = connect($connectionInfo, array(), PDO::ERRMODE_EXCEPTION, true);
} catch (PDOException $e) {
echo "Could not connect.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
$query1 = "SELECT * FROM $tableName1";
try
{
$stmt1 = $conn->prepare( $query1, array( PDO::ATTR_CURSOR=> PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=> PDO::SQLSRV_CURSOR_BUFFERED ) );
if ( $stmt1->execute() ) echo "Statement 1 successful.\n";
try {
$stmt1 = $conn->prepare($query1, array( PDO::ATTR_CURSOR=> PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=> PDO::SQLSRV_CURSOR_BUFFERED ));
if ($stmt1->execute()) {
echo "Statement 1 successful.\n";
}
$rowcount = $stmt1->rowCount();
echo $rowcount." rows in result set.\n";
}
catch( PDOException $e )
{
} catch (PDOException $e) {
echo "Error executing statement 1.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
BreakConnection( $conn, $conn_break );
breakConnection($conn, $conn_break);
$query2 = "SELECT * FROM $tableName2";
try
{
$stmt2 = $conn->prepare( $query2, array( PDO::ATTR_CURSOR=> PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=> PDO::SQLSRV_CURSOR_BUFFERED ) );
if ( $stmt2->execute() ) echo "Statement 2 successful.\n";
try {
$stmt2 = $conn->prepare($query2, array( PDO::ATTR_CURSOR=> PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=> PDO::SQLSRV_CURSOR_BUFFERED ));
if ($stmt2->execute()) {
echo "Statement 2 successful.\n";
}
$rowcount = $stmt2->rowCount();
echo $rowcount." rows in result set.\n";
}
catch( PDOException $e )
{
} catch (PDOException $e) {
echo "Error executing statement 2.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
$conn = null;
unset($conn);
///////////////////////////////////////////////////////////////////////////////
// Part 2
// Part 2
// Expected to successfully execute second query because first statement is
// freed before breaking connection
///////////////////////////////////////////////////////////////////////////////
try
{
$conn = new PDO( "sqlsrv:server = $server ; Database = $dbName ; $connectionInfo", $uid, $pwd );
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
}
catch( PDOException $e )
{
try {
$conn = connect($connectionInfo, array(), PDO::ERRMODE_EXCEPTION, true);
} catch (PDOException $e) {
echo "Could not connect.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
$query1 = "SELECT * FROM $tableName1";
try
{
$stmt3 = $conn->query( $query1 );
if ( $stmt3 ) echo "Statement 3 successful.\n";
try {
$stmt3 = $conn->query($query1);
if ($stmt3) {
echo "Statement 3 successful.\n";
}
$rowcount = $stmt3->rowCount();
echo $rowcount." rows in result set.\n";
}
catch( PDOException $e )
{
} catch (PDOException $e) {
echo "Error executing statement 3.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
$stmt3 = null;
unset($stmt3);
BreakConnection( $conn, $conn_break );
breakConnection($conn, $conn_break);
$query2 = "SELECT * FROM $tableName2";
try
{
$stmt4 = $conn->query( $query2 );
if ( $stmt4 ) echo "Statement 4 successful.\n";
try {
$stmt4 = $conn->query($query2);
if ($stmt4) {
echo "Statement 4 successful.\n";
}
$rowcount = $stmt4->rowCount();
echo $rowcount." rows in result set.\n";
}
catch( PDOException $e )
{
} catch (PDOException $e) {
echo "Error executing statement 4.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
$conn = null;
unset($conn);
///////////////////////////////////////////////////////////////////////////////
// Part 3
// Part 3
// Expected to fail executing second query because default cursor for first
// query is still active when connection is broken
///////////////////////////////////////////////////////////////////////////////
try
{
$conn = new PDO( "sqlsrv:server = $server ; Database = $dbName ; $connectionInfo", $uid, $pwd );
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
}
catch( PDOException $e )
{
try {
$conn = connect($connectionInfo, array(), PDO::ERRMODE_EXCEPTION, true);
} catch (PDOException $e) {
echo "Could not connect.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
$query1 = "SELECT * FROM $tableName1";
try
{
$stmt5 = $conn->query( $query1 );
if ( $stmt5 ) echo "Statement 5 successful.\n";
try {
$stmt5 = $conn->query($query1);
if ($stmt5) {
echo "Statement 5 successful.\n";
}
$rowcount = $stmt5->rowCount();
echo $rowcount." rows in result set.\n";
}
catch( PDOException $e )
{
} catch (PDOException $e) {
echo "Error executing statement 5.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
BreakConnection( $conn, $conn_break );
breakConnection($conn, $conn_break);
$query2 = "SELECT * FROM $tableName2";
try
{
$stmt6 = $conn->query( $query2 );
if ( $stmt6 ) echo "Statement 6 successful.\n";
try {
$stmt6 = $conn->query($query2);
if ($stmt6) {
echo "Statement 6 successful.\n";
}
$rowcount = $stmt6->rowCount();
echo $rowcount." rows in result set.\n";
}
catch( PDOException $e )
{
} catch (PDOException $e) {
echo "Error executing statement 6.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
$conn = null;
unset($conn);
///////////////////////////////////////////////////////////////////////////////
// Part 4
// Part 4
// Expected to trigger an error because there are two active statements with
// pending results and MARS is off
///////////////////////////////////////////////////////////////////////////////
$connectionInfo = "ConnectRetryCount = 10; ConnectRetryInterval = 10; MultipleActiveResultSets = false;";
try
{
$conn = new PDO( "sqlsrv:server = $server ; Database = $dbName ; $connectionInfo", $uid, $pwd );
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
}
catch( PDOException $e )
{
try {
$conn = connect($connectionInfo, array(), PDO::ERRMODE_EXCEPTION, true);
} catch (PDOException $e) {
echo "Could not connect.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
BreakConnection( $conn, $conn_break );
breakConnection($conn, $conn_break);
try
{
$stmt7 = $conn->query( "SELECT * FROM $tableName1" );
if ( $stmt7 ) echo "Statement 7 successful.\n";
}
catch( PDOException $e )
{
try {
$stmt7 = $conn->query("SELECT * FROM $tableName1");
if ($stmt7) {
echo "Statement 7 successful.\n";
}
} catch (PDOException $e) {
echo "Error executing statement 7.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
try
{
$stmt8 = $conn->query( "SELECT * FROM $tableName2" );
if ( $stmt8 ) echo "Statement 8 successful.\n";
}
catch( PDOException $e )
{
try {
$stmt8 = $conn->query("SELECT * FROM $tableName2");
if ($stmt8) {
echo "Statement 8 successful.\n";
}
} catch (PDOException $e) {
echo "Error executing statement 8.\n";
print_r( $e->getMessage() );
print_r($e->getMessage());
}
$conn = null;
$conn_break = null;
unset($conn);
unset($conn_break);
?>
--EXPECTREGEX--

64
test/functional/pdo_sqlsrv/pdo_decimal_precision.phpt Normal file
View file

@ -0,0 +1,64 @@
--TEST--
Insert into decimal columns with inputs of various scale and precision
--SKIPIF--
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsCommon_mid-refactor.inc");
try {
$conn = connect();
$tableName = "decimal_table";
createTable($conn, $tableName, array("c1_decimal0" => "decimal", "c2_decimal4" => "decimal(19,4)"));
insertRow($conn, $tableName, array("c1_decimal0" => 0.9, "c2_decimal4" => 0.9));
insertRow($conn, $tableName, array("c1_decimal0" => 9.9, "c2_decimal4" => 9.9));
insertRow($conn, $tableName, array("c1_decimal0" => 999.999, "c2_decimal4" => 999.999));
insertRow($conn, $tableName, array("c1_decimal0" => 99999.99999, "c2_decimal4" => 99999.99999));
$query = "SELECT * FROM $tableName";
$stmt = $conn->query($query);
$row = $stmt->fetchAll(PDO::FETCH_ASSOC);
var_dump($row);
dropTable($conn, $tableName);
unset($stmt);
unset($conn);
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
?>
--EXPECT--
array(4) {
[0]=>
array(2) {
["c1_decimal0"]=>
string(1) "1"
["c2_decimal4"]=>
string(5) ".9000"
}
[1]=>
array(2) {
["c1_decimal0"]=>
string(2) "10"
["c2_decimal4"]=>
string(6) "9.9000"
}
[2]=>
array(2) {
["c1_decimal0"]=>
string(4) "1000"
["c2_decimal4"]=>
string(8) "999.9990"
}
[3]=>
array(2) {
["c1_decimal0"]=>
string(6) "100000"
["c2_decimal4"]=>
string(11) "100000.0000"
}
}

29
test/functional/pdo_sqlsrv/pdo_error.phpt
View file

@ -1,28 +1,27 @@
--TEST--
Test the PDO::errorCode() and PDO::errorInfo() methods.
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
try
{
$db = connect();
// query with a wrong column name.
$db->query( "Select * from " . $table1 . " where IntColX = 1" );
}
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
catch( PDOException $e ) {
try {
$db = connect();
$tbname = "PDO_MainTypes";
createTableMainTypes($db, $tbname);
// query with a wrong column name.
$db->query("SELECT * FROM $tbname WHERE IntColX = 1");
dropTable($db, $tbname);
unset($conn);
} catch (PDOException $e) {
print($db->errorCode());
echo "\n";
print_r($db->errorInfo());
exit;
}
?>
?>
--EXPECTREGEX--
42S22
Array

85
test/functional/pdo_sqlsrv/pdo_insertDataType.phpt
View file

@ -1,50 +1,59 @@
--TEST--
Test the different type of data for retrieving
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
try
{
try {
$db = connect();
$query = "INSERT INTO PDO_AllTypes (";
$query .= "BigIntCol,BitCol,IntCol,";
$query .= "SmallIntCol,TinyIntCol,";
$query .= "DecimalCol,NumCol,MoneyCol,";
$query .= "SmallMoneyCol,FloatCol,RealCol,";
$query .= "CharCol,VarcharCol,TextCol,";
$query .= "NCharCol,NVarcharCol,ImageCol,";
$query .= "BinaryCol,VarbinaryCol,SmallDTCol,";
$query .= "DateTimeCol,DTOffsetCol,";
$query .= "TimeCol,Guidcol,VarbinaryMaxCol,";
$query .= "VarcharMaxCol,XmlCol,NTextCol,";
$query .= "NVarCharMaxCol) VALUES (1,'0',1,1,1,111,1,";
$query .= "111.1110,111.1110,111.111,111.111,";
$query .= "'STRINGCOL1','STRINGCOL1',";
$query .= "'1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',";
$query .= "'STRINGCOL1','STRINGCOL1','00',";
$query .= "CONVERT(BINARY(2),'0000000000',2),CONVERT(VARBINARY(2),CAST('00' AS VARCHAR(2)),2),'2000-11-11 11:11:00',";
$query .= "'2000-11-11 11:11:11.110',";
$query .= "'2000-11-11 11:11:11.1110000 +00:00','11:11:11.1110000',";
$query .= "'AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA',CONVERT(VARBINARY(MAX),CAST('00' AS VARCHAR(MAX)),2) ,";
$query .= "'1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',";
$query .= "'<xml> 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>',";
$query .= "'1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',";
$query .= "'1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.')";
$numRows = $db->exec($query);
echo "Insert complete!";
}
catch(PDOException $e)
{
$tbname = "PDO_AllTypes";
createTableAllTypes($db, $tbname);
$bin = fopen('php://memory', 'a');
fwrite($bin, '00');
rewind($bin);
$inputs = array("BigIntCol" => 0,
"BitCol" => '0',
"IntCol" => 1,
"SmallIntCol" => 1,
"TinyIntCol" => 1,
"DecimalCol" => 111,
"NumCol" => 1,
"MoneyCol" => 111.1110,
"SmallMoneyCol" => 111.1110,
"FloatCol" => 111.111,
"RealCol" => 111.111,
"CharCol" => 'STRINGCOL1',
"VarcharCol" => 'STRINGCOL1',
"TextCol" => '1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',
"NCharCol" => 'STRINGCOL1',
"NVarcharCol" => 'STRINGCOL1',
"ImageCol" => new BindParamOp(17, $bin, "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"BinaryCol" => new BindParamOp(18, $bin, "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"VarbinaryCol" => new BindParamOp(19, $bin, "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"SmallDTCol" => '2000-11-11 11:11:00',
"DateTimeCol" => '2000-11-11 11:11:11.110',
"DTOffsetCol" => '2000-11-11 11:11:11.1110000 +00:00',
"TimeCol" => '11:11:11.1110000',
"Guidcol" => 'AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA',
"VarbinaryMaxCol" => new BindParamOp(25, $bin, "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"VarcharMaxCol" => '1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',
"XmlCol" => '<xml> 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>',
"NTextCol" => '1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',
"NVarCharMaxCol" => '1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.');
$stmt = insertRow($db, $tbname, $inputs, "prepareBindParam");
dropTable($db, $tbname);
unset($stmt);
unset($conn);
echo "Insert complete!\n";
} catch (PDOException $e) {
var_dump($e);
}
?>
--EXPECT--
Insert complete!
Insert complete!

64
test/functional/pdo_sqlsrv/pdo_prepare.phpt
View file

@ -3,94 +3,84 @@ Test the PDO::prepare() method.
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
require 'MsSetup.inc';
require_once 'MsCommon.inc';
try
{
try {
$db = connect();
$db->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
$tbname = "PDO_MainTypes";
createAndInsertTableMainTypes($db, $tbname);
// Test_1 : Test with no parameters
echo "Test_1 : Test with no parameters :\n";
$stmt = $db->prepare('select * from ' . $table1);
if(!$stmt->execute())
{
$stmt = $db->prepare("select * from $tbname");
if (!$stmt->execute()) {
die("Test_1 failed.");
}
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
var_dump($result);
// Test_2 : Test with indexed parameters
echo "Test_2 : Test with indexed parameters :\n";
$stmt = $db->prepare('select IntCol, CharCol from ' . $table1 . ' where IntCol = ? and CharCol = ?');
if(!$stmt->execute(array(1, 'STRINGCOL1')))
{
$stmt = $db->prepare("select IntCol, CharCol from $tbname where IntCol = ? and CharCol = ?");
if (!$stmt->execute(array(1, 'STRINGCOL1'))) {
die("Test_2 failed.");
}
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
var_dump($result);
// Test_3 : Test with named parameters
echo "Test_3 : Test with named parameters :\n";
$IntColVal = 2;
$CharColVal = 'STRINGCOL2';
$stmt = $db->prepare('select IntCol, CharCol from ' . $table1 . ' where IntCol = :IntColVal and CharCol = :CharColVal');
if(!$stmt->execute(array(':IntColVal' => $IntColVal, ':CharColVal' => $CharColVal)))
{
$stmt = $db->prepare("select IntCol, CharCol from $tbname where IntCol = :IntColVal and CharCol = :CharColVal");
if (!$stmt->execute(array(':IntColVal' => $IntColVal, ':CharColVal' => $CharColVal))) {
die("Test_3 failed.");
}
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
var_dump($result);
// Test_4: Test single prepare, multiple execution with indexed parameters
echo "Test_4 : Test single prepare, multiple execution with indexed parameters :\n";
$IntColVal = 1;
$stmt = $db->prepare('select IntCol from ' . $table1 . ' where IntCol = ?');
$stmt = $db->prepare("select IntCol from $tbname where IntCol = ?");
$stmt->bindParam(1, $IntColVal);
if(!$stmt->execute())
{
if (!$stmt->execute()) {
die("Test_4 failed.");
}
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
var_dump($result);
// Execute the stmt again
$IntColVal = 2;
if(!$stmt->execute())
{
if (!$stmt->execute()) {
die("Test_4 failed.");
}
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
var_dump($result);
// Test_5: Test single prepare, multiple execution with named parameters
echo "Test_5 : Test single prepare, multiple execution with named parameters :\n";
$IntColVal = 1;
$stmt = $db->prepare('select IntCol from ' . $table1 . ' where IntCol = :IntColVal');
$stmt = $db->prepare("select IntCol from $tbname where IntCol = :IntColVal");
$stmt->bindParam(':IntColVal', $IntColVal);
if(!$stmt->execute())
{
if (!$stmt->execute()) {
die("Test_5 failed.");
}
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
var_dump($result);
// Execute the stmt again
$IntColVal = 2;
if(!$stmt->execute())
{
if (!$stmt->execute()) {
die("Test_5 failed.");
}
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
catch(PDOException $err)
{
var_dump($result);
} catch (PDOException $err) {
var_dump($err);
exit();
}

129
test/functional/pdo_sqlsrv/pdo_prepare_emulatePrepare_float.phpt
View file

@ -1,81 +1,82 @@
--TEST--
prepare with emulate prepare and binding integer
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require('MsSetup.inc');
$conn = new PDO( "sqlsrv:server=$server ; Database = $databaseName", $uid, $pwd);
require_once('MsCommon_mid-refactor.inc');
$tableName = "number_types";
try {
$conn = connect("", array(), PDO::ERRMODE_SILENT);
$query = "IF OBJECT_ID('number_types') IS NOT NULL DROP TABLE [$tableName]";
$stmt = $conn->query($query);
$tableName = "number_types";
if (!isColEncrypted()) {
createTable($conn, $tableName, array("c1_decimal" => "decimal", "c2_money" => "money", "c3_float" => "float"));
} else {
// money is not supported for column encryption, use decimal(19,4) instead
createTable($conn, $tableName, array("c1_decimal" => "decimal", "c2_money" => "decimal(19,4)", "c3_float" => "float"));
}
$query = "CREATE TABLE [$tableName] (c1_decimal decimal, c2_money money, c3_float float)";
$stmt = $conn->query($query);
insertRow($conn, $tableName, array("c1_decimal" => 411.1, "c2_money" => 131.11, "c3_float" => 611.111));
insertRow($conn, $tableName, array("c1_decimal" => 422.2222, "c2_money" => 132.22, "c3_float" => 622.22));
insertRow($conn, $tableName, array("c1_decimal" => 433.333, "c2_money" => 133.3333, "c3_float" => 633.33333));
$query = "INSERT INTO [$tableName] (c1_decimal, c2_money, c3_float) VALUES (411.1, 131.11, 611.111)";
$stmt = $conn->query($query);
$query = "SELECT * FROM [$tableName] WHERE c3_float = :c3";
$query = "INSERT INTO [$tableName] (c1_decimal, c2_money, c3_float) VALUES (422.2222, 132.222, 622.22)";
$stmt = $conn->query($query);
// prepare without emulate prepare
print_r("Prepare without emulate prepare:\n");
$options = array(PDO::ATTR_EMULATE_PREPARES => false);
$stmt = $conn->prepare($query, $options);
$c3 = 611.111;
$stmt->bindParam(':c3', $c3);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
$query = "INSERT INTO [$tableName] (c1_decimal, c2_money, c3_float) VALUES (433.333, 133.3333, 633.33333 )";
$stmt = $conn->query($query);
//with emulate prepare and no bind param options
print_r("Prepare with emulate prepare and no bind param options:\n");
if (!isColEncrypted()) {
// emulate prepare is not supported for encrypted columns
$options = array(PDO::ATTR_EMULATE_PREPARES => true);
}
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':c3', $c3);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
$query = "SELECT * FROM [$tableName] WHERE c3_float = :c3";
//with emulate prepare and encoding SQLSRV_ENCODING_SYSTEM
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_SYSTEM:\n");
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':c3', $c3, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_SYSTEM);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
// prepare without emulate prepare
print_r("Prepare without emulate prepare:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => false));
$c3 = 611.111;
$stmt->bindParam(':c3', $c3);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
//prepare with emulate prepare and encoding SQLSRV_ENCODING_UTF8
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_UTF8:\n");
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':c3', $c3, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_UTF8);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
//with emulate prepare and no bind param options
print_r("Prepare with emulate prepare and no bind param options:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$c3 = 611.111;
$stmt->bindParam(':c3', $c3);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
//with emulate prepare and encoding SQLSRV_ENCODING_SYSTEM
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_SYSTEM:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$c3 = 611.111;
$stmt->bindParam(':c3', $c3, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_SYSTEM);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
//prepare with emulate prepare and encoding SQLSRV_ENCODING_UTF8
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_UTF8:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$c3 = 611.111;
$stmt->bindParam(':c3', $c3, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_UTF8);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
//prepare with emulate prepare and encoding SQLSRV_ENCODING_BINARY
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_BINARY:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$c3 = 611.111;
$stmt->bindParam(':c3', $c3, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
if ($stmt->rowCount() == 0){
print_r("No results for this query\n");
//prepare with emulate prepare and encoding SQLSRV_ENCODING_BINARY
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_BINARY:\n");
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':c3', $c3, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
if ($stmt->rowCount() == 0) {
print_r("No results for this query\n");
}
dropTable($conn, $tableName);
unset($stmt);
unset($conn);
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
$stmt = null;
$conn=null;
?>
--EXPECT--
@ -108,4 +109,4 @@ Array
[c3_float] => 611.11099999999999
)
Prepare with emulate prepare and SQLSRV_ENCODING_BINARY:
No results for this query
No results for this query

139
test/functional/pdo_sqlsrv/pdo_prepare_emulatePrepare_int.phpt
View file

@ -1,80 +1,81 @@
--TEST--
prepare with emulate prepare and binding integer
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require('MsSetup.inc');
$conn = new PDO( "sqlsrv:server=$server ; Database = $databaseName", $uid, $pwd);
require_once('MsCommon_mid-refactor.inc');
try {
$conn = connect();
$tableName = "fruit";
$tableName = "fruit";
createTable($conn, $tableName, array("name" => "varchar(max)", "calories" => "int"));
$query = "IF OBJECT_ID('fruit') IS NOT NULL DROP TABLE [$tableName]";
$stmt = $conn->query($query);
insertRow($conn, $tableName, array("name" => "apple", "calories" => 150));
insertRow($conn, $tableName, array("name" => "banana", "calories" => 175));
insertRow($conn, $tableName, array("name" => "blueberry", "calories" => 1));
$query = "CREATE TABLE [$tableName] (name varchar(max), calories int)";
$stmt = $conn->query($query);
$query = "SELECT * FROM [$tableName] WHERE calories = :cal";
$query = "INSERT INTO [$tableName] (name, calories) VALUES ('apple', 150)";
$stmt = $conn->query($query);
// prepare without emulate prepare
print_r("Prepare without emulate prepare:\n");
$options = array(PDO::ATTR_EMULATE_PREPARES => false);
$stmt = $conn->prepare($query, $options);
$cal = 1;
$stmt->bindParam(':cal', $cal, PDO::PARAM_INT);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
$query = "INSERT INTO [$tableName] (name, calories) VALUES ('banana', 175)";
$stmt = $conn->query($query);
// prepare with emulate prepare
print_r("Prepare with emulate prepare and no bindParam options:\n");
if (!isColEncrypted()) {
// emulate prepare is not supported for encrypted columns
$options = array(PDO::ATTR_EMULATE_PREPARES => true);
}
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':cal', $cal, PDO::PARAM_INT);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
$query = "INSERT INTO [$tableName] (name, calories) VALUES ('blueberry', 1)";
$stmt = $conn->query($query);
if (!isColEncrypted()) {
// without emulate prepare, binding PARAM_INT with SQLSRV_ENCODING_SYSTEM is not allowed
// thus the following will not be tested when Column Encryption is enabled
$query = "SELECT * FROM [$tableName] WHERE calories = :cal";
$results = array();
//prepare with emulate prepare and encoding SQLSRV_ENCODING_SYSTEM
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':cal', $cal, PDO::PARAM_INT, 0, PDO::SQLSRV_ENCODING_SYSTEM);
$stmt->execute();
$results["SYSTEM"] = $stmt->fetch(PDO::FETCH_ASSOC);
// prepare without emulate prepare
print_r("Prepare without emulate prepare:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => false));
$cal = 1;
$stmt->bindParam(':cal', $cal, PDO::PARAM_INT);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
//prepare with emulate prepare and encoding SQLSRV_ENCODING_UTF8
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':cal', $cal, PDO::PARAM_INT, 0, PDO::SQLSRV_ENCODING_UTF8);
$stmt->execute();
$results["UTF8"] = $stmt->fetch(PDO::FETCH_ASSOC);
// prepare with emulate prepare
print_r("Prepare with emulate prepare and no bindParam options:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$cal = 1;
$stmt->bindParam(':cal', $cal, PDO::PARAM_INT);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
//prepare with emulate prepare and encoding SQLSRV_ENCODING_BINARY
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':cal', $cal, PDO::PARAM_INT, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->execute();
$results["BINARY"] = $stmt->fetch(PDO::FETCH_ASSOC);
//prepare with emulate prepare and encoding SQLSRV_ENCODING_SYSTEM
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_UTF8:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$cal = 1;
$stmt->bindParam(':cal', $cal, PDO::PARAM_INT, 0, PDO::SQLSRV_ENCODING_SYSTEM);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
foreach ($results as $key => $value) {
if ($value['name'] != "blueberry" || $value['calories'] != 1) {
echo "Failed to fetch when binding parameter with $key encoding.\n";
}
}
}
//prepare with emulate prepare and encoding SQLSRV_ENCODING_UTF8
print_r("Prepare with emulate prepare and and SQLSRV_ENCODING_SYSTEM:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$cal = 1;
$stmt->bindParam(':cal', $cal, PDO::PARAM_INT, 0, PDO::SQLSRV_ENCODING_UTF8);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
//prepare with emulate prepare and encoding SQLSRV_ENCODING_BINARY
print_r("Prepare with emulate prepare and encoding SQLSRV_ENCODING_BINARY:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$cal = 1;
$stmt->bindParam(':cal', $cal, PDO::PARAM_INT, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
$stmt = null;
$conn=null;
dropTable($conn, $tableName);
unset($stmt);
unset($conn);
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
?>
--EXPECT--
Prepare without emulate prepare:
Array
@ -88,21 +89,3 @@ Array
[name] => blueberry
[calories] => 1
)
Prepare with emulate prepare and SQLSRV_ENCODING_UTF8:
Array
(
[name] => blueberry
[calories] => 1
)
Prepare with emulate prepare and and SQLSRV_ENCODING_SYSTEM:
Array
(
[name] => blueberry
[calories] => 1
)
Prepare with emulate prepare and encoding SQLSRV_ENCODING_BINARY:
Array
(
[name] => blueberry
[calories] => 1
)

128
test/functional/pdo_sqlsrv/pdo_prepare_emulatePrepare_money.phpt
View file

@ -1,81 +1,83 @@
--TEST--
prepare with emulate prepare and binding integer
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require('MsSetup.inc');
$conn = new PDO( "sqlsrv:server=$server ; Database = $databaseName", $uid, $pwd);
require_once('MsCommon_mid-refactor.inc');
$tableName = "number_types";
try {
$conn = connect("", array(), PDO::ERRMODE_SILENT);
$query = "IF OBJECT_ID('number_types') IS NOT NULL DROP TABLE [$tableName]";
$stmt = $conn->query($query);
$tableName = "number_types";
if (!isColEncrypted()) {
createTable($conn, $tableName, array("c1_decimal" => "decimal", "c2_money" => "money", "c3_float" => "float"));
} else {
// money is not supported for column encryption, use decimal(19,4) instead
createTable($conn, $tableName, array("c1_decimal" => "decimal", "c2_money" => "decimal(19,4)", "c3_float" => "float"));
}
$query = "CREATE TABLE [$tableName] (c1_decimal decimal, c2_money money, c3_float float)";
$stmt = $conn->query($query);
insertRow($conn, $tableName, array("c1_decimal" => 411.1, "c2_money" => 131.11, "c3_float" => 611.111));
insertRow($conn, $tableName, array("c1_decimal" => 422.2222, "c2_money" => 132.22, "c3_float" => 622.22));
insertRow($conn, $tableName, array("c1_decimal" => 433.333, "c2_money" => 133.3333, "c3_float" => 633.33333));
$query = "INSERT INTO [$tableName] (c1_decimal, c2_money, c3_float) VALUES (411.1, 131.11, 611.111)";
$stmt = $conn->query($query);
$query = "SELECT * FROM [$tableName] WHERE c2_money = :c2";
$query = "INSERT INTO [$tableName] (c1_decimal, c2_money, c3_float) VALUES (422.2222, 132.222, 622.22)";
$stmt = $conn->query($query);
// prepare without emulate prepare
print_r("Prepare without emulate prepare:\n");
$options = array(PDO::ATTR_EMULATE_PREPARES => false);
$stmt = $conn->prepare($query, $options);
$c2 = 133.3333;
$stmt->bindParam(':c2', $c2);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
$query = "INSERT INTO [$tableName] (c1_decimal, c2_money, c3_float) VALUES (433.333, 133.3333, 633.33333 )";
$stmt = $conn->query($query);
//with emulate prepare and no bind param options
print_r("Prepare with emulate prepare and no bind param options:\n");
if (!isColEncrypted()) {
// emulate prepare is not supported for encrypted columns
$options = array(PDO::ATTR_EMULATE_PREPARES => true);
}
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':c2', $c2);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
$query = "SELECT * FROM [$tableName] WHERE c2_money = :c2";
//with emulate prepare and encoding SQLSRV_ENCODING_SYSTEM
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_SYSTEM:\n");
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':c2', $c2, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_SYSTEM);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
// prepare without emulate prepare
print_r("Prepare without emulate prepare:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => false));
$c2 = 133.3333;
$stmt->bindParam(':c2', $c2);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
//prepare with emulate prepare and encoding SQLSRV_ENCODING_UTF8
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_UTF8:\n");
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':c2', $c2, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_UTF8);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
//with emulate prepare and no bind param options
print_r("Prepare with emulate prepare and no bind param options:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$c2 = 133.3333;
$stmt->bindParam(':c2', $c2);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
//prepare with emulate prepare and encoding SQLSRV_ENCODING_BINARY
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_BINARY:\n");
$stmt = $conn->prepare($query, $options);
$stmt->bindParam(':c2', $c2, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
if ($stmt->rowCount() == 0) {
print_r("No results for this query\n");
}
//with emulate prepare and encoding SQLSRV_ENCODING_SYSTEM
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_SYSTEM:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$c2 = 133.3333;
$stmt->bindParam(':c2', $c2, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_SYSTEM);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
//prepare with emulate prepare and encoding SQLSRV_ENCODING_UTF8
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_UTF8:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$c2 = 133.3333;
$stmt->bindParam(':c2', $c2, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_UTF8);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
//prepare with emulate prepare and encoding SQLSRV_ENCODING_BINARY
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_BINARY:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$c2 = 133.3333;
$stmt->bindParam(':c2', $c2, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
if ($stmt->rowCount() == 0){
print_r("No results for this query\n");
dropTable($conn, $tableName);
unset($stmt);
unset($conn);
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
$stmt = null;
$conn=null;
?>
--EXPECT--
@ -108,4 +110,4 @@ Array
[c3_float] => 633.33333000000005
)
Prepare with emulate prepare and SQLSRV_ENCODING_BINARY:
No results for this query
No results for this query

160
test/functional/pdo_sqlsrv/pdo_prepare_emulatePrepare_unicode.phpt
View file

@ -1,89 +1,95 @@
--TEST--
prepare with emulate prepare and binding uft8 characters
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require('MsSetup.inc');
$conn = new PDO( "sqlsrv:server=$server ; Database = $databaseName", $uid, $pwd);
//$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
//$conn->setAttribute( PDO::SQLSRV_ATTR_QUERY_TIMEOUT, 1 );
require_once('MsCommon_mid-refactor.inc');
$tableName = "users";
$query = "IF OBJECT_ID('users') IS NOT NULL DROP TABLE [$tableName]";
$stmt = $conn->query($query);
$query = "CREATE TABLE [$tableName] (name nvarchar(max), status int, age int)";
$stmt = $conn->query($query);
$query = "INSERT INTO [$tableName] (name, status, age) VALUES (N'Belle', 1, 34)";
$stmt = $conn->query($query);
$query = "INSERT INTO [$tableName] (name, status, age) VALUES (N'Абрам', 1, 40)";
$stmt = $conn->query($query);
$query = "INSERT INTO [$tableName] (name, status, age) VALUES (N'가각', 1, 30)";
$stmt = $conn->query($query);
$name = "가각";
$query = "SELECT * FROM [$tableName] WHERE name = :name AND status = 1";
//without emulate prepare
print_r("Prepare without emulate prepare:\n");
$stmt = $conn->prepare($query);
$stmt->bindParam(':name', $name, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_UTF8);
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
//with emulate prepare and no bind param options
print_r("Prepare with emulate prepare and no bindParam options:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$stmt->bindParam(':name', $name );
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
if ($stmt->rowCount() == 0){
print_r("No results for this query\n");
function prepareStmt($conn, $query, $prepareOptions = array(), $dataType = null, $length = null, $driverOptions = null)
{
$name = "가각";
if (!isColEncrypted()) {
$stmt = $conn->prepare($query, $prepareOptions);
$stmt->bindParam(':name', $name, $dataType, $length, $driverOptions);
} else {
$status = 1;
$stmt = $conn->prepare($query, $prepareOptions);
$stmt->bindParam(':name', $name, $dataType, $length, $driverOptions);
$stmt->bindParam(':status', $status);
}
$stmt->execute();
return $stmt;
}
//with emulate prepare and SQLSRV_ENCODING_UTF8
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_UTF8:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$stmt->bindParam(':name', $name, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_UTF8);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
try {
$conn = connect("", array(), PDO::ERRMODE_SILENT);
//with emulate prepare and SQLSRV_ENCODING_SYSTEM
print_r("Prepare with emulate prepare and and SQLSRV_ENCODING_SYSTEM:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$stmt->bindParam(':name', $name, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_SYSTEM);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
if ($stmt->rowCount() == 0){
print_r("No results for this query\n");
$tableName = "users";
createTable($conn, $tableName, array("name" => "nvarchar(max)", "status" => "int", "age" => "int"));
if (!isColEncrypted()) {
$conn->exec("INSERT INTO [$tableName] (name, status, age) VALUES (N'Belle', 1, 34)");
$conn->exec("INSERT INTO [$tableName] (name, status, age) VALUES (N'Абрам', 1, 40)");
$conn->exec("INSERT INTO [$tableName] (name, status, age) VALUES (N'가각', 1, 30)");
$query = "SELECT * FROM [$tableName] WHERE name = :name AND status = 1";
} else {
insertRow($conn, $tableName, array("name" => "Belle", "status" => 1, "age" => 34));
insertRow($conn, $tableName, array("name" => "Абрам", "status" => 1, "age" => 40));
insertRow($conn, $tableName, array("name" => "가각", "status" => 1, "age" => 30));
$query = "SELECT * FROM [$tableName] WHERE name = :name AND status = :status";
}
//without emulate prepare
print_r("Prepare without emulate prepare:\n");
$stmt = prepareStmt($conn, $query, array(), PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_UTF8);
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
//with emulate prepare and no bind param options
print_r("Prepare with emulate prepare and no bindParam options:\n");
if (!isColEncrypted()) {
$options = array(PDO::ATTR_EMULATE_PREPARES => true);
} else {
$options = array(PDO::ATTR_EMULATE_PREPARES => false);
}
$stmt = prepareStmt($conn, $query, $options);
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
if ($stmt->rowCount() == 0) {
print_r("No results for this query\n");
}
//with emulate prepare and SQLSRV_ENCODING_UTF8
print_r("Prepare with emulate prepare and SQLSRV_ENCODING_UTF8:\n");
$stmt = prepareStmt($conn, $query, $options, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_UTF8);
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
//with emulate prepare and SQLSRV_ENCODING_SYSTEM
print_r("Prepare with emulate prepare and and SQLSRV_ENCODING_SYSTEM:\n");
$stmt = prepareStmt($conn, $query, $options, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_SYSTEM);
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
if ($stmt->rowCount() == 0) {
print_r("No results for this query\n");
}
//with emulate prepare and encoding SQLSRV_ENCODING_BINARY
print_r("Prepare with emulate prepare and encoding SQLSRV_ENCODING_BINARY:\n");
$stmt = prepareStmt($conn, $query, $options, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY);
$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
if ($stmt->rowCount() == 0) {
print_r("No results for this query\n");
}
dropTable($conn, $tableName);
unset($stmt);
unset($conn);
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
//with emulate prepare and encoding SQLSRV_ENCODING_BINARY
print_r("Prepare with emulate prepare and encoding SQLSRV_ENCODING_BINARY:\n");
$stmt = $conn->prepare($query, array(PDO::ATTR_EMULATE_PREPARES => true));
$stmt->bindParam(':name', $name, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->execute();
$row = $stmt->fetch( PDO::FETCH_ASSOC );
print_r($row);
if ($stmt->rowCount() == 0){
print_r("No results for this query\n");
}
//$query = "DROP TABLE [$tableName]";
//$stmt = $conn->query($query);
$stmt = null;
$conn=null;
?>
--EXPECT--
@ -106,4 +112,4 @@ Array
Prepare with emulate prepare and and SQLSRV_ENCODING_SYSTEM:
No results for this query
Prepare with emulate prepare and encoding SQLSRV_ENCODING_BINARY:
No results for this query
No results for this query

33
test/functional/pdo_sqlsrv/pdo_prepare_invalid_cursor.phpt
View file

@ -1,33 +1,28 @@
--TEST--
Test PDO::prepare by passing in invalid cursor value
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsSetup.inc");
require_once("MsCommon_mid-refactor.inc");
try {
$conn = connect("", array(), PDO::ERRMODE_SILENT);
try
{
$conn = new PDO( "sqlsrv:Server = $server; database = $databaseName", $uid, $pwd);
// PDO::CURSOR_FWDONLY should not be quoted
$stmt1 = $conn->prepare( "SELECT 1", array( PDO::ATTR_CURSOR => "PDO::CURSOR_FWDONLY" ));
print_r(($conn->errorInfo())[2]);
echo "\n";
// 10 is an invalid value for PDO::ATTR_CURSOR
$stmt2 = $conn->prepare( "SELECT 2", array( PDO::ATTR_CURSOR => 10 ));
$stmt1 = $conn->prepare("SELECT 1", array( PDO::ATTR_CURSOR => "PDO::CURSOR_FWDONLY" ));
print_r(($conn->errorInfo())[2]);
echo "\n";
// 10 is an invalid value for PDO::ATTR_CURSOR
$stmt2 = $conn->prepare("SELECT 2", array( PDO::ATTR_CURSOR => 10 ));
print_r(($conn->errorInfo())[2]);
echo "\n";
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
catch( PDOException $e ) {
var_dump( $e->errorInfo );
}
?>
?>
--EXPECT--
An invalid cursor type was specified for either PDO::ATTR_CURSOR or PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE
An invalid cursor type was specified for either PDO::ATTR_CURSOR or PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE
An invalid cursor type was specified for either PDO::ATTR_CURSOR or PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE

28
test/functional/pdo_sqlsrv/pdo_prepare_invalid_encoding.phpt
View file

@ -1,32 +1,28 @@
--TEST--
Test PDO::prepare by passing in invalid encoding values
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsSetup.inc");
require_once("MsCommon_mid-refactor.inc");
try {
$conn = connect("", array(), PDO::ERRMODE_SILENT);
try
{
$conn = new PDO( "sqlsrv:Server = $server; database = $databaseName", $uid, $pwd);
// PDO::SQLSRV_ENCODING_SYSTEM should not be quoted
$stmt1 = $conn->prepare( "SELECT 1", array( PDO::SQLSRV_ATTR_ENCODING => "PDO::SQLSRV_ENCODING_SYSTEM" ));
$stmt1 = $conn->prepare("SELECT 1", array( PDO::SQLSRV_ATTR_ENCODING => "PDO::SQLSRV_ENCODING_SYSTEM" ));
print_r(($conn->errorInfo())[2]);
echo "\n";
// 10 is an invalid value for PDO::SQLSRV_ATTR_ENCODING
$stmt2 = $conn->prepare( "SELECT 2", array( PDO::SQLSRV_ATTR_ENCODING => 10 ));
$stmt2 = $conn->prepare("SELECT 2", array( PDO::SQLSRV_ATTR_ENCODING => 10 ));
print_r(($conn->errorInfo())[2]);
echo "\n";
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
catch( PDOException $e ) {
var_dump( $e->errorInfo );
}
?>
?>
--EXPECT--
An invalid encoding was specified for SQLSRV_ATTR_ENCODING.
An invalid encoding was specified for SQLSRV_ATTR_ENCODING.
An invalid encoding was specified for SQLSRV_ATTR_ENCODING.

25
test/functional/pdo_sqlsrv/pdo_prepare_invalid_option_key.phpt
View file

@ -1,28 +1,23 @@
--TEST--
Test PDO::prepare by passing in a string key
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsSetup.inc");
require_once("MsCommon_mid-refactor.inc");
try
{
$dsn = "sqlsrv:Server = $server; database = $databaseName";
$attr = array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION);
$conn = new PDO( $dsn, $uid, $pwd, $attr);
$stmt = $conn->prepare( "SELECT 1", array( "PDO::ATTR_CURSOR" => PDO::CURSOR_FWDONLY ));
try {
$conn = connect();
$stmt = $conn->prepare("SELECT 1", array( "PDO::ATTR_CURSOR" => PDO::CURSOR_FWDONLY ));
echo "Test Successful";
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
catch( PDOException $e ) {
var_dump( $e->errorInfo );
}
?>
?>
--EXPECT--
array(3) {
[0]=>
string(5) "IMSSP"
@ -30,4 +25,4 @@ array(3) {
int(-43)
[2]=>
string(42) "An invalid statement option was specified."
}
}

30
test/functional/pdo_sqlsrv/pdo_prepare_invalid_scrollable_cursor.phpt
View file

@ -1,33 +1,29 @@
--TEST--
Test PDO::prepare by passing in invalid scrollable type value
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsSetup.inc");
require_once("MsCommon_mid-refactor.inc");
try {
$conn = connect("", array(), PDO::ERRMODE_SILENT);
try
{
$conn = new PDO( "sqlsrv:Server = $server; database = $databaseName", $uid, $pwd);
// PDO::SQLSRV_CURSOR_BUFFERED should not be quoted
$stmt1 = $conn->prepare( "SELECT 1", array( PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => "PDO::SQLSRV_CURSOR_BUFFERED" ));
// if ATTR_CURSOR is FWDONLY, cannot set SCROLL_TYPE
$stmt2 = $conn->prepare( "SELECT 2", array( PDO::ATTR_CURSOR => PDO::CURSOR_FWDONLY, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED ));
$stmt1 = $conn->prepare("SELECT 1", array( PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => "PDO::SQLSRV_CURSOR_BUFFERED" ));
if ( $stmt1 || $stmt2 ){
// if ATTR_CURSOR is FWDONLY, cannot set SCROLL_TYPE
$stmt2 = $conn->prepare("SELECT 2", array( PDO::ATTR_CURSOR => PDO::CURSOR_FWDONLY, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED ));
if ($stmt1 || $stmt2) {
echo "Invalid values for PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE should return false.\n";
} else {
echo "Invalid values for PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE return false.\n";
}
}
catch( PDOException $e ) {
} catch (PDOException $e) {
echo $e->getMessage();
}
?>
?>
--EXPECT--
Invalid values for PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE return false.
Invalid values for PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE return false.

30
test/functional/pdo_sqlsrv/pdo_prepare_options.phpt
View file

@ -1,38 +1,34 @@
--TEST--
Test PDO::prepare by passing in attributes
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsSetup.inc");
try
{
require_once("MsCommon_mid-refactor.inc");
try {
class CustomPDOStatement extends PDOStatement
{
protected function __construct() {
protected function __construct()
{
}
}
$dsn = "sqlsrv:Server = $server; database = $databaseName";
$conn = connect();
$prep_attr = array(PDO::SQLSRV_ATTR_ENCODING => PDO::SQLSRV_ENCODING_UTF8,
PDO::ATTR_STATEMENT_CLASS => array('CustomPDOStatement', array()),
PDO::SQLSRV_ATTR_DIRECT_QUERY => true,
PDO::ATTR_EMULATE_PREPARES => false,
PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE => true
);
$conn = new PDO( $dsn, $uid, $pwd);
$stmt = $conn->prepare( "SELECT 1", $prep_attr );
PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE => true);
$stmt = $conn->prepare("SELECT 1", $prep_attr);
echo "Test Successful";
}
catch( PDOException $e ) {
} catch (PDOException $e) {
echo $e->getMessage();
}
?>
?>
--EXPECT--
Test Successful
Test Successful

113
test/functional/pdo_sqlsrv/pdo_query.phpt
View file

@ -3,83 +3,80 @@ Test the PDO::query() method.
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
function query_default( $conn )
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
function queryDefault($conn, $tbname)
{
global $table1;
$stmt = $conn->query( "Select * from " . $table1 );
$stmt = $conn->query("Select * from $tbname");
$result = $stmt->fetch();
var_dump($result);
}
function query_column( $conn )
{
global $table1;
$stmt = $conn->query( "Select * from " . $table1, PDO::FETCH_COLUMN, 2 );
$result = $stmt->fetch();
var_dump($result);
}
function query_class( $conn )
{
global $table1;
global $table1_class;
$stmt = $conn->query( "Select * from " . $table1, PDO::FETCH_CLASS, $table1_class );
$result = $stmt->fetch();
$result->dumpAll();
}
function query_into( $conn )
{
global $table1;
global $table1_class;
$obj = new $table1_class;
$stmt = $conn->query( "Select * from " . $table1, PDO::FETCH_INTO, $obj );
$result = $stmt->fetch();
$result->dumpAll();
}
function query_empty_table( $conn )
{
CreateTableEx($conn, 'emptyTable', "c1 INT, c2 INT");
$stmt = $conn->query( "Select * from emptyTable");
$result = $stmt->fetch();
var_dump($result);
DropTable($conn, 'emptyTable');
}
try
{
function queryColumn($conn, $tbname)
{
$stmt = $conn->query("Select * from $tbname", PDO::FETCH_COLUMN, 2);
$result = $stmt->fetch();
var_dump($result);
}
function queryClass($conn, $tbname)
{
global $mainTypesClass;
$stmt = $conn->query("Select * from $tbname", PDO::FETCH_CLASS, $mainTypesClass);
$result = $stmt->fetch();
$result->dumpAll();
}
function queryInto($conn, $tbname)
{
global $mainTypesClass;
$obj = new $mainTypesClass;
$stmt = $conn->query("Select * from $tbname", PDO::FETCH_INTO, $obj);
$result = $stmt->fetch();
$result->dumpAll();
}
function queryEmptyTable($conn)
{
createTable($conn, 'emptyTable', array("c1" => "int", "c2" => "int"));
$stmt = $conn->query("Select * from emptyTable");
$result = $stmt->fetch();
var_dump($result);
dropTable($conn, 'emptyTable');
}
try {
$db = connect();
$tbname = "PDO_MainTypes";
createAndInsertTableMainTypes($db, $tbname);
echo "TEST_1 : query with default fetch style :\n";
query_default($db);
queryDefault($db, $tbname);
echo "TEST_2 : query with FETCH_COLUMN :\n";
query_column($db);
queryColumn($db, $tbname);
echo "TEST_3 : query with FETCH_CLASS :\n";
query_class($db);
queryClass($db, $tbname);
echo "TEST_4 : query with FETCH_INTO :\n";
query_into($db);
echo "TEST_5 : query an empty table :\n";
query_empty_table($db);
}
queryInto($db, $tbname);
catch( PDOException $e ) {
var_dump( $e );
echo "TEST_5 : query an empty table :\n";
queryEmptyTable($db);
dropTable($db, $tbname);
unset($db);
} catch (PDOException $e) {
var_dump($e);
exit;
}
?>
?>
--EXPECT--
TEST_1 : query with default fetch style :
array(16) {
@ -137,4 +134,4 @@ string(10) "STRINGCOL1"
string(7) "111.111"
string(431) "<xml> 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>"
TEST_5 : query an empty table :
bool(false)
bool(false)

73
test/functional/pdo_sqlsrv/pdo_query_timeout.phpt
View file

@ -1,73 +1,50 @@
--TEST--
test query time out at the connection level and statement level
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsCommon_mid-refactor.inc");
include 'MsCommon.inc';
function QueryTimeout($connLevel)
function queryTimeout($connLevel)
{
require("MsSetup.inc");
$tableName = GetTempTableName();
$conn = new PDO( "sqlsrv:server=$server;database=$databaseName", $uid, $pwd);
$stmt = $conn->exec("CREATE TABLE $tableName ([c1_int] int, [c2_varchar] varchar(25))");
$query = "INSERT INTO $tableName ([c1_int], [c2_varchar]) VALUES (1, 'QueryTimeout 1')";
$stmt = $conn->query($query);
$query = "INSERT INTO $tableName ([c1_int], [c2_varchar]) VALUES (2, 'QueryTimeout 2')";
$stmt = $conn->query($query);
$conn = connect('', array(), PDO::ERRMODE_SILENT);
$tableName = getTableName();
createTable($conn, $tableName, array("c1_int" => "int", "c2_varchar" => "varchar(25)"));
insertRow($conn, $tableName, array("c1_int" => 1, "c2_varchar" => "QueryTimeout 1"));
insertRow($conn, $tableName, array("c1_int" => 2, "c2_varchar" => "QueryTimeout 2"));
$query = "SELECT * FROM $tableName";
if ($connLevel)
{
if ($connLevel) {
echo "Setting query timeout as an attribute in connection\n";
$conn->setAttribute(constant('PDO::SQLSRV_ATTR_QUERY_TIMEOUT'), 1);
$stmt = $conn->query("WAITFOR DELAY '00:00:03'; $query");
var_dump($conn->errorInfo());
}
else
{
} else {
echo "Setting query timeout in the statement\n";
$stmt = $conn->prepare("WAITFOR DELAY '00:00:03'; $query", array(constant('PDO::SQLSRV_ATTR_QUERY_TIMEOUT') => 1));
$stmt->execute();
var_dump($stmt->errorInfo());
}
$stmt = null;
$conn = null;
dropTable($conn, $tableName);
unset($stmt);
unset($conn);
}
function RunTest()
{
StartTest("pdo_query_timeout");
echo "\nStarting test...\n";
try
{
QueryTimeout(true);
QueryTimeout(false);
}
catch (Exception $e)
{
echo $e->getMessage();
}
echo "\nDone\n";
EndTest("pdo_query_timeout");
echo "Starting test...\n";
try {
queryTimeout(true);
queryTimeout(false);
} catch (Exception $e) {
echo $e->getMessage();
}
RunTest();
echo "Done\n";
?>
--EXPECTREGEX--
Starting test\.\.\.
Setting query timeout as an attribute in connection
array\(3\) \{
@ -87,6 +64,4 @@ array\(3\) \{
\[2\]=>
string\(63\) \"\[Microsoft\]\[ODBC Driver 1[1-9] for SQL Server\]Query timeout expired\"
\}
Done
Test \"pdo_query_timeout\" completed successfully\.

20
test/functional/pdo_sqlsrv/pdo_quote.phpt
View file

@ -1,30 +1,26 @@
--TEST--
Test the PDO::quote() method.
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
try
{
$conn = connect(array(PDO::SQLSRV_ATTR_ENCODING => 3, PDO::ATTR_CASE => 2));
try {
$conn = connect("", array(PDO::SQLSRV_ATTR_ENCODING => 3, PDO::ATTR_CASE => 2));
$unquoted = "ABC'DE";
$quoted1 = $conn->quote($unquoted);
$quoted2 = $conn->quote($quoted1);
$quoted2 = $conn->quote($quoted1);
var_dump($unquoted);
var_dump($quoted1);
var_dump($quoted2);
}
catch( PDOException $e ) {
var_dump( $e );
} catch (PDOException $e) {
var_dump($e);
exit;
}
?>
?>
--EXPECT--
string(6) "ABC'DE"

30
test/functional/pdo_sqlsrv/pdo_set_attr_invalid.phpt
View file

@ -1,33 +1,27 @@
--TEST--
Test setting invalid value or key in connection attributes
Test setting invalid value or key in connection attributes
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsSetup.inc");
require_once("MsCommon_mid-refactor.inc");
try{
$dsn = "sqlsrv:Server = $server; database = $databaseName";
$conn = new PDO( $dsn, $uid, $pwd, array(PDO::ATTR_ERRMODE => PDO::ERRMODE_SILENT));
try {
$conn = connect("", array(), PDO::ERRMODE_SILENT);
// Negative value for query timeout: should raise error
@$conn->setAttribute( PDO::SQLSRV_ATTR_QUERY_TIMEOUT, -1 );
print_r (($conn->errorInfo())[2]);
@$conn->setAttribute(PDO::SQLSRV_ATTR_QUERY_TIMEOUT, -1);
print_r(($conn->errorInfo())[2]);
echo "\n";
// PDO::ATTR_CURSOR is a Statement Level Attribute only
@$conn->setAttribute( PDO::ATTR_CURSOR, PDO::CURSOR_SCROLL );
print_r (($conn->errorInfo())[2]);
}
catch ( PDOException $e ){
@$conn->setAttribute(PDO::ATTR_CURSOR, PDO::CURSOR_SCROLL);
print_r(($conn->errorInfo())[2]);
} catch (PDOException $e) {
echo $e->getMessage();
}
?>
?>
--EXPECT--
Invalid value -1 specified for option PDO::SQLSRV_ATTR_QUERY_TIMEOUT.
The given attribute is only supported on the PDOStatement object.
The given attribute is only supported on the PDOStatement object.

30
test/functional/pdo_sqlsrv/pdo_set_attr_invalid_encoding.phpt
View file

@ -1,39 +1,35 @@
--TEST--
Test setting invalid encoding attributes
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsSetup.inc");
try{
$dsn = "sqlsrv:Server = $server; database = $databaseName";
require_once("MsCommon_mid-refactor.inc");
$conn = new PDO( $dsn, $uid, $pwd, array(PDO::ATTR_ERRMODE => PDO::ERRMODE_SILENT));
try {
$conn = connect("", array(), PDO::ERRMODE_SILENT);
// valid option: should have no error
@$conn->setAttribute( PDO::SQLSRV_ATTR_ENCODING, PDO::SQLSRV_ENCODING_DEFAULT );
print_r (($conn->errorInfo())[2]);
@$conn->setAttribute(PDO::SQLSRV_ATTR_ENCODING, PDO::SQLSRV_ENCODING_DEFAULT);
print_r(($conn->errorInfo())[2]);
echo "\n";
// PDO::SQLSRV_ENCODING_UTF8 should not be quoted
@$conn->setAttribute( PDO::SQLSRV_ATTR_ENCODING, "PDO::SQLSRV_ENCODING_UTF8" );
print_r (($conn->errorInfo())[2]);
@$conn->setAttribute(PDO::SQLSRV_ATTR_ENCODING, "PDO::SQLSRV_ENCODING_UTF8");
print_r(($conn->errorInfo())[2]);
echo "\n";
// PDO::SQLSRV_ENCODING_BINARY is not supported
@$conn->setAttribute( PDO::SQLSRV_ATTR_ENCODING, PDO::SQLSRV_ENCODING_BINARY );
print_r (($conn->errorInfo())[2]);
@$conn->setAttribute(PDO::SQLSRV_ATTR_ENCODING, PDO::SQLSRV_ENCODING_BINARY);
print_r(($conn->errorInfo())[2]);
echo "\n";
}
catch ( PDOException $e ){
} catch (PDOException $e) {
echo $e->getMessage();
}
?>
?>
--EXPECT--
An invalid encoding was specified for SQLSRV_ATTR_ENCODING.
An invalid encoding was specified for SQLSRV_ATTR_ENCODING.
An invalid encoding was specified for SQLSRV_ATTR_ENCODING.

217
test/functional/pdo_sqlsrv/pdo_statement_rowcount_query.phpt
View file

@ -1,180 +1,161 @@
--TEST--
test rowCount() with different querying method and test nextRowset() with different fetch
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
include_once("MsCommon_mid-refactor.inc");
function RowCount_Query($exec)
function rowCountQuery($exec)
{
require("MsSetup.inc");
$tableName = GetTempTableName('testRowCount');
$conn = new PDO( "sqlsrv:server=$server;database=$databaseName", $uid, $pwd);
$stmt = $conn->exec("CREATE TABLE $tableName ([c1_int] int, [c2_real] real)");
$conn = connect();
$tableName = getTableName('testRowCount');
createTable($conn, $tableName, array("c1_int" => "int", "c2_real" => "real"));
$numRows = 5;
for ($i = 1; $i <= $numRows; $i++)
{
InsertData($conn, $tableName, $i);
for ($i = 1; $i <= $numRows; $i++) {
$r = $i * 1.0;
insertRow($conn, $tableName, array("c1_int" => $i, "c2_real" => $r));
}
FetchRowsets($conn, $tableName, $numRows);
for ($i = 1; $i <= $numRows; $i++)
{
UpdateData($conn, $tableName, $i, $exec);
fetchRowsets($conn, $tableName, $numRows);
for ($i = 1; $i <= $numRows; $i++) {
updateData($conn, $tableName, $i, $exec);
}
DeleteData($conn, $tableName, $exec);
$stmt = null;
$conn = null;
deleteData($conn, $tableName, $exec);
dropTable($conn, $tableName);
unset($stmt);
unset($conn);
}
function InsertData($conn, $tableName, $value)
{
$query = "INSERT INTO $tableName VALUES ($value, $value * 1.0)";
$stmt = $conn->query($query);
}
function UpdateData($conn, $tableName, $value, $exec)
function updateData($conn, $tableName, $value, $exec)
{
$newValue = $value * 100;
$query = "UPDATE $tableName SET c1_int = $newValue WHERE (c1_int = $value)";
$rowCount = 0;
if ($exec)
{
$rowCount = $conn->exec($query);
}
else
{
$stmt = $conn->prepare($query);
$rowCount = $stmt->rowCount();
if ($rowCount > 0)
echo "Number of rows affected prior to execution should be 0!\n";
if (isColEncrypted()) {
// need to bind parameters for updating encrypted columns
$query = "UPDATE $tableName SET c1_int = ? WHERE (c1_int = ?)";
$stmt = $conn->prepare($query);
if ($rowCount > 0) {
echo "Number of rows affected prior to execution should be 0!\n";
}
$stmt->bindParam(1, $newValue);
$stmt->bindParam(2, $value);
$stmt->execute();
$rowCount = $stmt->rowCount();
} else {
$query = "UPDATE $tableName SET c1_int = $newValue WHERE (c1_int = $value)";
if ($exec) {
$rowCount = $conn->exec($query);
} else {
$stmt = $conn->prepare($query);
$rowCount = $stmt->rowCount();
if ($rowCount > 0) {
echo "Number of rows affected prior to execution should be 0!\n";
}
$stmt->execute();
$rowCount = $stmt->rowCount();
}
}
if ($rowCount !== 1)
if ($rowCount !== 1) {
echo "Number of rows affected should be 1!\n";
$stmt = null;
}
unset($stmt);
}
function CompareValues($actual, $expected)
function compareValues($actual, $expected)
{
if ($actual != $expected)
{
if ($actual != $expected) {
echo "Unexpected value $value returned! Expected $expected.\n";
}
}
function FetchRowsets($conn, $tableName, $numRows)
function fetchRowsets($conn, $tableName, $numRows)
{
$query = "SELECT [c1_int] FROM $tableName ORDER BY [c1_int]";
if (!isColEncrypted()) {
$query = "SELECT [c1_int] FROM $tableName ORDER BY [c1_int]";
} else {
// ORDER BY is not supported in encrypted columns
$query = "SELECT [c1_int] FROM $tableName";
}
$queries = $query . ';' . $query . ';' . $query;
$stmt = $conn->query($queries);
$i = 0;
while ($row = $stmt->fetch(PDO::FETCH_LAZY))
{
while ($row = $stmt->fetch(PDO::FETCH_LAZY)) {
$value = (int)$row['c1_int'];
CompareValues($value, ++$i);
compareValues($value, ++$i);
}
if ($i != $numRows)
{
if ($i != $numRows) {
echo "Number of rows fetched $i is unexpected!\n";
}
$result = $stmt->nextRowset();
if ($result == false)
{
echo "Missing result sets!\n";
}
$rows = $stmt->fetchAll(PDO::FETCH_NUM);
$i = 0;
foreach ($rows as $row)
{
foreach ($row as $key => $value)
{
$value = (int)$value;
CompareValues($value, ++$i);
}
}
$result = $stmt->nextRowset();
if ($result == false)
{
if ($result == false) {
echo "Missing result sets!\n";
}
$rows = $stmt->fetchAll(PDO::FETCH_NUM);
$i = 0;
foreach ($rows as $row) {
foreach ($row as $key => $value) {
$value = (int)$value;
compareValues($value, ++$i);
}
}
$result = $stmt->nextRowset();
if ($result == false) {
echo "Missing result sets!\n";
}
$stmt->bindColumn('c1_int', $value);
$i = 0;
while ($row = $stmt->fetch(PDO::FETCH_BOUND))
{
CompareValues($value, ++$i);
while ($row = $stmt->fetch(PDO::FETCH_BOUND)) {
compareValues($value, ++$i);
}
$result = $stmt->nextRowset();
if ($result != false)
{
if ($result != false) {
echo "Number of result sets exceeding expectation!\n";
}
}
function DeleteData($conn, $tableName, $exec)
function deleteData($conn, $tableName, $exec)
{
$query = "DELETE TOP(3) FROM $tableName";
$query = "DELETE TOP(3) FROM $tableName";
$rowCount = 0;
if ($exec)
{
if ($exec) {
$rowCount = $conn->exec($query);
}
else
{
} else {
$stmt = $conn->query($query);
$rowCount = $stmt->rowCount();
}
if ($rowCount <= 0)
if ($rowCount <= 0) {
echo "Number of rows affected should be > 0!\n";
$stmt = null;
}
unset($stmt);
}
function RunTest()
{
StartTest("pdo_statement_rowcount_query");
echo "\nStarting test...\n";
try
{
RowCount_Query(true);
RowCount_Query(false);
}
catch (Exception $e)
{
echo $e->getMessage();
}
echo "\nDone\n";
EndTest("pdo_statement_rowcount_query");
echo "Starting test...\n";
try {
rowCountQuery(true);
rowCountQuery(false);
} catch (Exception $e) {
echo $e->getMessage();
}
RunTest();
echo "Done\n";
?>
--EXPECT--
Starting test...
Done
Test "pdo_statement_rowcount_query" completed successfully.

367
test/functional/pdo_sqlsrv/pdo_stored_proc_fetch_datatypes.phpt
View file

@ -1,320 +1,303 @@
--TEST--
call stored procedures with inputs of ten different datatypes to get outputs of various types
call stored procedures with inputs of ten different datatypes to get outputs of various types
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
include 'MsCommon.inc';
include_once("MsCommon_mid-refactor.inc");
function ProcFetch_BigInt($conn)
function procFetchBigInt($conn)
{
$procName = GetTempProcName('bigint');
$procName = getProcName('bigint');
$stmt = $conn->exec("CREATE PROC $procName (@p1 BIGINT, @p2 BIGINT, @p3 NCHAR(128) OUTPUT)
AS BEGIN SELECT @p3 = CONVERT(NCHAR(128), @p1 + @p2) END");
$inValue1 = '12345678';
$inValue2 = '11111111';
$outValue = '0';
$stmt = $conn->prepare("{CALL $procName (?, ?, ?)}");
$stmt->bindValue(1, $inValue1);
$stmt->bindValue(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->execute();
$expected = "23456789";
$outValue = trim($outValue);
if (strncasecmp($outValue, $expected, strlen($expected)))
{
if (strncasecmp($outValue, $expected, strlen($expected))) {
echo "Output value $outValue is unexpected! Expected $expected\n";
}
$stmt = null;
}
dropProc($conn, $procName);
unset($stmt);
}
function ProcFetch_Decimal($conn)
function procFetchDecimal($conn)
{
$procName = GetTempProcName('decimal');
$procName = getProcName('decimal');
$stmt = $conn->exec("CREATE PROC $procName (@p1 DECIMAL, @p2 DECIMAL, @p3 CHAR(128) OUTPUT)
AS BEGIN SELECT @p3 = CONVERT(CHAR(128), @p1 + @p2) END");
$inValue1 = '2.1';
$inValue2 = '5.3';
$outValue = '0';
$inValue1 = '2.1';
$inValue2 = '5.3';
$outValue = '0';
$stmt = $conn->prepare("{CALL $procName (?, ?, ?)}");
$stmt->bindValue(1, $inValue1);
$stmt->bindValue(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->execute();
$expected = "7";
$outValue = trim($outValue);
if (strncasecmp($outValue, $expected, strlen($expected)))
{
if (strncasecmp($outValue, $expected, strlen($expected))) {
echo "Output value $outValue is unexpected! Expected $expected\n";
}
$stmt = null;
}
dropProc($conn, $procName);
unset($stmt);
}
function ProcFetch_Float($conn)
function procFetchFloat($conn)
{
$procName = GetTempProcName('float');
$procName = getProcName('float');
$stmt = $conn->exec("CREATE PROC $procName (@p1 FLOAT, @p2 FLOAT, @p3 FLOAT OUTPUT)
AS BEGIN SELECT @p3 = CONVERT(FLOAT, @p1 + @p2) END");
$inValue1 = '2.25';
$inValue2 = '5.5';
$outValue = '0';
$inValue1 = '2.25';
$inValue2 = '5.5';
$outValue = '0';
$stmt = $conn->prepare("{CALL $procName (?, ?, ?)}");
$stmt->bindValue(1, $inValue1);
$stmt->bindValue(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->execute();
$expected = "7.75";
$outValue = trim($outValue);
if (strncasecmp($outValue, $expected, strlen($expected)))
{
if (strncasecmp($outValue, $expected, strlen($expected))) {
echo "Output value $outValue is unexpected! Expected $expected\n";
}
$stmt = null;
}
dropProc($conn, $procName);
unset($stmt);
}
function ProcFetch_Int($conn)
function procFetchInt($conn)
{
$procName = GetTempProcName('int');
$procName = getProcName('int');
$stmt = $conn->exec("CREATE PROC $procName (@p1 INT, @p2 INT, @p3 INT OUTPUT)
AS BEGIN SELECT @p3 = CONVERT(INT, @p1 + @p2) END");
$inValue1 = '1234';
$inValue2 = '5678';
$outValue = '0';
$inValue1 = '1234';
$inValue2 = '5678';
$outValue = '0';
$stmt = $conn->prepare("{CALL $procName (?, ?, ?)}");
$stmt->bindValue(1, $inValue1);
$stmt->bindValue(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->execute();
$expected = "6912";
$outValue = trim($outValue);
if (strncasecmp($outValue, $expected, strlen($expected)))
{
if (strncasecmp($outValue, $expected, strlen($expected))) {
echo "Output value $outValue is unexpected! Expected $expected\n";
}
$stmt = null;
}
dropProc($conn, $procName);
unset($stmt);
}
function ProcFetch_Money($conn)
function procFetchMoney($conn)
{
$procName = GetTempProcName('money');
$procName = getProcName('money');
$stmt = $conn->exec("CREATE PROC $procName (@p1 MONEY, @p2 MONEY, @p3 MONEY OUTPUT)
AS BEGIN SELECT @p3 = CONVERT(MONEY, @p1 + @p2) END");
$inValue1 = '22.3';
$inValue2 = '16.1';
$outValue = '0';
$inValue1 = '22.3';
$inValue2 = '16.1';
$outValue = '0';
$stmt = $conn->prepare("{CALL $procName (?, ?, ?)}");
$stmt->bindValue(1, $inValue1, PDO::PARAM_STR);
$stmt->bindParam(2, $inValue2, PDO::PARAM_STR);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->bindValue(1, $inValue1, PDO::PARAM_STR);
$stmt->bindParam(2, $inValue2, PDO::PARAM_STR);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->execute();
$expected = "38.40";
$outValue = trim($outValue);
if (strncasecmp($outValue, $expected, strlen($expected)))
{
if (strncasecmp($outValue, $expected, strlen($expected))) {
echo "Output value $outValue is unexpected! Expected $expected\n";
}
$stmt = null;
}
dropProc($conn, $procName);
unset($stmt);
}
function ProcFetch_Numeric($conn)
function procFetchNumeric($conn)
{
$procName = GetTempProcName('numeric');
$procName = getProcName('numeric');
$stmt = $conn->exec("CREATE PROC $procName (@p1 NUMERIC, @p2 NUMERIC, @p3 NCHAR(128) OUTPUT)
AS BEGIN SELECT @p3 = CONVERT(NCHAR(128), @p1 + @p2) END");
$inValue1 = '2.8';
$inValue2 = '5.4';
$outValue = '0';
$inValue1 = '2.8';
$inValue2 = '5.4';
$outValue = '0';
$stmt = $conn->prepare("{CALL $procName (?, ?, ?)}");
$stmt->bindValue(1, $inValue1);
$stmt->bindParam(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->bindValue(1, $inValue1);
$stmt->bindParam(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->execute();
$expected = "8";
$outValue = trim($outValue);
if (strncasecmp($outValue, $expected, strlen($expected)))
{
if (strncasecmp($outValue, $expected, strlen($expected))) {
echo "Output value $outValue is unexpected! Expected $expected\n";
}
$stmt = null;
}
dropProc($conn, $procName);
unset($stmt);
}
function ProcFetch_Real($conn)
function procFetchReal($conn)
{
$procName = GetTempProcName('real');
$procName = getProcName('real');
$stmt = $conn->exec("CREATE PROC $procName (@p1 REAL, @p2 REAL, @p3 REAL OUTPUT)
AS BEGIN SELECT @p3 = CONVERT(REAL, @p1 + @p2) END");
$inValue1 = '3.4';
$inValue2 = '6.6';
$outValue = '0';
$inValue1 = '3.4';
$inValue2 = '6.6';
$outValue = '0';
$stmt = $conn->prepare("{CALL $procName (?, ?, ?)}");
$stmt->bindValue(1, $inValue1);
$stmt->bindParam(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->bindValue(1, $inValue1);
$stmt->bindParam(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->execute();
$expected = "10";
$outValue = trim($outValue);
if (strncasecmp($outValue, $expected, strlen($expected)))
{
if (strncasecmp($outValue, $expected, strlen($expected))) {
echo "Output value $outValue is unexpected! Expected $expected\n";
}
$stmt = null;
}
dropProc($conn, $procName);
unset($stmt);
}
function ProcFetch_SmallInt($conn)
function procFetchSmallInt($conn)
{
$procName = GetTempProcName('smallint');
$procName = getProcName('smallint');
$stmt = $conn->exec("CREATE PROC $procName (@p1 SMALLINT, @p2 SMALLINT, @p3 NCHAR(32) OUTPUT)
AS BEGIN SELECT @p3 = CONVERT(NCHAR(32), @p1 + @p2) END");
$inValue1 = '34';
$inValue2 = '56';
$outValue = '0';
$inValue1 = '34';
$inValue2 = '56';
$outValue = '0';
$stmt = $conn->prepare("{CALL $procName (?, ?, ?)}");
$stmt->bindValue(1, $inValue1);
$stmt->bindParam(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->bindValue(1, $inValue1);
$stmt->bindParam(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->execute();
$expected = "90";
$outValue = trim($outValue);
if (strncasecmp($outValue, $expected, strlen($expected)))
{
if (strncasecmp($outValue, $expected, strlen($expected))) {
echo "Output value $outValue is unexpected! Expected $expected\n";
}
$stmt = null;
}
dropProc($conn, $procName);
unset($conn);
}
function ProcFetch_SmallMoney($conn)
function procFetchSmallMoney($conn)
{
$procName = GetTempProcName('smallmoney');
$procName = getProcName('smallmoney');
$stmt = $conn->exec("CREATE PROC $procName (@p1 SMALLMONEY, @p2 SMALLMONEY, @p3 SMALLMONEY OUTPUT)
AS BEGIN SELECT @p3 = CONVERT(SMALLMONEY, @p1 + @p2) END");
$inValue1 = '10';
$inValue2 = '11.7';
$outValue = '0';
$inValue1 = '10';
$inValue2 = '11.7';
$outValue = '0';
$stmt = $conn->prepare("{CALL $procName (?, ?, ?)}");
$stmt->bindValue(1, $inValue1, PDO::PARAM_STR);
$stmt->bindParam(2, $inValue2, PDO::PARAM_STR);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->bindValue(1, $inValue1, PDO::PARAM_STR);
$stmt->bindParam(2, $inValue2, PDO::PARAM_STR);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->execute();
$expected = "21.70";
$outValue = trim($outValue);
if (strncasecmp($outValue, $expected, strlen($expected)))
{
if (strncasecmp($outValue, $expected, strlen($expected))) {
echo "Output value $outValue is unexpected! Expected $expected\n";
}
$stmt = null;
}
dropProc($conn, $procName);
unset($stmt);
}
function ProcFetch_TinyInt($conn)
{
$procName = GetTempProcName('tinyint');
$procName = getProcName('tinyint');
$stmt = $conn->exec("CREATE PROC $procName (@p1 TINYINT, @p2 TINYINT, @p3 CHAR(32) OUTPUT)
AS BEGIN SELECT @p3 = CONVERT(CHAR(32), @p1 + @p2) END");
$inValue1 = '11';
$inValue2 = '12';
$outValue = '0';
$inValue1 = '11';
$inValue2 = '12';
$outValue = '0';
$stmt = $conn->prepare("{CALL $procName (?, ?, ?)}");
$stmt->bindValue(1, $inValue1);
$stmt->bindParam(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->bindValue(1, $inValue1);
$stmt->bindParam(2, $inValue2);
$stmt->bindParam(3, $outValue, PDO::PARAM_STR, 300);
$stmt->execute();
$expected = "23";
$outValue = trim($outValue);
if (strncasecmp($outValue, $expected, strlen($expected)))
{
if (strncasecmp($outValue, $expected, strlen($expected))) {
echo "Output value $outValue is unexpected! Expected $expected\n";
}
$stmt = null;
}
dropProc($conn, $procName);
unset($stmt);
}
function RunTest()
{
set_time_limit(0);
StartTest("pdo_stored_proc_fetch_datatypes");
echo "\nStarting test...\n";
try
{
include("MsSetup.inc");
$conn = new PDO( "sqlsrv:server=$server;database=$databaseName", $uid, $pwd);
set_time_limit(0);
echo "Starting test...\n";
try {
$conn = connect();
ProcFetch_BigInt($conn);
ProcFetch_Decimal($conn);
ProcFetch_Float($conn);
ProcFetch_Int($conn);
ProcFetch_Money($conn);
ProcFetch_Numeric($conn);
ProcFetch_Real($conn);
ProcFetch_SmallInt($conn);
ProcFetch_SmallMoney($conn);
ProcFetch_TinyInt($conn);
$conn = null;
}
catch (Exception $e)
{
echo $e->getMessage();
}
echo "\nDone\n";
EndTest("pdo_stored_proc_fetch_datatypes");
procFetchBigInt($conn);
procFetchDecimal($conn);
procFetchFloat($conn);
procFetchInt($conn);
procFetchMoney($conn);
procFetchNumeric($conn);
procFetchReal($conn);
procFetchSmallInt($conn);
procFetchSmallMoney($conn);
ProcFetch_TinyInt($conn);
unset($conn);
} catch (Exception $e) {
echo $e->getMessage();
}
RunTest();
echo "Done\n";
?>
--EXPECT--
Starting test...
Done
Test "pdo_stored_proc_fetch_datatypes" completed successfully.

494
test/functional/pdo_sqlsrv/pdo_testDataType.phpt
View file

@ -1,494 +0,0 @@
--TEST--
Test the different type of data for retrieving
--SKIPIF--
<?php require('skipif.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
function testBigInt()
{
$db = connect();
// Retrieve data type
$stmt = $db->query("SELECT BigIntCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testBit()
{
$db = connect();
// Retrieve data type
$stmt = $db->query("SELECT BitCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testInt()
{
$db = connect();
// Retrieve data type
$stmt = $db->query("SELECT IntCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testSmallInt()
{
$db = connect();
// Retrieve data type
$stmt = $db->query("SELECT SmallIntCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testTinyInt()
{
$db = connect();
// Retrieve data type
$stmt = $db->query("SELECT TinyIntCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testDecimal()
{
$db = connect();
// Retrieve data type
$stmt = $db->query("SELECT DecimalCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testNumeric()
{
$db = connect();
// Retrieve data type
$stmt = $db->query("SELECT NumCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testMoney()
{
$db = connect();
// Retrieve data type
$stmt = $db->query("SELECT MoneyCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testSmallMoney()
{
$db = connect();
// Retrieve data type
$stmt = $db->query("SELECT SmallMoneyCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testFloat()
{
$db = connect();
$stmt = $db->query("SELECT FloatCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testReal()
{
$db = connect();
$stmt = $db->query("SELECT RealCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testChar()
{
$db = connect();
$stmt = $db->query("SELECT CharCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testVarchar()
{
$db = connect();
$stmt = $db->query("SELECT VarcharCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testText()
{
$db = connect();
$stmt = $db->query("SELECT TextCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testNText()
{
$db = connect();
$stmt = $db->query("SELECT NTextCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testNChar()
{
$db = connect();
$stmt = $db->query("SELECT NCharCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testNVarchar()
{
$db = connect();
$stmt = $db->query("SELECT NVarcharCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testImage()
{
$db = connect();
$stmt = $db->query("SELECT ImageCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testBinary()
{
$db = connect();
$stmt = $db->query("SELECT BinaryCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testVarbinary()
{
$db = connect();
$stmt = $db->query("SELECT VarbinaryCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testDateTime2()
{
$db = connect();
$stmt = $db->query("SELECT DateTime2Col FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testDatetimeoffset()
{
$db = connect();
$stmt = $db->query("SELECT DTOffsetCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testsmalldatetime()
{
$db = connect();
$stmt = $db->query("SELECT SmallDTCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testDateTime()
{
$db = connect();
$stmt = $db->query("SELECT DateTimeCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testDate()
{
$db = connect();
$stmt = $db->query("SELECT DateCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testNVarcharMax()
{
$db = connect();
$stmt = $db->query("SELECT NVarCharMaxCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testTime()
{
$db = connect();
$stmt = $db->query("SELECT TimeCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testUniqueidentifier()
{
$db = connect();
$stmt = $db->query("SELECT Guidcol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testVarbinaryMax()
{
$db = connect();
$stmt = $db->query("SELECT VarbinaryMaxCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testVarcharMax()
{
$db = connect();
$stmt = $db->query("SELECT VarcharMaxCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
function testXml()
{
$db = connect();
$stmt = $db->query("SELECT XmlCol FROM PDO_AllTypes");
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
}
try
{
//$db = connect();
//$sql = "INSERT INTO PDO_AllTypes(BigIntCol,BitCol,IntCol,) VALUES(" . GetSampleData(4) . ",1,)";
//$numRows = $db->exec($sql);
echo "Test_1 : bigint data type :\n";
testBigInt();
echo "Test_2 : bit data type :\n";
testBit();
echo "Test_3 : int data type :\n";
testInt();
echo "Test_4 : smallint data type:\n";
testSmallInt();
echo "Test_5 : tinyint data type:\n";
testTinyInt();
echo "Test_6 : decimal data type:\n";
testDecimal();
echo "Test_7 : numeric data type:\n";
testNumeric();
echo "Test_8 : money data type:\n";
testMoney();
echo "Test_9 : smallmoney data type:\n";
testSmallMoney();
echo "Test_10 : float data type:\n";
testFloat();
echo "Test_11 : real data type:\n";
testReal();
echo "Test_12 : char data type:\n";
testChar();
echo "Test_13 : varchar data type:\n";
testVarchar();
echo "Test_14 : text data type:\n";
testText();
echo "Test_15 : nchar data type:\n";
testNChar();
echo "Test_16 : nvarchar data type:\n";
testNVarchar();
echo "Test_17 : image data type:\n";
testImage();
echo "Test_18 : binary data type:\n";
testBinary();
echo "Test_19 : varbinary data type:\n";
testVarbinary();
echo "Test_20 : smalldatetime data type:\n";
testsmalldatetime();
echo "Test_21 : datetime data type:\n";
testDateTime();
echo "Test_22 : datetime2 data type:\n";
testsmalldatetime();
echo "Test_23 : datetimeoffset data type:\n";
testDatetimeoffset();
echo "Test_24 : time data type:\n";
testTime();
echo "Test_25 : Uniqueidentifier data type:\n";
testUniqueidentifier();
echo "Test_26 : VarbinaryMax data type:\n";
testVarbinaryMax();
echo "Test_27 : VarcharMax data type:\n";
testVarcharMax();
echo "Test_28 : xml data type:\n";
testXml();
echo "Test_29 : ntext data type:\n";
testNText();
echo "Test_30 : nvarcharmax data type:\n";
testNVarcharMax();
}
catch (PDOException $e)
{
var_dump($e);
}
?>
--EXPECT--
Test_1 : bigint data type :
array(1) {
["BigIntCol"]=>
string(1) "1"
}
Test_2 : bit data type :
array(1) {
["BitCol"]=>
string(1) "0"
}
Test_3 : int data type :
array(1) {
["IntCol"]=>
string(1) "1"
}
Test_4 : smallint data type:
array(1) {
["SmallIntCol"]=>
string(1) "1"
}
Test_5 : tinyint data type:
array(1) {
["TinyIntCol"]=>
string(1) "1"
}
Test_6 : decimal data type:
array(1) {
["DecimalCol"]=>
string(3) "111"
}
Test_7 : numeric data type:
array(1) {
["NumCol"]=>
string(1) "1"
}
Test_8 : money data type:
array(1) {
["MoneyCol"]=>
string(8) "111.1110"
}
Test_9 : smallmoney data type:
array(1) {
["SmallMoneyCol"]=>
string(8) "111.1110"
}
Test_10 : float data type:
array(1) {
["FloatCol"]=>
string(7) "111.111"
}
Test_11 : real data type:
array(1) {
["RealCol"]=>
string(7) "111.111"
}
Test_12 : char data type:
array(1) {
["CharCol"]=>
string(10) "STRINGCOL1"
}
Test_13 : varchar data type:
array(1) {
["VarcharCol"]=>
string(10) "STRINGCOL1"
}
Test_14 : text data type:
array(1) {
["TextCol"]=>
string(420) " 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417."
}
Test_15 : nchar data type:
array(1) {
["NCharCol"]=>
string(10) "STRINGCOL1"
}
Test_16 : nvarchar data type:
array(1) {
["NVarcharCol"]=>
string(10) "STRINGCOL1"
}
Test_17 : image data type:
array(1) {
["ImageCol"]=>
string(1) ""
}
Test_18 : binary data type:
array(1) {
["BinaryCol"]=>
string(5) ""
}
Test_19 : varbinary data type:
array(1) {
["VarbinaryCol"]=>
string(1) ""
}
Test_20 : smalldatetime data type:
array(1) {
["SmallDTCol"]=>
string(19) "2000-11-11 11:11:00"
}
Test_21 : datetime data type:
array(1) {
["DateTimeCol"]=>
string(23) "2000-11-11 11:11:11.110"
}
Test_22 : datetime2 data type:
array(1) {
["SmallDTCol"]=>
string(19) "2000-11-11 11:11:00"
}
Test_23 : datetimeoffset data type:
array(1) {
["DTOffsetCol"]=>
string(34) "2000-11-11 11:11:11.1110000 +00:00"
}
Test_24 : time data type:
array(1) {
["TimeCol"]=>
string(16) "11:11:11.1110000"
}
Test_25 : Uniqueidentifier data type:
array(1) {
["Guidcol"]=>
string(36) "AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA"
}
Test_26 : VarbinaryMax data type:
array(1) {
["VarbinaryMaxCol"]=>
string(1) ""
}
Test_27 : VarcharMax data type:
array(1) {
["VarcharMaxCol"]=>
string(420) " 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417."
}
Test_28 : xml data type:
array(1) {
["XmlCol"]=>
string(431) "<xml> 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>"
}
Test_29 : ntext data type:
array(1) {
["NTextCol"]=>
string(420) " 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417."
}
Test_30 : nvarcharmax data type:
array(1) {
["NVarCharMaxCol"]=>
string(420) " 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417."
}

80
test/functional/pdo_sqlsrv/pdo_transaction.phpt
View file

@ -3,51 +3,73 @@ test transaction rollback and commit
--DESCRIPTION--
starts a transaction, delete rows and rollback the transaction; starts a transaction, delete rows and commit
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsSetup.inc");
require_once("MsCommon_mid-refactor.inc");
function deleteRows($conn, $tbname)
{
try {
if (!isColEncrypted()) {
$rows = $conn->exec("DELETE FROM $tbname WHERE col1 = 'a'");
} else {
// needs to find parameter for encrypted columns
$sql = "DELETE FROM $tbname WHERE col1 = ?";
$stmt = $conn->prepare($sql);
$col1 = "a";
$stmt->execute(array($col1));
$rows = $stmt->rowCount();
}
return $rows;
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
}
try {
$conn = connect();
$tbname = "Table1";
createTable($conn, $tbname, array("col1" => "char(1)", "col2" => "char(1)"));
insertRow($conn, $tbname, array("col1" => "a", "col2" => "b"));
insertRow($conn, $tbname, array("col1" => "a", "col2" => "c"));
$conn = new PDO( "sqlsrv:Server=$server; database = $databaseName", $uid, $pwd);
$conn->exec("IF OBJECT_ID('Table1', 'U') IS NOT NULL DROP TABLE Table1");
$conn->exec("CREATE TABLE Table1(col1 CHARACTER(1), col2 CHARACTER(1))");
$ret = $conn->exec("INSERT INTO Table1(col1, col2) VALUES('a', 'b')");
$ret = $conn->exec("INSERT INTO Table1(col1, col2) VALUES('a', 'c')");
//revert the inserts but roll back
$conn->beginTransaction();
$rows = $conn->exec("DELETE FROM Table1 WHERE col1 = 'a'");
$rows = deleteRows($conn, $tbname);
$conn->rollback();
$stmt = $conn->query("SELECT * FROM Table1");
$stmt = $conn->query("SELECT * FROM $tbname");
// Table1 should still have 2 rows since delete was rolled back
if ( count( $stmt->fetchAll() ) == 2 )
if (count($stmt->fetchAll()) == 2) {
echo "Transaction rolled back successfully\n";
else
} else {
echo "Transaction failed to roll back\n";
}
//revert the inserts then commit
$conn->beginTransaction();
$rows = $conn->exec("DELETE FROM Table1 WHERE col1 = 'a'");
$rows = deleteRows($conn, $tbname);
$conn->commit();
echo $rows." rows affected\n";
$stmt = $conn->query("SELECT * FROM Table1");
if ( count( $stmt->fetchAll() ) == 0 )
$stmt = $conn->query("SELECT * FROM $tbname");
if (count($stmt->fetchAll()) == 0) {
echo "Transaction committed successfully\n";
else
} else {
echo "Transaction failed to commit\n";
//drop the created temp table
$conn->exec("DROP TABLE Table1");
//free statement and connection
$stmt = NULL;
$conn = NULL;
}
dropTable($conn, $tbname);
unset($stmt);
unset($conn);
} catch (PDOException $e) {
var_dump($e->errorInfo);
}
?>
--EXPECT--
Transaction rolled back successfully
2 rows affected
Transaction committed successfully
Transaction committed successfully

94
test/functional/pdo_sqlsrv/pdo_transactions.phpt
View file

@ -1,112 +1,98 @@
--TEST--
Test Transactions.
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
// commit
function test1($conn)
function test1($conn, $tbname)
{
global $table1;
$conn->beginTransaction();
$stmt = $conn->query( "Insert into " .$table1 . " (NCharCol, IntCol) values ('NCharCol3', 3)" );
insertRow($conn, $tbname, array("NCharCol" => "NCharCol3", "IntCol" => 3));
$conn->commit();
echo "\nTest 1 Passed]\n";
echo "Test 1 Passed\n";
}
// rollback
function test2($conn)
function test2($conn, $tbname)
{
global $table1;
$conn->beginTransaction();
$stmt = $conn->query( "Insert into " .$table1 . " (NCharCol, IntCol) values ('NCharCol3', 3)" );
insertRow($conn, $tbname, array("NCharCol" => "NCharCol3", "IntCol" => 3));
$conn->rollBack();
echo "Test 2 Passed\n";
}
// commit
function test3($conn)
function test3($conn, $tbname)
{
global $table1;
$conn->beginTransaction();
$stmt = $conn->query( "Insert into " .$table1 . " (NCharCol, IntCol) values ('NCharCol3', 3)" );
insertRow($conn, $tbname, array("NCharCol" => "NCharCol3", "IntCol" => 3));
$conn->commit();
echo "Test 3 Passed\n";
}
// Rollback twice. Verify that error is thrown
function test4($conn)
function test4($conn, $tbname)
{
try {
global $table1;
$conn->beginTransaction();
$stmt = $conn->query( "Insert into " .$table1 . " (NCharCol, IntCol) values ('NCharCol3', 3)" );
insertRow($conn, $tbname, array("NCharCol" => "NCharCol3", "IntCol" => 3));
$conn->rollBack();
$conn->rollBack();
}
catch( PDOException $e )
{
} catch (PDOException $e) {
echo "Test4: ". $e->getMessage() . "\n";
}
}
// Commit twice Verify that error is thrown
function test5($conn)
function test5($conn, $tbname)
{
try {
global $table1;
$conn->beginTransaction();
$stmt = $conn->query( "Insert into " .$table1 . " (NCharCol, IntCol) values ('NCharCol3', 3)" );
insertRow($conn, $tbname, array("NCharCol" => "NCharCol3", "IntCol" => 3));
$conn->commit();
$conn->commit();
}
catch( PDOException $e )
{
} catch (PDOException $e) {
echo "Test5: ". $e->getMessage() . "\n";
}
}
// begin transaction twice. Verify that error is thrown
function test6($conn)
{
try {
$conn->beginTransaction();
$conn->beginTransaction();
}
catch( PDOException $e )
{
} catch (PDOException $e) {
echo "Test6: ". $e->getMessage() . "\n";
}
}
try
{
$db = connect();
create_and_insert_table1( $db );
test1($db);
test2($db);
test3($db);
test4($db);
test5($db);
test6($db);
}
try {
$db = connect();
$tbname = "PDO_MainTypes";
createTableMainTypes($db, $tbname);
test1($db, $tbname);
test2($db, $tbname);
test3($db, $tbname);
test4($db, $tbname);
test5($db, $tbname);
test6($db);
catch( PDOException $e ) {
var_dump( $e );
dropTable($db, $tbname);
unset($conn);
} catch (PDOException $e) {
var_dump($e);
exit;
}
?>
?>
--EXPECT--
Test 1 Passed]
Test 1 Passed
Test 2 Passed
Test 3 Passed
Test4: There is no active transaction
Test5: There is no active transaction
Test6: There is already an active transaction
Test6: There is already an active transaction

82
test/functional/pdo_sqlsrv/pdo_txn_rollback_crash.phpt Normal file
View file

@ -0,0 +1,82 @@
--TEST--
Checks that calling query() after beginTransaction() with an invalid query does not cause a crash. Fix for Github 434.
--DESCRIPTION--
Calling beginTransaction() and then query() with an invalid query can cause a crash in php.exe or php-cgi.exe,
which may manifest as a CLI crash or produce an error message saying "Faulting Module[...]odbc32.dll". The
cause is an attempt to double free a statement handle after script execution which had not been properly freed
during rollback. This test tells us nothing under run-tests.php because the crash only occurs at the end of
script execution, so any expected output already exists and the test would pass. Therefore manual verification
is necessary - this test should be run separately to verify no crash occurs.
--SKIPIF--
<?php require('skipif.inc'); ?>
--FILE--
<?php
require_once("MsSetup.inc");
$conn = new PDO("sqlsrv:Server=$server; database = $databaseName", $uid, $pwd);
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
for ($i = 0; $i < 50; $i++) {
echo "Iteration $i\n";
if ($conn->beginTransaction()) {
$stmt = $conn->query('SELECT fakecolumn FROM faketable');
}
$conn->commit();
}
$conn = null;
echo "Done.\n";
?>
--EXPECT--
Iteration 0
Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5
Iteration 6
Iteration 7
Iteration 8
Iteration 9
Iteration 10
Iteration 11
Iteration 12
Iteration 13
Iteration 14
Iteration 15
Iteration 16
Iteration 17
Iteration 18
Iteration 19
Iteration 20
Iteration 21
Iteration 22
Iteration 23
Iteration 24
Iteration 25
Iteration 26
Iteration 27
Iteration 28
Iteration 29
Iteration 30
Iteration 31
Iteration 32
Iteration 33
Iteration 34
Iteration 35
Iteration 36
Iteration 37
Iteration 38
Iteration 39
Iteration 40
Iteration 41
Iteration 42
Iteration 43
Iteration 44
Iteration 45
Iteration 46
Iteration 47
Iteration 48
Iteration 49
Done.

27
test/functional/pdo_sqlsrv/pdo_utf8_conn.phpt
View file

@ -1,26 +1,27 @@
--TEST--
UTF-8 connection strings
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsCommon_mid-refactor.inc");
$server = 'localhost';
$databaseName = 'test';
$uid = 'sa';
$pwd = 'Sunshine4u';
$server = 'localhost';
$databaseName = 'test';
$uid = 'sa';
$pwd = 'Sunshine4u';
// test an invalid connection credentials
$c = new PDO('sqlsrv:Server=' . $server . ';Database=' . $databaseName, $uid, $pwd);
if( $c !== false )
{
die( "Should have failed to connect." );
}
$dsn = getDSN($server, $databaseName);
// test an invalid connection credentials
$c = new PDO($dsn, $uid, $pwd);
if ($c !== false) {
die("Should have failed to connect.");
}
?>
--EXPECTREGEX--
Fatal error: Uncaught PDOException: SQLSTATE\[(28000|08001|HYT00)\]: .*\[Microsoft\]\[ODBC Driver 1[1-9] for SQL Server\](\[SQL Server\])?(Named Pipes Provider: Could not open a connection to SQL Server \[2\]\. |Login timeout expired|Login failed for user 'sa'\.) in .+(\/|\\)pdo_utf8_conn\.php:[0-9]+
Fatal error: Uncaught PDOException: SQLSTATE\[(28000|08001|HYT00)\]: .*\[Microsoft\]\[ODBC Driver 1[0-9] for SQL Server\](\[SQL Server\])?(Named Pipes Provider: Could not open a connection to SQL Server \[2\]\. |Login timeout expired|Login failed for user 'sa'\.) in .+(\/|\\)pdo_utf8_conn\.php:[0-9]+
Stack trace:
#0 .+(\/|\\)pdo_utf8_conn\.php\([0-9]+\): PDO->__construct\('sqlsrv:Server=l\.\.\.', 'sa', 'Sunshine4u'\)
#1 {main}

322
test/functional/pdo_sqlsrv/pdostatement_Buffqry.phpt
View file

@ -1,200 +1,206 @@
--TEST--
PDOStatement::BindParam for predefined constants and buffered query.
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
//*************************************************************************************
// Test binding with different predefined constants and using buffered query to update and
// Test binding with different predefined constants and using buffered query to update and
// select data.
//*************************************************************************************
require_once 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
function insert($db)
function insert($db, $tbname)
{
$query = "DECLARE @string VARCHAR(MAX) = '0000000000'";
$query .= "DECLARE @string1 VARCHAR(MAX) = '00'";
$query .= "DECLARE @bin VARBINARY(MAX)";
$query .= "DECLARE @bin1 VARBINARY(2)";
$query .= "SET @bin = CAST(@string AS VARBINARY(MAX))";
$query .= "SET @bin1 = CAST(@string1 AS VARBINARY(2))";
$query .= "INSERT INTO PDO_AllTypes (";
$query .= "BigIntCol,BitCol,IntCol,";
$query .= "SmallIntCol,TinyIntCol,";
$query .= "DecimalCol,NumCol,MoneyCol,";
$query .= "SmallMoneyCol,FloatCol,RealCol,";
$query .= "CharCol,VarcharCol,TextCol,";
$query .= "NCharCol,NVarcharCol,ImageCol,";
$query .= "BinaryCol,VarbinaryCol,SmallDTCol,";
$query .= "DateTimeCol,DTOffsetCol,";
$query .= "TimeCol,Guidcol,VarbinaryMaxCol,";
$query .= "VarcharMaxCol,XmlCol,NTextCol,";
$query .= "NVarCharMaxCol) VALUES (0,'0',0,1,1,111,1,";
$query .= "111.1110,111.1110,111.111,111.111,";
$query .= "'STRINGCOL2','STRINGCOL2',";
$query .= "'1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',";
$query .= "'STRINGCOL2','STRINGCOL2','00',";
$query .= "CONVERT(BINARY(2),@bin),CONVERT(VARBINARY(2),@bin1),'2000-11-11 11:11:00',";
$query .= "'2000-11-11 11:11:11.110',";
$query .= "'2000-11-11 11:11:11.1110000 +00:00','11:11:11.1110000',";
$query .= "'AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA',CONVERT(VARBINARY(MAX),@bin1) ,";
$query .= "'1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',";
$query .= "'<xml> 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>',";
$query .= "'1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',";
$query .= "'1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.')";
$bin = fopen('php://memory', 'a');
fwrite($bin, '00');
rewind($bin);
$numRows = $db->exec($query);
echo "Insert complete!\n";
$inputs = array("BigIntCol" => 0,
"BitCol" => '0',
"IntCol" => 0,
"SmallIntCol" => 1,
"TinyIntCol" => 1,
"DecimalCol" => 111,
"NumCol" => 1,
"MoneyCol" => 111.1110,
"SmallMoneyCol" => 111.1110,
"FloatCol" => 111.111,
"RealCol" => 111.111,
"CharCol" => 'STRINGCOL2',
"VarcharCol" => 'STRINGCOL2',
"TextCol" => '1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',
"NCharCol" => 'STRINGCOL2',
"NVarcharCol" => 'STRINGCOL2',
"ImageCol" => new BindParamOp(17, $bin, "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"BinaryCol" => new BindParamOp(18, $bin, "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"VarbinaryCol" => new BindParamOp(19, $bin, "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"SmallDTCol" => '2000-11-11 11:11:00',
"DateTimeCol" => '2000-11-11 11:11:11.110',
"DTOffsetCol" => '2000-11-11 11:11:11.1110000 +00:00',
"TimeCol" => '11:11:11.1110000',
"Guidcol" => 'AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA',
"VarbinaryMaxCol" => new BindParamOp(25, $bin, "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY"),
"VarcharMaxCol" => '1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',
"XmlCol" => '<xml> 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>',
"NTextCol" => '1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.',
"NVarCharMaxCol" => '1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.');
$stmt = insertRow($db, $tbname, $inputs, "prepareBindParam");
unset($stmt);
echo "Insert complete!\n";
}
function bindParam_LOB($db)
function bindPARAM_LOB($db, $tbname)
{
// Binding LOB with buffered queries activated.
$noteID = fopen('php://memory', 'a');
$data = '0';
$query = "UPDATE PDO_AllTypes SET [VarbinaryCol]=:Name WHERE [BitCol]=:value";
$stmt = $db->prepare($query,array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
fwrite($noteID, '00');
rewind($noteID);
$stmt->bindParam(':Name',$noteID,PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->bindParam(':value',$data);
$result = $stmt->execute();
$select = "SELECT * FROM PDO_AllTypes WHERE [BitCol]=:value";
$stmt = $db->prepare($select,array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value',$data);
$stmt->execute();
$result = $stmt->fetchColumn(26); // Retrieve VarbinaryCol
print("$result\n");
// Binding LOB with buffered queries activated.
$noteID = fopen('php://memory', 'a');
$data = '0';
$query = "UPDATE $tbname SET [VarbinaryCol]=:Name WHERE [BitCol]=:value";
$stmt = $db->prepare($query, array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
fwrite($noteID, '00');
rewind($noteID);
$stmt->bindParam(':Name', $noteID, PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->bindParam(':value', $data);
$result = $stmt->execute();
$select = "SELECT * FROM $tbname WHERE [BitCol]=:value";
$stmt = $db->prepare($select, array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value', $data);
$stmt->execute();
$result = $stmt->fetchColumn(26); // Retrieve VarbinaryCol
unset($stmt);
print("$result\n");
}
function bindParam_STR($db)
function bindPARAM_STR($db, $tbname)
{
// Binding STR with buffered queries activated.
$noteID = fopen('php://memory', 'a');
$data = 'STRINGCOL2';
$query = "UPDATE PDO_AllTypes SET [BitCol]=:Name WHERE [CharCol]=:value";
$stmt = $db->prepare($query,array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
fwrite($noteID, '1');
rewind($noteID);
$stmt->bindParam(':Name',$noteID,PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->bindParam(':value',$data);
$stmt->execute();
$select = "SELECT * FROM PDO_AllTypes WHERE [CharCol]=:value";
$stmt = $db->prepare($select,array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value',$data);
$stmt->execute();
$result = $stmt->fetchColumn(2); // Retrieve BitCol
$result = str_replace("\0","",$result);
print("$result\n");
// Binding STR with buffered queries activated.
// fopen returns a resource, if using PDO::PARAM_STR, the PDO side converts it to a zend_string "Resource id #*"
// thus a resource is not meant to bind parameter using PDO::PARAM_STR
$noteID = '1';
$data = 'STRINGCOL2';
$query = "UPDATE $tbname SET [BitCol]=:Name WHERE [CharCol]=:value";
$stmt = $db->prepare($query, array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':Name', $noteID, PDO::PARAM_STR);
$stmt->bindParam(':value', $data);
$stmt->execute();
$select = "SELECT * FROM $tbname WHERE [CharCol]=:value";
$stmt = $db->prepare($select, array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value', $data);
$stmt->execute();
$result = $stmt->fetchColumn(2); // Retrieve BitCol
unset($stmt);
$result = str_replace("\0", "", $result);
print("$result\n");
}
function bindParam_NULL($db)
function bindPARAM_NULL($db, $tbname)
{
// Binding NULL with buffered queries activated.
$noteID = fopen('php://memory', 'a');
$data = 'STRINGCOL2';
$query = "UPDATE PDO_AllTypes SET [BitCol]=:Name WHERE [VarcharCol]=:value";
$stmt = $db->prepare($query,array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
fwrite($noteID, null);
rewind($noteID);
$stmt->bindParam(':Name',$noteID,PDO::PARAM_NULL);
$stmt->bindParam(':value',$data);
$stmt->execute();
// Binding NULL with buffered queries activated.
$noteID = fopen('php://memory', 'a');
$data = 'STRINGCOL2';
$query = "UPDATE PDO_AllTypes SET [BitCol]=:Name WHERE [VarcharCol]=:value";
$data = '0';
$select = "SELECT * FROM PDO_AllTypes WHERE [BitCol]=:value";
$stmt = $db->prepare($select,array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value',$data);
$stmt->execute();
$result = $stmt->fetchColumn(2); // Retrieve BitCol
$result = str_replace("\0","",$result);
print("$result\n");
$stmt = $db->prepare($query, array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
fwrite($noteID, null);
rewind($noteID);
$stmt->bindParam(':Name', $noteID, PDO::PARAM_NULL);
$stmt->bindParam(':value', $data);
$stmt->execute();
$data = '0';
$select = "SELECT * FROM PDO_AllTypes WHERE [BitCol]=:value";
$stmt = $db->prepare($select, array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value', $data);
$stmt->execute();
$result = $stmt->fetchColumn(2); // Retrieve BitCol
unset($stmt);
$result = str_replace("\0", "", $result);
print("$result\n");
}
function bindParam_INT($db)
function bindPARAM_INT($db, $tbname)
{
// Binding INT with buffered queries activated.
$noteID = fopen('php://memory', 'a');
$data = 0;
$query = "UPDATE PDO_ALLTypes SET [IntCol]=:Name WHERE [IntCol]=:value";
$stmt = $db->prepare($query,array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
fwrite($noteID, '1');
rewind($noteID);
$stmt->bindParam(':Name',$noteID,PDO::PARAM_INT);
$stmt->bindParam(':value',$data);
$stmt->execute();
$select = "SELECT * FROM PDO_AllTypes WHERE [BigIntCol]=:value";
$stmt = $db->prepare($select,array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value',$data,PDO::PARAM_INT);
$stmt->execute();
$result = $stmt->fetchColumn(11); // Retrieve IntCol
$result = str_replace("\0","",$result);
print("$result\n");
// Binding INT with buffered queries activated.
$noteID = fopen('php://memory', 'a');
$data = 0;
$query = "UPDATE $tbname SET [IntCol]=:Name WHERE [IntCol]=:value";
$stmt = $db->prepare($query, array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
fwrite($noteID, '1');
rewind($noteID);
$stmt->bindParam(':Name', $noteID, PDO::PARAM_INT);
$stmt->bindParam(':value', $data);
$stmt->execute();
$select = "SELECT * FROM $tbname WHERE [BigIntCol]=:value";
$stmt = $db->prepare($select, array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value', $data, PDO::PARAM_INT);
$stmt->execute();
$result = $stmt->fetchColumn(11); // Retrieve IntCol
unset($stmt);
$result = str_replace("\0", "", $result);
print("$result\n");
}
function bindParam_BOOL($db)
function bindPARAM_BOOL($db, $tbname)
{
// Binding BOOL with buffered queries activated.
$noteID = fopen('php://memory', 'a');
$data = '0';
$query = "UPDATE PDO_AllTypes SET [BitCol]=:Name WHERE [BigIntCol]=:value";
$stmt = $db->prepare($query,array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
fwrite($noteID, '1');
rewind($noteID);
$stmt->bindParam(':Name',$noteID,PDO::PARAM_BOOL);
$stmt->bindParam(':value',$data);
$stmt->execute();
$query = "SELECT * FROM PDO_AllTypes WHERE [BigIntCol]=:value";
$stmt = $db->prepare($query,array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value',$data,PDO::PARAM_BOOL);
$stmt->execute();
$result = $stmt->fetchColumn(2); // Retrieve BitCol
$result = str_replace("\0","",$result);
print("$result\n");
// Binding BOOL with buffered queries activated.
$noteID = fopen('php://memory', 'a');
$data = '0';
$query = "UPDATE $tbname SET [BitCol]=:Name WHERE [BigIntCol]=:value";
$stmt = $db->prepare($query, array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
fwrite($noteID, '1');
rewind($noteID);
$stmt->bindParam(':Name', $noteID, PDO::PARAM_BOOL);
$stmt->bindParam(':value', $data);
$stmt->execute();
$query = "SELECT * FROM $tbname WHERE [BigIntCol]=:value";
$stmt = $db->prepare($query, array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value', $data, PDO::PARAM_BOOL);
$stmt->execute();
$result = $stmt->fetchColumn(2); // Retrieve BitCol
unset($stmt);
$result = str_replace("\0", "", $result);
print("$result\n");
}
function delete($db)
function delete($db, $tbname)
{
$data = "STRINGCOL2";
$query = "DELETE FROM PDO_AllTypes WHERE [CharCol]=:value";
$stmt = $db->prepare($query,array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value',$data);
$stmt->execute();
$data = "STRINGCOL2";
$query = "DELETE FROM $tbname WHERE [CharCol]=:value";
$stmt = $db->prepare($query, array(PDO::ATTR_CURSOR=>PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE=>PDO::SQLSRV_CURSOR_BUFFERED));
$stmt->bindParam(':value', $data);
$stmt->execute();
unset($stmt);
}
try {
$db = connect();
$tbname = "PDO_AllTypes";
createAndInsertTableAllTypes($db, $tbname);
insert($db, $tbname);
bindPARAM_LOB($db, $tbname);
bindPARAM_STR($db, $tbname);
bindPARAM_NULL($db, $tbname);
bindPARAM_INT($db, $tbname);
bindPARAM_BOOL($db, $tbname);
delete($db, $tbname);
$db = connect();
insert($db);
bindParam_LOB($db);
bindParam_STR($db);
bindParam_NULL($db);
bindParam_INT($db);
bindParam_BOOL($db);
delete($db);
echo "Test Completed";
}
catch( PDOException $e ) {
var_dump( $e );
dropTable($db, $tbname);
unset($db);
echo "Test Completed";
} catch (PDOException $e) {
var_dump($e);
exit;
}
@ -207,4 +213,4 @@ Insert complete!
0
1
1
Test Completed
Test Completed

BIN
test/functional/pdo_sqlsrv/pdostatement_GetDataType.phpt
View file

Binary file not shown.

45
test/functional/pdo_sqlsrv/pdostatement_bindColumn.phpt
View file

@ -1,53 +1,50 @@
--TEST--
Test the bindColumn method using either by bind by column number or bind by column name
--SKIPIF--
<?php require "skipif.inc"; ?>
<?php require "skipif_mid-refactor.inc"; ?>
--FILE--
<?php
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
require_once "MsCommon.inc";
function bindColumn_byName($db)
function bindColumnByName($db, $tbname)
{
global $table1;
$stmt = $db->prepare("SELECT IntCol, CharCol, DateTimeCol FROM " . $table1);
$stmt = $db->prepare("SELECT IntCol, CharCol, DateTimeCol FROM $tbname");
$stmt->execute();
$stmt->bindColumn('IntCol', $intCol);
$stmt->bindColumn('CharCol', $charCol);
$stmt->bindColumn('DateTimeCol', $dateTimeCol);
while($row = $stmt->fetch(PDO::FETCH_BOUND))
{
while ($row = $stmt->fetch(PDO::FETCH_BOUND)) {
echo $intCol . " : " . $charCol . " : " . $dateTimeCol . "\n";
}
}
function bindColumn_byNumber($db)
function bindColumnByNumber($db, $tbname)
{
global $table1;
$stmt = $db->prepare("SELECT IntCol, CharCol, DateTimeCol FROM " . $table1);
$stmt = $db->prepare("SELECT IntCol, CharCol, DateTimeCol FROM $tbname");
$stmt->execute();
$stmt->bindColumn(1, $intCol);
$stmt->bindColumn(2, $charCol);
$stmt->bindColumn(3, $dateTimeCol);
while($row = $stmt->fetch(PDO::FETCH_BOUND))
{
while ($row = $stmt->fetch(PDO::FETCH_BOUND)) {
echo $intCol . " : " . $charCol . " : " . $dateTimeCol . "\n";
}
}
try
{
try {
$db = connect();
$tbname = "PDO_MainTypes";
createAndInsertTableMainTypes($db, $tbname);
echo "Bind Column by name :\n";
bindColumn_byName($db);
bindColumnByName($db, $tbname);
echo "Bind Column by number :\n";
bindColumn_byNumber($db);
}
catch (PDOException $e)
{
bindColumnByNumber($db, $tbname);
dropTable($db, $tbname);
unset($db);
} catch (PDOException $e) {
var_dump($e);
}
@ -58,4 +55,4 @@ Bind Column by name :
2 : STRINGCOL2 : 2000-11-11 11:11:11.223
Bind Column by number :
1 : STRINGCOL1 : 2000-11-11 11:11:11.110
2 : STRINGCOL2 : 2000-11-11 11:11:11.223
2 : STRINGCOL2 : 2000-11-11 11:11:11.223

217
test/functional/pdo_sqlsrv/pdostatement_bindParam.phpt
View file

@ -1,7 +1,7 @@
--TEST--
PDOStatement::BindParam for NULL types and for value types.
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
@ -23,141 +23,134 @@ PDOStatement::BindParam for NULL types and for value types.
//*************************************************************************************
require_once 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
function bind_params_with_null($db)
function bindParamsWithNull($db, $tbname)
{
global $table2;
$sql = " INSERT INTO " .$table2 . "
([BigIntCol]
,[BinaryCol]
,[BitCol]
,[CharCol]
,[DateCol]
,[DateTimeCol]
,[DateTime2Col]
,[DTOffsetCol]
,[DecimalCol]
,[FloatCol]
,[ImageCol]
,[IntCol]
,[MoneyCol]
,[NCharCol]
,[NTextCol]
,[NumCol]
,[NVarCharCol]
,[NVarCharMaxCol]
,[RealCol]
,[SmallDTCol]
,[SmallIntCol]
,[SmallMoneyCol]
,[TextCol]
,[TimeCol]
,[TinyIntCol]
,[Guidcol]
,[VarbinaryCol]
,[VarbinaryMaxCol]
,[VarcharCol]
,[VarcharMaxCol]
,[XmlCol])
VALUES (?,?,?,?,?,?,?,?,?,? /*10*/,?,?,?,?,?,?,?,?,?,? /*20*/, ?,?,?,?,?,?,?,?,?,?, ? /*31*/)";
$sql = "INSERT INTO $tbname
([BigIntCol],
[BinaryCol],
[BitCol],
[CharCol],
[DateCol],
[DateTimeCol],
[DateTime2Col],
[DTOffsetCol],
[DecimalCol],
[FloatCol],
[ImageCol],
[IntCol],
[MoneyCol],
[NCharCol],
[NTextCol],
[NumCol],
[NVarCharCol],
[NVarCharMaxCol],
[RealCol],
[SmallDTCol],
[SmallIntCol],
[SmallMoneyCol],
[TextCol],
[TimeCol],
[TinyIntCol],
[Guidcol],
[VarbinaryCol],
[VarbinaryMaxCol],
[VarcharCol],
[VarcharMaxCol],
[XmlCol])
VALUES (?,?,?,?,?,?,?,?,?,? /*10*/,?,?,?,?,?,?,?,?,?,? /*20*/, ?,?,?,?,?,?,?,?,?,?, ? /*31*/)";
$stmt = $db->prepare($sql);
$stmt = $db->prepare($sql);
$param = null;
$stmt->bindParam(1, $param);
$stmt->bindParam(2, $param, PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY );
$stmt->bindParam(3, $param );
$stmt->bindParam(4, $param );
$stmt->bindParam(5, $param );
$stmt->bindParam(6, $param );
$stmt->bindParam(7, $param );
$stmt->bindParam(8, $param );
$stmt->bindParam(9, $param );
$stmt->bindParam(10, $param );
$stmt->bindParam(11, $param );
$stmt->bindParam(12, $param );
$stmt->bindParam(13, $param );
$stmt->bindParam(14, $param );
$stmt->bindParam(15, $param );
$stmt->bindParam(16, $param );
$stmt->bindParam(17, $param );
$stmt->bindParam(18, $param );
$stmt->bindParam(19, $param );
$stmt->bindParam(20, $param );
$stmt->bindParam(21, $param );
$stmt->bindParam(22, $param );
$stmt->bindParam(23, $param );
$stmt->bindParam(24, $param );
$stmt->bindParam(25, $param );
$stmt->bindParam(26, $param );
$stmt->bindParam(27, $param, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY ); //PDO::PARAM_STR OR PDO::PARAM_LOB DOES NOT MATTER
$stmt->bindParam(28, $param, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY );
$stmt->bindParam(29, $param );
$stmt->bindParam(30, $param );
$stmt->bindParam(31, $param );
$stmt->execute();
$stmt->bindParam(2, $param, PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->bindParam(3, $param);
$stmt->bindParam(4, $param);
$stmt->bindParam(5, $param);
$stmt->bindParam(6, $param);
$stmt->bindParam(7, $param);
$stmt->bindParam(8, $param);
$stmt->bindParam(9, $param);
$stmt->bindParam(10, $param);
$stmt->bindParam(11, $param);
$stmt->bindParam(12, $param);
$stmt->bindParam(13, $param);
$stmt->bindParam(14, $param);
$stmt->bindParam(15, $param);
$stmt->bindParam(16, $param);
$stmt->bindParam(17, $param);
$stmt->bindParam(18, $param);
$stmt->bindParam(19, $param);
$stmt->bindParam(20, $param);
$stmt->bindParam(21, $param);
$stmt->bindParam(22, $param);
$stmt->bindParam(23, $param);
$stmt->bindParam(24, $param);
$stmt->bindParam(25, $param);
$stmt->bindParam(26, $param);
$stmt->bindParam(27, $param, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY); //PDO::PARAM_STR OR PDO::PARAM_LOB DOES NOT MATTER
$stmt->bindParam(28, $param, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->bindParam(29, $param);
$stmt->bindParam(30, $param);
$stmt->bindParam(31, $param);
$stmt->execute();
}
function bind_params_int($db)
function bindParamsInt($db, $tbname)
{
global $table2;
$stmt = $db->prepare("SELECT * FROM " . $table2 . " WHERE BigIntCol = :bigIntCol ");
$int = 1;
$stmt->bindParam(":bigIntCol", $int, PDO::PARAM_INT);
$stmt->execute();
$stmt = $db->prepare("SELECT * FROM $tbname WHERE BigIntCol = :bigIntCol");
$int = 1;
$stmt->bindParam(":bigIntCol", $int, PDO::PARAM_INT);
$stmt->execute();
}
function bind_params_str($db)
function bindParamsStr($db, $tbname)
{
global $table2;
$stmt = $db->prepare("SELECT * FROM " . $table2 . " WHERE CharCol = :charCol ");
$char = "STRINGCOL1";
$stmt->bindParam(":charCol", $char, PDO::PARAM_STR);
$stmt->execute();
$stmt = $db->prepare("SELECT * FROM $tbname WHERE CharCol = :charCol");
$char = "STRINGCOL1";
$stmt->bindParam(":charCol", $char, PDO::PARAM_STR);
$stmt->execute();
}
function bind_params_bool($db)
function bindParamsBool($db, $tbname)
{
global $table2;
$stmt = $db->prepare("SELECT * FROM " . $table2 . " WHERE BitCol = :bool ");
$bool = 0;
$stmt->bindParam(":bool" , $bool, PDO::PARAM_BOOL);
$stmt->execute();
$stmt = $db->prepare("SELECT * FROM " . $tbname . " WHERE BitCol = :bool");
$bool = 0;
$stmt->bindParam(":bool", $bool, PDO::PARAM_BOOL);
$stmt->execute();
}
function bind_params_lob($db)
function bindParamsLob($db, $tbname)
{
global $table2;
$stmt = $db->prepare("SELECT * FROM " . $table2 . " WHERE BinaryCol = :lob ");
$lob = 0;
$stmt->bindParam(":lob" , $lob, PDO::PARAM_LOB);
$stmt->execute();
$stmt = $db->prepare("SELECT * FROM $tbname WHERE BinaryCol = :lob");
$lob = fopen('php://memory', 'a');
fwrite($lob, '00');
rewind($lob);
$stmt->bindParam(":lob", $lob, PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
$stmt->execute();
}
try {
$db = connect();
$tbname = "PDO_AllTypes";
createAndInsertTableAllTypes($db, $tbname);
bindParamsWithNull($db, $tbname);
bindParamsInt($db, $tbname);
bindParamsStr($db, $tbname);
bindParamsBool($db, $tbname);
bindParamsLob($db, $tbname);
$db = connect();
create_and_insert_table2( $db );
bind_params_with_null($db);
bind_params_int($db);
bind_params_str($db);
bind_params_bool($db);
bind_params_lob($db);
echo "Test Succeeded";
}
catch( PDOException $e ) {
var_dump( $e );
dropTable($db, $tbname);
unset($db);
echo "Test Succeeded\n";
} catch (PDOException $e) {
var_dump($e);
exit;
}
?>
--EXPECT--
Test Succeeded

23
test/functional/pdo_sqlsrv/pdostatement_bindValue.phpt
View file

@ -1,27 +1,30 @@
--TEST--
Test bindValue method.
--SKIPIF--
<?php require "skipif.inc"; ?>
<?php require("skipif_mid-refactor.inc"); ?>
--FILE--
<?php
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
require_once 'MsCommon.inc';
try{
try {
$db = connect();
global $table2;
$tbname = "PDO_AllTypes";
createAndInsertTableAllTypes($db, $tbname);
$bigint = 1;
$string = "STRINGCOL1";
$stmt = $db->prepare("SELECT IntCol FROM " . $table2 . " WHERE BigIntCol = :bigint AND CharCol = :string");
$stmt = $db->prepare("SELECT IntCol FROM $tbname WHERE BigIntCol = :bigint AND CharCol = :string");
$stmt->bindValue(':bigint', $bigint, PDO::PARAM_INT);
$stmt->bindValue(':string', $string, PDO::PARAM_STR);
$stmt->execute();
dropTable($db, $tbname);
unset($stmt);
unset($db);
echo "Test Complete!\n";
}
catch (PDOException $e)
{
} catch (PDOException $e) {
var_dump($e);
}
?>
--EXPECT--
Test Complete!
Test Complete!

29
test/functional/pdo_sqlsrv/pdostatement_closeCursor.phpt
View file

@ -1,28 +1,27 @@
--TEST--
Test PDOStatement::closeCursor method.
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
try{
try {
$db = connect();
global $table2;
$stmt = $db->prepare("SELECT * FROM " . $table2);
$tbname = "PDO_AllTypes";
createAndInsertTableAllTypes($db, $tbname);
$stmt = $db->prepare("SELECT * FROM $tbname");
$stmt->execute();
$result = $stmt->fetch();
$stmt->closeCursor();
echo "Test complete!";
}
catch ( PDOException $e)
{
dropTable($db, $tbname);
unset($stmt);
unset($db);
echo "Test complete!\n";
} catch (PDOException $e) {
var_dump($e);
}
?>
--EXPECT--
Test complete!
Test complete!

31
test/functional/pdo_sqlsrv/pdostatement_columnCount.phpt
View file

@ -1,24 +1,23 @@
--TEST--
Test PDOStatement::columnCount if the number of the columns in a result set.
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
require_once 'MsCommon.inc';
try
{
$db = connect();
$sql = "SELECT * FROM PDO_AllTypes";
$stmt = $db->prepare($sql);
$stmt->execute();
print_r("Existing table contains: " . $stmt->columnCount());
}
catch(PDOException $e)
{
var_dump($e);
}
try {
$db = connect();
$tbname = "PDO_AllTypes";
createAndInsertTableAllTypes($db, $tbname);
$sql = "SELECT * FROM $tbname";
$stmt = $db->prepare($sql);
$stmt->execute();
print_r("Existing table contains: " . $stmt->columnCount() . "\n");
} catch (PDOException $e) {
var_dump($e);
}
?>
--EXPECT--
Existing table contains: 31
Existing table contains: 31

24
test/functional/pdo_sqlsrv/pdostatement_debugDumpParams.phpt
View file

@ -1,26 +1,30 @@
--TEST--
Test debugDumpParams method.
--SKIPIF--
<?php require "skipif.inc"; ?>
<?php require("skipif_mid-refactor.inc"); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
require_once('MsCommon_mid-refactor.inc');
require_once("MsData_PDO_AllTypes.inc");
try{
try {
$db = connect();
global $table2;
$tbname = "PDO_AllTypes";
createAndInsertTableAllTypes($db, $tbname);
$bigint = 1;
$string = "STRINGCOL1";
$stmt = $db->prepare("SELECT IntCol FROM " . $table2 . " WHERE BigIntCol = :bigint AND CharCol = :string");
$stmt = $db->prepare("SELECT IntCol FROM $tbname WHERE BigIntCol = :bigint AND CharCol = :string");
$stmt->bindValue(':bigint', $bigint, PDO::PARAM_INT);
$stmt->bindValue(':string', $string, PDO::PARAM_STR);
$stmt->execute();
$stmt->debugDumpParams();
}
catch (PDOException $e)
{
dropTable($db, $tbname);
unset($stmt);
unset($db);
} catch (PDOException $e) {
var_dump($e);
}
?>
@ -36,4 +40,4 @@ Key: Name: [7] :string
paramno=1
name=[7] ":string"
is_param=1
param_type=2
param_type=2

27
test/functional/pdo_sqlsrv/pdostatement_error.phpt
View file

@ -1,31 +1,30 @@
--TEST--
Test PDOStatement::errorInfo and PDOStatement::errorCode methods.
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
try
{
try {
$db = connect();
$stmt = $db->prepare("SELECT * FROM PDO_Types_1");
$tbname = "PDO_MainTypes";
createAndInsertTableMainTypes($db, $tbname);
$stmt = $db->prepare("SELECT * FROM $tbname");
$stmt->execute();
$arr = $stmt->errorInfo();
print_r("Error Info :\n");
var_dump($arr);
$arr = $stmt->errorCode();
print_r("Error Code : " . $arr . "\n");
$db = null;
}
catch (PDOException $e)
{
dropTable($db, $tbname);
unset($stmt);
unset($db);
} catch (PDOException $e) {
var_dump($e);
}
?>
--EXPECT--
Error Info :
@ -37,4 +36,4 @@ array(3) {
[2]=>
NULL
}
Error Code : 00000
Error Code : 00000

62
test/functional/pdo_sqlsrv/pdostatement_execute.phpt
View file

@ -1,34 +1,52 @@
--TEST--
Test PDOStatement::execute method.
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
try
{
$db = connect();
try {
$db = connect();
$tbname = "PDO_MainTypes";
createAndInsertTableMainTypes($db, $tbname);
$stmt = $db->prepare("SELECT * FROM PDO_Types_1");
$stmt->execute();
$rows = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($rows);
// Test update table value
$stmt = $db->prepare("UPDATE PDO_Types_1 SET IntCol=1");
$rows = $stmt->execute();
var_dump($rows);
// Test insert value to table
$stmt1 = $db->prepare("INSERT INTO PDO_Types_1 (IntCol,CharCol,NCharCol,DateTimeCol,VarcharCol,NVarCharCol,FloatCol,XmlCol) VALUES (2,'STRINGCOL1','STRINGCOL1','2000-11-11 11:11:11.110','STRINGCOL1','STRINGCOL1',111.111,'<xml> 1 This is a really large string used to test certain large data types like xml data type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>')");
$rows = $stmt1->execute();
var_dump($rows);
$db = null;
}
catch(PDOException $e)
{
var_dump($e);
$stmt = $db->prepare("SELECT * FROM $tbname");
$stmt->execute();
$rows = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($rows);
// Test update table value
if (isColEncrypted()) {
$stmt = $db->prepare("UPDATE $tbname SET IntCol=?");
$r = $stmt->execute(array(1));
} else {
$stmt = $db->prepare("UPDATE $tbname SET IntCol=1");
$r = $stmt->execute();
}
var_dump($r);
// Test insert value to table
$inputs = array("IntCol" => 2,
"CharCol" => 'STRINGCOL1',
"NCharCol" => 'STRINGCOL1',
"DateTimeCol" => '2000-11-11 11:11:11.110',
"VarcharCol" => 'STRINGCOL1',
"NVarCharCol" => 'STRINGCOL1',
"FloatCol" => 111.111,
"XmlCol" => '<xml> 1 This is a really large string used to test certain large data types like xml data type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>');
$r;
$stmt1 = insertRow($db, $tbname, $inputs, "prepareExecuteBind", $r);
var_dump($r);
dropTable($db, $tbname);
unset($stmt);
unset($stmt1);
unset($conn);
} catch (PDOException $e) {
var_dump($e);
}
?>
--EXPECT--
array(8) {

BIN
test/functional/pdo_sqlsrv/pdostatement_fetchAll.phpt
View file

Binary file not shown.

64
test/functional/pdo_sqlsrv/pdostatement_fetchColumn.phpt
View file

@ -1,54 +1,42 @@
--TEST--
Test the fetchColumn() method.
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
function fetch_column( $conn )
{
global $table1;
$stmt = $conn->query( "Select * from ". $table1 );
// Fetch the first column from the next row in resultset. (This wud be first row since this is a first call to fetchcol)
$result = $stmt->fetchColumn();
var_dump($result);
// Fetch the second column from the next row. (This would be second row since this is a second call to fetchcol).
$result = $stmt->fetchColumn(1);
var_dump($result);
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
// Test false is returned when there are no more rows.
$result = $stmt->fetchColumn(1);
var_dump($result);
}
try
{
//$verbose = false;
$db = connect();
create_and_insert_table1( $db );
fetch_column($db);
}
try {
$db = connect();
$tbname = "PDO_MainTypes";
createAndInsertTableMainTypes($db, $tbname);
catch( PDOException $e ) {
$stmt = $db->query("Select * from $tbname");
var_dump( $e );
// Fetch the first column from the next row in resultset. (This would be first row since this is a first call to fetchcol)
$result = $stmt->fetchColumn();
var_dump($result);
// Fetch the second column from the next row. (This would be second row since this is a second call to fetchcol).
$result = $stmt->fetchColumn(1);
var_dump($result);
// Test false is returned when there are no more rows.
$result = $stmt->fetchColumn(1);
var_dump($result);
dropTable($db, $tbname);
unset($stmt);
unset($conn);
} catch (PDOException $e) {
var_dump($e);
exit;
}
?>
?>
--EXPECT--
string(1) "1"
string(10) "STRINGCOL2"
bool(false)

BIN
test/functional/pdo_sqlsrv/pdostatement_fetchObject.phpt
View file

Binary file not shown.

221
test/functional/pdo_sqlsrv/pdostatement_fetch_style.phpt
View file

@ -1,153 +1,116 @@
--TEST--
Test the PDOStatement::fetch() method with different fetch styles.
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
function fetch_both( $conn )
function fetchWithStyle($conn, $tbname, $style)
{
global $table1;
$stmt = $conn->query( "Select * from ". $table1 );
$result = $stmt->fetch(PDO::FETCH_BOTH);
var_dump($result);
$stmt->closeCursor();
}
function fetch_assoc( $conn )
{
global $table1;
$stmt = $conn->query( "Select * from ". $table1 );
$result = $stmt->fetch(PDO::FETCH_ASSOC);
var_dump($result);
$stmt->closeCursor();
}
function fetch_lazy( $conn )
{
global $table1;
$stmt = $conn->query( "Select * from " . $table1 );
$result = $stmt->fetch(PDO::FETCH_LAZY);
var_dump($result);
$stmt->closeCursor();
}
function fetch_obj( $conn )
{
global $table1;
$stmt = $conn->query( "Select * from ". $table1 );
$result = $stmt->fetch(PDO::FETCH_OBJ);
var_dump($result);
$stmt->closeCursor();
}
function fetch_num( $conn )
{
global $table1;
$stmt = $conn->query( "Select * from ". $table1 );
$result = $stmt->fetch(PDO::FETCH_NUM);
var_dump($result);
$stmt->closeCursor();
}
function fetch_bound( $conn )
{
global $table1;
$stmt = $conn->query( "Select * from ". $table1 );
$stmt->bindColumn('IntCol', $IntCol);
$stmt->bindColumn('CharCol', $CharCol);
$stmt->bindColumn('NCharCol', $NCharCol);
$stmt->bindColumn('DateTimeCol', $DateTimeCol);
$stmt->bindColumn('VarcharCol', $VarcharCol);
$stmt->bindColumn('NVarCharCol', $NVarCharCol);
$stmt->bindColumn('FloatCol', $FloatCol);
$stmt->bindColumn('XmlCol', $XmlCol);
$result = $stmt->fetch(PDO::FETCH_BOUND);
if (!$result)
{
die("Error in FETCH_BOUND\n");
$stmt = $conn->query("SELECT * FROM $tbname");
switch ($style) {
case PDO::FETCH_BOTH:
case PDO::FETCH_ASSOC:
case PDO::FETCH_LAZY:
case PDO::FETCH_OBJ:
case PDO::FETCH_NUM:
{
$result = $stmt->fetch($style);
var_dump($result);
unset($stmt);
break;
}
case PDO::FETCH_BOUND:
{
$stmt->bindColumn('IntCol', $IntCol);
$stmt->bindColumn('CharCol', $CharCol);
$stmt->bindColumn('NCharCol', $NCharCol);
$stmt->bindColumn('DateTimeCol', $DateTimeCol);
$stmt->bindColumn('VarcharCol', $VarcharCol);
$stmt->bindColumn('NVarCharCol', $NVarCharCol);
$stmt->bindColumn('FloatCol', $FloatCol);
$stmt->bindColumn('XmlCol', $XmlCol);
$result = $stmt->fetch($style);
if (!$result) {
die("Error in FETCH_BOUND\n");
}
var_dump($IntCol);
var_dump($CharCol);
var_dump($NCharCol);
var_dump($DateTimeCol);
var_dump($VarcharCol);
var_dump($NVarCharCol);
var_dump($FloatCol);
var_dump($XmlCol);
unset($stmt);
break;
}
case PDO::FETCH_CLASS:
{
global $mainTypesClass;
$stmt->setFetchMode($style, $mainTypesClass);
$result = $stmt->fetch($style);
$result->dumpAll();
unset($stmt);
break;
}
case PDO::FETCH_INTO:
{
global $mainTypesClass;
$obj = new $mainTypesClass;
$stmt->setFetchMode($style, $obj);
$result = $stmt->fetch($style);
$obj->dumpAll();
unset($stmt);
break;
}
case "PDO::FETCH_INVALID":
{
try {
$result = $stmt->fetch(PDO::FETCH_UNKNOWN);
} catch (PDOException $err) {
print_r($err);
}
break;
}
}
var_dump($IntCol);
var_dump($CharCol);
var_dump($NCharCol);
var_dump($DateTimeCol);
var_dump($VarcharCol);
var_dump($NVarCharCol);
var_dump($FloatCol);
var_dump($XmlCol);
$stmt->closeCursor();
}
function fetch_class( $conn )
{
global $table1;
global $table1_class;
$stmt = $conn->query( "Select * from ". $table1 );
$stmt->setFetchMode(PDO::FETCH_CLASS, $table1_class);
$result = $stmt->fetch(PDO::FETCH_CLASS);
$result->dumpAll();
$stmt->closeCursor();
}
function fetch_into( $conn )
{
global $table1;
global $table1_class;
$stmt = $conn->query( "Select * from ". $table1 );
$obj = new $table1_class;
$stmt->setFetchMode(PDO::FETCH_INTO, $obj);
$result = $stmt->fetch(PDO::FETCH_INTO);
$obj->dumpAll();
$stmt->closeCursor();
}
function fetch_invalid( $conn )
{
global $table1;
$stmt = $conn->query( "Select * from ". $table1 );
try
{
$result = $stmt->fetch(PDO::FETCH_UNKNOWN);
}
catch(PDOException $err)
{
print_r($err);
}
}
try
{
try {
$db = connect();
create_and_insert_table1( $db );
$tbname = "PDO_MainTypes";
createAndInsertTableMainTypes($db, $tbname);
echo "Test_1 : FETCH_BOTH :\n";
fetch_both($db);
fetchWithStyle($db, $tbname, PDO::FETCH_BOTH);
echo "Test_2 : FETCH_ASSOC :\n";
fetch_assoc($db);
fetchWithStyle($db, $tbname, PDO::FETCH_ASSOC);
echo "Test_3 : FETCH_LAZY :\n";
fetch_lazy($db);
fetchWithStyle($db, $tbname, PDO::FETCH_LAZY);
echo "Test_4 : FETCH_OBJ :\n";
fetch_obj($db);
fetchWithStyle($db, $tbname, PDO::FETCH_OBJ);
echo "Test_5 : FETCH_NUM :\n";
fetch_num($db);
fetchWithStyle($db, $tbname, PDO::FETCH_NUM);
echo "Test_6 : FETCH_BOUND :\n";
fetch_bound($db);
fetchWithStyle($db, $tbname, PDO::FETCH_BOUND);
echo "Test_7 : FETCH_CLASS :\n";
fetch_class($db);
fetchWithStyle($db, $tbname, PDO::FETCH_CLASS);
echo "Test_8 : FETCH_INTO :\n";
fetch_into($db);
fetchWithStyle($db, $tbname, PDO::FETCH_INTO);
echo "Test_9 : FETCH_INVALID :\n";
fetch_invalid($db);
}
catch( PDOException $e ) {
var_dump( $e );
fetchWithStyle($db, $tbname, "PDO::FETCH_INVALID");
dropTable($db, $tbname);
unset($db);
} catch (PDOException $e) {
var_dump($e);
exit;
}
?>
?>
--EXPECTF--
Test_1 : FETCH_BOTH :
@ -207,7 +170,7 @@ array(8) {
Test_3 : FETCH_LAZY :
object(PDORow)#%x (%x) {
["queryString"]=>
string(25) "Select * from PDO_Types_1"
string(27) "SELECT * FROM PDO_MainTypes"
["IntCol"]=>
string(1) "1"
["CharCol"]=>
@ -294,6 +257,6 @@ Test_9 : FETCH_INVALID :
Fatal error: Uncaught Error: Undefined class constant 'FETCH_UNKNOWN' in %s:%x
Stack trace:
#0 %s: fetch_invalid(Object(PDO))
#0 %s: fetchWithStyle(Object(PDO), 'PDO_MainTypes', 'PDO::FETCH_INVA...')
#1 {main}
thrown in %s on line %x
thrown in %s on line %x

88
test/functional/pdo_sqlsrv/pdostatement_getColumnMeta.phpt
View file

@ -1,76 +1,78 @@
--TEST--
Test the PDOStatement::getColumnMeta() method (Note: there could be an issue about using a non-existent column index --- doesn't give any error/output/warning).
Test the PDOStatement::getColumnMeta() method
--DESCRIPTION--
there could be an issue about using a non-existent column index --- doesn't give any error/output/warning
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
function fetch_both( $conn )
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
function fetchBoth($conn, $tbname)
{
global $table1;
$stmt = $conn->query( "Select * from ". $table1 );
$stmt = $conn->query("Select * from $tbname");
// 1
$meta = $stmt->getColumnMeta( 0 );
var_dump($meta);
$meta = $stmt->getColumnMeta(0);
var_dump($meta);
// 2
$meta = $stmt->getColumnMeta( 1 );
var_dump($meta);
$meta = $stmt->getColumnMeta(1);
var_dump($meta);
// 3
$meta = $stmt->getColumnMeta( 2 );
var_dump($meta);
$meta = $stmt->getColumnMeta(2);
var_dump($meta);
// 4
$meta = $stmt->getColumnMeta( 3 );
var_dump($meta);
$meta = $stmt->getColumnMeta(3);
var_dump($meta);
// 5
$meta = $stmt->getColumnMeta( 4 );
var_dump($meta);
$meta = $stmt->getColumnMeta(4);
var_dump($meta);
// 6
$meta = $stmt->getColumnMeta( 5 );
var_dump($meta);
$meta = $stmt->getColumnMeta(5);
var_dump($meta);
// 7
$meta = $stmt->getColumnMeta( 6 );
var_dump($meta);
$meta = $stmt->getColumnMeta(6);
var_dump($meta);
// 8
$meta = $stmt->getColumnMeta( 7 );
var_dump($meta);
$meta = $stmt->getColumnMeta(7);
if ($meta["sqlsrv:decl_type"] != "xml") {
echo "Wrong column metadata was retrieved for a xml column.\n";
}
unset($meta["sqlsrv:decl_type"]);
var_dump($meta);
// Test invalid arguments, set error mode to silent to reduce the amount of error messages generated
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
// Test negative column number, ignore the error messages
$meta = $stmt->getColumnMeta( -1 );
$meta = $stmt->getColumnMeta(-1);
var_dump($meta);
// Test non-existent column number
//$meta = $stmt->getColumnMeta( 10 );
//var_dump($meta);
$meta = $stmt->getColumnMeta(10);
var_dump($meta);
}
try
{
try {
$db = connect();
create_and_insert_table1( $db );
fetch_both($db);
}
catch( PDOException $e ) {
var_dump( $e );
$tbname = "PDO_MainTypes";
createAndInsertTableMainTypes($db, $tbname);
fetchBoth($db, $tbname);
} catch (PDOException $e) {
var_dump($e);
exit;
}
?>
?>
--EXPECTF--
array(8) {
@ -199,11 +201,9 @@ array(8) {
["precision"]=>
int(0)
}
array(8) {
array(7) {
["flags"]=>
int(0)
["sqlsrv:decl_type"]=>
string(3) "xml"
["native_type"]=>
string(6) "string"
["table"]=>
@ -219,4 +219,6 @@ array(8) {
}
Warning: PDOStatement::getColumnMeta(): SQLSTATE[42P10]: Invalid column reference: column number must be non-negative in %s on line %x
bool(false)
bool(false)
Fatal error: pdo_sqlsrv_stmt_get_col_meta: invalid column number. in %s on line %x

169
test/functional/pdo_sqlsrv/pdostatement_getColumnMeta_unicode_col_name.phpt
View file

@ -1,124 +1,117 @@
--TEST--
Test the PDOStatement::getColumnMeta() method for Unicode column names (Note: there could be an issue about using a non-existent column index --- doesn't give any error/output/warning).
Test the PDOStatement::getColumnMeta() method for Unicode column names
--DESCRIPTION--
there could be an issue about using a non-existent column index --- doesn't give any error/output/warning
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_mid-refactor.inc'); ?>
--FILE--
<?php
require_once 'MsCommon.inc';
function fetch_both( $conn )
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
function fetchBoth($conn, $tbname)
{
global $table1;
$stmt = $conn->query( "Select * from ". $table1 );
$stmt = $conn->query("Select * from $tbname");
// 1
$meta = $stmt->getColumnMeta( 0 );
var_dump($meta);
$meta = $stmt->getColumnMeta(0);
var_dump($meta);
// 2
$meta = $stmt->getColumnMeta( 1 );
var_dump($meta);
$meta = $stmt->getColumnMeta(1);
var_dump($meta);
// 3
$meta = $stmt->getColumnMeta( 2 );
var_dump($meta);
$meta = $stmt->getColumnMeta(2);
var_dump($meta);
// 4
$meta = $stmt->getColumnMeta( 3 );
var_dump($meta);
$meta = $stmt->getColumnMeta(3);
var_dump($meta);
// 5
$meta = $stmt->getColumnMeta( 4 );
var_dump($meta);
$meta = $stmt->getColumnMeta(4);
var_dump($meta);
// 6
$meta = $stmt->getColumnMeta( 5 );
var_dump($meta);
$meta = $stmt->getColumnMeta(5);
var_dump($meta);
// 7
$meta = $stmt->getColumnMeta( 6 );
var_dump($meta);
$meta = $stmt->getColumnMeta(6);
var_dump($meta);
// 8
$meta = $stmt->getColumnMeta( 7 );
var_dump($meta);
$meta = $stmt->getColumnMeta(7);
if (isColEncrypted()) {
$xmlType = "nvarchar";
} else {
$xmlType = "xml";
}
if ($meta["sqlsrv:decl_type"] != $xmlType) {
echo "Wrong column metadata was retrieved for a $xmlType column.\n";
}
unset($meta["sqlsrv:decl_type"]);
var_dump($meta);
// Test invalid arguments, set error mode to silent to reduce the amount of error messages generated
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
// Test negative column number, ignore the error messages
$meta = $stmt->getColumnMeta( -1 );
$meta = $stmt->getColumnMeta(-1);
var_dump($meta);
// Test non-existent column number
//$meta = $stmt->getColumnMeta( 10 );
//var_dump($meta);
$meta = $stmt->getColumnMeta(10);
var_dump($meta);
}
function create_and_insert_table_unicode( $conn )
function createAndInsertTableUnicode($conn, $tbname)
{
global $string_col, $date_col, $large_string_col, $xml_col, $binary_col, $int_col, $decimal_col, $guid_col, $null_col, $comma, $closing_brace, $table1;
try
{
$create_query =
"IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'" . $table1 . "') AND type in (N'U'))
DROP TABLE " . $table1 .
" CREATE TABLE [dbo].[" . $table1 . "](
[此是後話] [int] NULL,
[Κοντάוְאַתָּה第] [char](10) NULL,
[NΚοντάוְאַתָּה第] [nchar](10) NULL,
[ნომინავიiałopioБун] [datetime] NULL,
[VarcharCol] [varchar](50) NULL,
[NVarΚοντάוְאַתָּה第] [nvarchar](50) NULL,
[FloatCol] [float] NULL,
[XmlCol] [xml] NULL
) ON [PRIMARY]
";
$conn->query( $create_query );
for ($i = 0 ; $i <= 1; ++ $i)
{
$insert_query =
"INSERT INTO PDO_Types_1 VALUES (".
$int_col[$i] . $comma .
$string_col[$i] . $comma .
$string_col[$i] . $comma .
"Convert(datetime, ". $date_col[$i] . ")" . $comma .
$string_col[$i] . $comma .
$string_col[$i] . $comma .
$decimal_col[$i] . $comma .
$xml_col[$i] .
")";
$conn->query ( $insert_query );
try {
global $string_col, $xml_col, $int_col, $decimal_col, $datetime_col;
if (isColEncrypted()) {
$xmlType = "nvarchar(max)";
} else {
$xmlType = "xml";
}
}
catch(Exception $e)
{
var_dump( $e);
$columnMetaArr = array("此是後話" => "int",
"Κοντάוְאַתָּה第" => "char(10)",
"NΚοντάוְאַתָּה第" => "nchar(10)",
"ნომინავიiałopioБун" => "datetime",
"VarcharCol" => "varchar(50)",
"NVarΚοντάוְאַתָּה第" => "nvarchar(50)",
"FloatCol" => "float",
"XmlCol" => $xmlType);
createTable($conn, $tbname, $columnMetaArr, "ON [PRIMARY]");
for ($i = 0 ; $i <= 1; ++ $i) {
$inputs = array("此是後話" => $int_col[$i],
"Κοντάוְאַתָּה第" => $string_col[$i],
"NΚοντάוְאַתָּה第" => $string_col[$i],
"ნომინავიiałopioБун" => $datetime_col[$i],
"VarcharCol" => $string_col[$i],
"NVarΚοντάוְאַתָּה第" => $string_col[$i],
"FloatCol" => $decimal_col[$i],
"XmlCol" => $xml_col[$i]);
$stmt = insertRow($conn, $tbname, $inputs, "prepareBindParam");
}
} catch (Exception $e) {
var_dump($e);
exit;
}
}
try
{
$db = connect();
create_and_insert_table_unicode( $db );
fetch_both($db);
}
catch( PDOException $e ) {
var_dump( $e );
try {
$db = connect();
$tbname = "PDO_MainTypes";
createAndInsertTableUnicode($db, $tbname);
fetchBoth($db, $tbname);
} catch (PDOException $e) {
var_dump($e);
exit;
}
?>
?>
--EXPECTF--
array(8) {
@ -247,11 +240,9 @@ array(8) {
["precision"]=>
int(0)
}
array(8) {
array(7) {
["flags"]=>
int(0)
["sqlsrv:decl_type"]=>
string(3) "xml"
["native_type"]=>
string(6) "string"
["table"]=>
@ -267,4 +258,6 @@ array(8) {
}
Warning: PDOStatement::getColumnMeta(): SQLSTATE[42P10]: Invalid column reference: column number must be non-negative in %s on line %x
bool(false)
bool(false)
Fatal error: pdo_sqlsrv_stmt_get_col_meta: invalid column number. in %s on line %x

BIN
test/functional/pdo_sqlsrv/pdostatement_nextRowset.phpt
View file

Binary file not shown.

60
test/functional/pdo_sqlsrv/pdostatement_setFetchMode.phpt
View file

@ -1,48 +1,32 @@
--TEST--
Test setFetchMode method.
--SKIPIF--
<?php require 'skipif.inc'; ?>
<?php require 'skipif_mid-refactor.inc'; ?>
--FILE--
<?php
require_once("MsCommon_mid-refactor.inc");
require_once("MsData_PDO_AllTypes.inc");
require_once 'MsCommon.inc';
try{
try {
$db = connect();
$stmt = $db->query("SELECT * FROM " . $table1 );
echo "Set Fetch Mode for PDO::FETCH_ASSOC \n";
$stmt->setFetchMode(PDO::FETCH_ASSOC);
$result = $stmt->fetch();
var_dump($result);
$stmt = $db->query("SELECT * FROM " . $table1 );
echo "Set Fetch Mode for PDO::FETCH_NUM \n";
$stmt->setFetchMode(PDO::FETCH_NUM);
$result = $stmt->fetch();
var_dump($result);
$stmt = $db->query("SELECT * FROM " . $table1 );
echo "Set Fetch Mode for PDO::FETCH_BOTH \n";
$stmt->setFetchMode(PDO::FETCH_BOTH);
$result = $stmt->fetch();
var_dump($result);
$stmt = $db->query("SELECT * FROM " . $table1 );
echo "Set Fetch Mode for PDO::FETCH_LAZY \n";
$stmt->setFetchMode(PDO::FETCH_LAZY);
$result = $stmt->fetch();
var_dump($result);
$stmt = $db->query("SELECT * FROM " . $table1 );
echo "Set Fetch Mode for PDO::FETCH_OBJ \n";
$stmt->setFetchMode(PDO::FETCH_OBJ);
$result = $stmt->fetch();
var_dump($result);
}
catch ( PDOException $e)
{
$tbname = "PDO_MainTypes";
createAndInsertTableMainTypes($db, $tbname);
$fetchModes = array("PDO::FETCH_ASSOC", "PDO::FETCH_NUM", "PDO::FETCH_BOTH", "PDO::FETCH_LAZY", "PDO::FETCH_OBJ");
foreach ($fetchModes as $mode) {
$stmt = $db->query("SELECT * FROM $tbname");
echo "Set Fetch Mode for $mode\n";
$stmt->setFetchMode(constant($mode));
$result = $stmt->fetch();
var_dump($result);
}
} catch (PDOException $e) {
var_dump($e);
}
?>
--EXPECT--
Set Fetch Mode for PDO::FETCH_ASSOC
Set Fetch Mode for PDO::FETCH_ASSOC
array(8) {
["IntCol"]=>
string(1) "1"
@ -61,7 +45,7 @@ array(8) {
["XmlCol"]=>
string(431) "<xml> 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>"
}
Set Fetch Mode for PDO::FETCH_NUM
Set Fetch Mode for PDO::FETCH_NUM
array(8) {
[0]=>
string(1) "1"
@ -80,7 +64,7 @@ array(8) {
[7]=>
string(431) "<xml> 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>"
}
Set Fetch Mode for PDO::FETCH_BOTH
Set Fetch Mode for PDO::FETCH_BOTH
array(16) {
["IntCol"]=>
string(1) "1"
@ -115,10 +99,10 @@ array(16) {
[7]=>
string(431) "<xml> 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>"
}
Set Fetch Mode for PDO::FETCH_LAZY
Set Fetch Mode for PDO::FETCH_LAZY
object(PDORow)#3 (9) {
["queryString"]=>
string(25) "SELECT * FROM PDO_Types_1"
string(27) "SELECT * FROM PDO_MainTypes"
["IntCol"]=>
string(1) "1"
["CharCol"]=>
@ -136,7 +120,7 @@ object(PDORow)#3 (9) {
["XmlCol"]=>
string(431) "<xml> 1 This is a really large string used to test certain large data types like xml data type. The length of this string is greater than 256 to correctly test a large data type. This is currently used by atleast varchar type and by xml type. The fetch tests are the primary consumer of this string to validate that fetch on large types work fine. The length of this string as counted in terms of number of characters is 417.</xml>"
}
Set Fetch Mode for PDO::FETCH_OBJ
Set Fetch Mode for PDO::FETCH_OBJ
object(stdClass)#5 (8) {
["IntCol"]=>
string(1) "1"

142
test/functional/sqlsrv/MsCommon.inc
View file

@ -220,16 +220,6 @@ function executeQueryEx($conn, $query, $modeDirect)
return ($stmt);
}
function createTable($conn, $tableName)
{
trace("Creating table $tableName ...");
$dataType = "[c1_int] int, [c2_tinyint] tinyint, [c3_smallint] smallint, [c4_bigint] bigint, [c5_bit] bit, [c6_float] float, [c7_real] real, [c8_decimal] decimal(28,4), [c9_numeric] numeric(32,4), [c10_money] money, [c11_smallmoney] smallmoney, [c12_char] char(512), [c13_varchar] varchar(512), [c14_varchar_max] varchar(max), [c15_nchar] nchar(512), [c16_nvarchar] nvarchar(512), [c17_nvarchar_max] nvarchar(max), [c18_text] text, [c19_ntext] ntext, [c20_binary] binary(512), [c21_varbinary] varbinary(512), [c22_varbinary_max] varbinary(max), [c23_image] image, [c24_uniqueidentifier] uniqueidentifier, [c25_datetime] datetime, [c26_smalldatetime] smalldatetime, [c27_timestamp] timestamp, [c28_xml] xml";
createTableEx($conn, $tableName, $dataType);
trace(" completed successfully.\n");
}
function createTableEx($conn, $tableName, $dataType)
{
$sql = "CREATE TABLE [$tableName] ($dataType)";
@ -288,7 +278,6 @@ function dropTable($conn, $tableName)
}
}
function selectFromTable($conn, $tableName)
{
return (selectFromTableEx($conn, $tableName, null));
@ -345,84 +334,6 @@ function numRows($conn, $tableName)
return ($rowCount);
}
function insertQueryData($tableName, $index)
{
if (UseUTF8data()) {
include_once 'MsData_UTF8.inc';
return (InsertQueryExUTF8($tableName, $index));
} else {
include_once 'MsData.inc';
return (InsertQueryEx($tableName, $index));
}
}
function insertQuery($tableName)
{
return (insertQueryData($tableName, rand(1, 20)));
}
function insertRows($conn, $tableName, $rowCount)
{
trace("Inserting $rowCount rows into $tableName ...");
$count = 0;
for ($i = 0; $i < $rowCount; $i++) {
if (insertRow($conn, $tableName)) {
$count++;
}
}
trace(" completed successfully.\n");
if ($count != $rowCount) {
die("$count rows inserted instead of $rowCount\n");
}
return ($count);
}
function insertRowsByRange($conn, $tableName, $minIndex, $maxIndex)
{
$rowCount = $maxIndex - $minIndex + 1;
if ($rowCount > 0) {
trace("Inserting $rowCount rows into $tableName ...");
for ($i = $minIndex; $i <= $maxIndex; $i++) {
insertRowByIndex($conn, $tableName, $i);
}
trace(" completed successfully.\n");
}
}
function insertRow($conn, $tableName)
{
$query = insertQuery($tableName);
$stmt = sqlsrv_query($conn, $query);
return (insertCheck($stmt));
}
function insertRowEx($conn, $tableName, $dataCols, $dataValues, $dataOptions)
{
$stmt = sqlsrv_query($conn, "INSERT INTO [$tableName] ($dataCols) VALUES ($dataValues)", $dataOptions);
return (insertCheck($stmt));
}
function insertRowByIndex($conn, $tableName, $index)
{
$query = insertQueryData($tableName, $index);
$stmt = sqlsrv_query($conn, $query);
return (insertCheck($stmt));
}
function insertStream($conn, $tableName, $dataCols, $dataValues, $dataOptions, $atExec)
{
if ($atExec) {
$stmt = sqlsrv_query($conn, "INSERT INTO [$tableName] ($dataCols) VALUES ($dataValues)", $dataOptions, array('SendStreamParamsAtExec' => 1));
} else {
$stmt = sqlsrv_query($conn, "INSERT INTO [$tableName] ($dataCols) VALUES ($dataValues)", $dataOptions);
if ($stmt) {
while (sqlsrv_send_stream_data($stmt)) {
}
}
}
return (insertCheck($stmt));
}
function insertCheck($stmt)
{
if ($stmt === false) {
@ -436,50 +347,6 @@ function insertCheck($stmt)
return (true);
}
function getInsertData($rowIndex, $colIndex, $skip)
{
$query = insertQueryData("TestTable", $rowIndex);
$data = strstr($query, "((");
$pos = 1;
if ($data === false) {
die("Failed to retrieve data on row $rowIndex");
}
$data = substr($data, 2);
while ($pos < ($colIndex - $skip)) {
$data = strstr($data, ", (");
$pos++;
if ($data === false) {
die("Failed to retrieve data on row $rowIndex, column $pos");
}
$data = substr($data, 3);
}
// Is it's XML type, we can't use the closing bracket as the next delimiter
// because a bracket can be part of the xml data, unless the data is null
$pos = strpos($data, ")");
if ($pos === false) {
die("Failed to isolate data on row $rowIndex, column $pos");
}
$tmp = substr($data, 0, $pos); // don't replace $data in case it's xml data
if (strcasecmp($tmp, "null") == 0 || strlen($tmp) == 0) { // data can actually be blank for null
$tmp = "";
} elseif (IsXml($colIndex)) {
$str = ">')"; // use the XML closing angle bracket as the delimiter
$pos = strpos($data, $str);
$tmp = substr($data, 0, $pos + 2);
}
$data = $tmp; // update $data
if (IsUnicode($colIndex)) { // N'data'
$data = substr($data, 2, strlen($data) - 3);
} elseif (IsLiteral($colIndex)) { // 'data'
$data = substr($data, 1, strlen($data) - 2);
} elseif (IsBinary($colIndex)) { // 0xdata
$data = substr($data, 2);
}
return (trim($data));
}
function createProc($conn, $procName, $procArgs, $procCode)
{
dropProc($conn, $procName);
@ -542,10 +409,14 @@ function callFunc($conn, $funcName, $funcArgs, $funcValues)
sqlsrv_free_stmt($stmt);
}
function fatalError($errorMsg)
function fatalError($errorMsg, $print = true)
{
SetUTF8Data(false);
handleErrors();
if ($print) {
printErrors();
} else {
handleErrors();
}
die($errorMsg."\n");
}
@ -554,7 +425,6 @@ function printErrors($message = "")
if (strlen($message) > 0) {
echo $message . "\n";
}
$errors = sqlsrv_errors(SQLSRV_ERR_ERRORS);
if (count($errors) == 0) {
$errors = sqlsrv_errors(SQLSRV_ERR_ALL);

149
test/functional/sqlsrv/MsData.inc
View file

File diff suppressed because one or more lines are too long

149
test/functional/sqlsrv/MsData_UTF8.inc
View file

File diff suppressed because one or more lines are too long

407
test/functional/sqlsrv/MsHelper.inc
View file

@ -28,22 +28,57 @@ const INSERT_PREPARE_PARAMS = 4;
*/
class ColumnMeta
{
public $colName;
public $dataType; // a string that includes the size of the type if necessary (e.g., decimal(10,5))
public $encType; // randomized or deterministic; default is deterministic
public $options; // a string that is null by default (e.g. NOT NULL Identity (1,1) )
public $dataType; // a string that includes the size of the type if necessary (e.g., decimal(10,5))
public $colName; // column name
public $encType; // randomized or deterministic; default is deterministic
public $options; // a string that is null by default (e.g. NOT NULL Identity (1,1) )
public function __construct($dataType, $colName = null, $options = null, $deterministic = true)
protected $encryptable; // whether Always Encrypted supports this column
public function __construct($dataType, $colName = null, $options = null, $deterministic = true, $noEncrypt = false)
{
if (is_null($colName)) {
$this->colName = getDefaultColname($dataType);
} else {
$this->colName = $colName;
}
$this->encType = ($deterministic ? "deterministic" : "randomized");
if (empty($dataType)) {
echo "Data type can not be null or empty!\n";
}
$this->dataType = $dataType;
$this->options = $options;
if (!$noEncrypt) {
$this->checkIfUnsupported();
} else {
$this->encryptable = false;
}
}
/**
* if Always Encrypted not supported for this data type set $noEncryption to false
* @return void
*/
protected function checkIfUnsupported()
{
// Always Encrypted is not supported for columns with the IDENTITY property
// or any column using one of the following datatypes:
//
// xml, timestamp, image, ntext, text, sql_variant, hierarchyid, geography, geometry, alias,
// user defined-types.
// https://docs.microsoft.com/en-us/sql/relational-databases/security/encryption/always-encrypted-database-engine
$unsupported = array("xml", "timestamp", "image", "ntext", "text", "sql_variant", "hierarchyid", "geography", "geometry", "alias");
if (stripos($this->options, "identity") !== false) {
$this->encryptable = false;
} elseif (in_array($this->dataType, $unsupported)) {
$this->encryptable = false;
} else {
$this->encryptable = true;
}
}
/**
* @return string column definition for creating a table
@ -52,8 +87,7 @@ class ColumnMeta
{
$append = " ";
// an identity column is not encrypted because a select query with identity column as the where clause is often run and the user want to have to bind parameter every time
if (isColEncrypted() && stripos($this->options, "identity") === false) {
if (isColEncrypted() && $this->encryptable) {
$cekName = getCekName();
if (stripos($this->dataType, "char") !== false) {
$append .= "COLLATE Latin1_General_BIN2 ";
@ -83,17 +117,17 @@ class BindParamOption
$this->phpType = $phpType;
$this->sqlType = $sqlType;
}
/**
* @param mix $var : variable to bind to the SQL statement parameter
* @return array needed to bind parameter in sqlsrv_prepare
*/
public function bindParamArr($var)
public function bindParamArr()
{
// get the constant values of direction, phpType, and sqlType
$direction = null;
$phpType = null;
$sqlType = null;
if ($this->direction) {
if ($this->direction) {
if (in_array($this->direction, array(SQLSRV_PARAM_IN, SQLSRV_PARAM_OUT, SQLSRV_PARAM_INOUT))) {
$direction = constant($this->direction);
} else {
@ -102,9 +136,16 @@ class BindParamOption
}
if ($this->phpType) {
try {
$phpType = constant($this->phpType);
$arr = explode("(", $this->phpType);
$type = $arr[0];
if (count($arr) > 1) {
$enc = rtrim($arr[1], ")");
$phpType = call_user_func($type, constant($enc));
} else {
$phpType = constant($this->phpType);
}
} catch (Exception $e) {
// there's something wrong with the input php type
// there's something wrong with the input php type
echo $e->getMessage();
}
}
@ -134,11 +175,11 @@ class BindParamOption
$sqlType = constant($type);
}
} catch (Exception $e) {
// there's something wrong with the input SQL type
// there's something wrong with the input SQL type
echo $e->getMessage();
}
}
return array($var, $direction, $phpType, $sqlType);
return array($this->value, $direction, $phpType, $sqlType);
}
}
@ -195,7 +236,7 @@ function getInsertSqlComplete($tbname, $inputs)
foreach ($inputs as $key => $value) {
$colStr .= $key . ", ";
if (is_null($value)) {
echo "getInsertSqlComplete: value provided for input $value is null.\n";
$valStr .= "null, ";
} elseif (is_string($value)) {
$valStr .= "'" . $value . "', ";
} else {
@ -258,7 +299,7 @@ function getSeqPlaceholders($num)
}
/**
* @return bool false if $keystore specified in MsSetup.inc is none or data not encrypted,
* @return bool false if $keystore specified in MsSetup.inc is none or data not encrypted,
* otherwise return true
*/
function isColEncrypted()
@ -307,8 +348,8 @@ function connect($options = array(), $disableCE = false)
if ($keystore == "ksp") {
require('AE_Ksp.inc');
$ksp_path = getKSPPath();
$ksp_options = array("CEKeystoreProvider"=>$ksp_path,
"CEKeystoreName"=>$ksp_name,
$ksp_options = array("CEKeystoreProvider"=>$ksp_path,
"CEKeystoreName"=>$ksp_name,
"CEKeystoreEncryptKey"=>$encrypt_key);
$connectionOptions = array_merge($connectionOptions, $ksp_options);
}
@ -322,9 +363,10 @@ function connect($options = array(), $disableCE = false)
/**
* Create a table
* @param object $conn : sqlsrv connection object
* @param resource $conn : sqlsrv connection resource
* @param string $tbname : name of the table to be created
* @param array $columnMetaArr : array of ColumnMeta objects, which contain metadata for one column
* @return resource sqlsrv statement resource
*/
function createTable($conn, $tbname, $columnMetaArr)
{
@ -336,19 +378,19 @@ function createTable($conn, $tbname, $columnMetaArr)
}
$colDef = rtrim($colDef, ", ");
$createSql = "CREATE TABLE $tbname ( $colDef )";
sqlsrv_query($conn, $createSql);
return sqlsrv_query($conn, $createSql);
}
/**
* Insert a row into a table
* @param object $conn : sqlsrv connection object
* @param resource $conn : sqlsrv connection resource
* @param string $tbname : name of the table for the row to be inserted
* @param array $inputs : an associative array column name and its value, which may be a
* @param array $inputs : an associative array column name and its value, which may be a
* literal or a BindParamOption object
* @param bool $r : true if the row was successfully inserted, otherwise false. Default value is null to make this parameter optional.
* $param string $api : SQLSRV API used for executing the insert query
* accepted values: INSERT_QUERY, INSERT_PREPARE, INSERT_QUERY_PARAMS, INSERT_PREPARE_PARAMS
* @return object sqlsrv statement object of the insert statement
* $param int $api : SQLSRV API used for executing the insert query
* accepted values: INSERT_QUERY, INSERT_PREPARE, INSERT_QUERY_PARAMS, INSERT_PREPARE_PARAMS
* @return resource sqlsrv statement resource of the insert statement
*/
function insertRow($conn, $tbname, $inputs, &$r = null, $api = INSERT_QUERY)
{
@ -361,7 +403,9 @@ function insertRow($conn, $tbname, $inputs, &$r = null, $api = INSERT_QUERY)
break;
case INSERT_PREPARE:
$stmt = sqlsrv_prepare($conn, $insertSql);
$r = sqlsrv_execute($stmt);
if ($stmt) {
$r = sqlsrv_execute($stmt);
}
break;
}
} else {
@ -370,32 +414,125 @@ function insertRow($conn, $tbname, $inputs, &$r = null, $api = INSERT_QUERY)
$params = array();
foreach ($inputs as $key => $input) {
if (is_object($input)) {
array_push($params, $input->bindParamArr($inputs[$key]));
array_push($params, $input->bindParamArr());
} else {
array_push($params, $inputs[$key]);
}
}
// use prepare for inserts when AE is enabled
if (isColEncrypted() || $api == INSERT_PREPARE_PARAMS) {
$stmt = sqlsrv_prepare($conn, $insertSql, $params);
$r = sqlsrv_execute($stmt);
if ($stmt) {
$r = sqlsrv_execute($stmt);
} else {
fatalError("insertRow: failed to prepare insert query!");
}
} else {
$stmt = sqlsrv_query($conn, $insertSql, $params);
}
}
}
return $stmt;
}
/**
* Perform a simple select from a table with or without where condition(s)
* @param resource $conn : connection resource
* @param string $tbname : name of the table
* @param string $conds : string of condition(s) with placeholders, null by default
* @param array $values : array of parameters, null by default
* @return resource sqlsrv statement upon success or false otherwise
*/
function selectFromTable($conn, $tbname, $conds = null, $values = null)
{
$sql = "SELECT * FROM $tbname";
return executeQuery($conn, $sql, $conds, $values);
}
/**
* Perform a query from a table with or without where condition(s)
* @param resource $conn : connection resource
* @param string $sql : T-SQL query
* @param string $conds : string of condition(s) possibly with placeholders, null by default
* @param array $values : array of parameters, null by default
* @return resource sqlsrv statement upon success or false otherwise
*/
function executeQuery($conn, $sql, $conds = null, $values = null)
{
if (!isColEncrypted()) {
// if not encrypted replace placeholders ('?') with values, if array not empty
if (!empty($values)) {
$tmpArray = explode('?', $conds);
$i = 0;
foreach ($values as $value) {
if (!is_numeric($value)) {
$tmpArray[$i++] .= "'$value'";
} else {
$tmpArray[$i++] .= "$value";
}
}
$clause = implode($tmpArray);
$sql = $sql . " WHERE $clause ";
} elseif (!empty($conds)) {
$sql = $sql . " WHERE $conds ";
}
$stmt = sqlsrv_query($conn, $sql);
} else {
// with AE enabled, use sqlsrv_prepare() in case there are
// fields with unlimited size
if (empty($conds) || empty($values)) {
$stmt = sqlsrv_prepare($conn, $sql);
} else {
$sql = $sql . " WHERE $conds ";
$stmt = sqlsrv_prepare($conn, $sql, $values);
}
if ($stmt) {
$r = sqlsrv_execute($stmt);
if (!$r) {
fatalError("executeQuery: failed to execute \'$sql\'!");
}
}
}
if (!$stmt) {
fatalError("executeQuery: failed to run query \'$sql\'!");
}
return $stmt;
}
/**
* Similar to executeQuery() but with query options
* @return resource sqlsrv statement upon success or false otherwise
*/
function executeQueryEx($conn, $sql, $options)
{
// when AE is enabled, use sqlsrv_prepare() to handle fields with unlimited size
if (!isColEncrypted()) {
$stmt = sqlsrv_query($conn, $sql, null, $options);
} else {
$stmt = sqlsrv_prepare($conn, $sql, null, $options);
if ($stmt) {
$r = sqlsrv_execute($stmt);
if (!$r) {
fatalError("executeQueryEx: failed to execute \'$sql\'!");
}
}
}
if (!$stmt) {
fatalError("executeQueryEx: failed to run query \'$sql\'!");
}
return $stmt;
}
/**
* Fetch all rows and all columns given a table name, and print them
* @param resource $conn : connection resource
* @param string $tbname : name of the table to fetch from
* @param string $tbname : name of the table to fetch from
*/
function fetchAll($conn, $tbname)
{
$sql = "SELECT * FROM $tbname";
$stmt = sqlsrv_query($conn, $sql);
$stmt = selectFromTable($conn, $tbname);
while ($row = sqlsrv_fetch_array($stmt, SQLSRV_FETCH_ASSOC)) {
foreach ($row as $key => $value) {
if (is_object($value)) {
@ -410,6 +547,200 @@ function fetchAll($conn, $tbname)
}
}
/**
* Create a test table with columns of various types given a table name,
* all deterministic if AE is enabled
* @param resource $conn : connection resource
* @param string $tbname : name of the table to create
* @return resource sqlsrv statement
*/
function createTestTable($conn, $tbname)
{
$columns = array(new ColumnMeta('int', 'c1_int'),
new ColumnMeta('tinyint', 'c2_tinyint'),
new ColumnMeta('smallint', 'c3_smallint'),
new ColumnMeta('bigint', 'c4_bigint'),
new ColumnMeta('bit', 'c5_bit'),
new ColumnMeta('float', 'c6_float'),
new ColumnMeta('real', 'c7_real'),
new ColumnMeta('decimal(28,4)', 'c8_decimal'),
new ColumnMeta('numeric(32,4)', 'c9_numeric'),
new ColumnMeta('money', 'c10_money', null, true, true),
new ColumnMeta('smallmoney', 'c11_smallmoney', null, true, true),
new ColumnMeta('char(512)', 'c12_char'),
new ColumnMeta('varchar(512)', 'c13_varchar'),
new ColumnMeta('varchar(max)', 'c14_varchar_max'),
new ColumnMeta('nchar(512)', 'c15_nchar'),
new ColumnMeta('nvarchar(512)', 'c16_nvarchar'),
new ColumnMeta('nvarchar(max)', 'c17_nvarchar_max'),
new ColumnMeta('text', 'c18_text'),
new ColumnMeta('ntext', 'c19_ntext'),
new ColumnMeta('binary(512)', 'c20_binary'),
new ColumnMeta('varbinary(512)', 'c21_varbinary'),
new ColumnMeta('varbinary(max)', 'c22_varbinary_max'),
new ColumnMeta('image', 'c23_image'),
new ColumnMeta('uniqueidentifier', 'c24_uniqueidentifier'),
new ColumnMeta('datetime', 'c25_datetime'),
new ColumnMeta('smalldatetime', 'c26_smalldatetime'),
new ColumnMeta('timestamp', 'c27_timestamp'),
new ColumnMeta('xml', 'c28_xml'),
);
return createTable($conn, $tbname, $columns);
}
/**
* Insert the specified number of rows with test data into the test table
* @param resource $conn : connection resource
* @param string $tbname : name of the table to create
* @param int $rowCount : number of test rows to be inserted
* @return number of rows inserted
*/
function insertTestRows($conn, $tbame, $rowCount)
{
$count = 0;
for ($i = 0; $i < $rowCount; $i++) {
if (insertTestRow($conn, $tbame, rand(1, 20))) {
$count++;
}
}
if ($count != $rowCount) {
die("$count rows inserted instead of $rowCount\n");
}
return ($count);
}
/**
* Insert a number of rows with test data into the test table given the indexes
* @param resource $conn : connection resource
* @param string $tbname : name of the table to create
* @param int $minIndex : index of the first row to be inserted
* @param int $maxIndex : index of the last row to be inserted
* @return number of rows inserted
*/
function insertTestRowsByRange($conn, $tbame, $minIndex, $maxIndex)
{
$count = 0;
$rowCount = $maxIndex - $minIndex + 1;
if ($rowCount > 0) {
for ($i = $minIndex; $i <= $maxIndex; $i++) {
if (insertTestRow($conn, $tbame, $i)) {
$count++;
}
}
}
if ($count != $rowCount) {
die("$count rows inserted instead of $rowCount\n");
}
return ($count);
}
/**
* Insert one or more specific rows of test data into the test table
* @param resource $conn : connection resource
* @param string $tbname : name of the table to create
* @param int $index : the index of a certain row of test data
* @return resource sqlsrv statement upon success or false otherwise
*/
function insertTestRow($conn, $tbname, $index)
{
if ($index < 1 || $index > 20) {
echo("Invalid row index $index for test data!\n");
return false;
}
// get array of input values
$inputArray = getInsertArray($index);
if (empty($inputArray)) {
fatalError("getInsertSqlComplete: inputs for inserting a row cannot be empty");
}
$result = null;
if (isColEncrypted()) {
$stmt = insertRow($conn, $tbname, $inputArray, $result);
} else {
// do not use the generic insertRow as the binary data needs some pre-processing
// before calling sqlsrv_query()
$colStr = "INSERT INTO $tbname (";
$valStr = "VALUES (";
$col = 1;
foreach ($inputArray as $key => $value) {
$colStr .= $key . ", ";
if (is_array($value)) {
$value = $value[0];
// this might be an input to a decimal, a numeric or a binary field
if (isBinary($col)) {
$value = "0x" . $value; // annotate the input string as a hex string
}
}
if (is_null($value)) {
$valStr .= "null, ";
} elseif (is_string($value) && !isBinary($col)) {
$valStr .= "'" . $value . "', ";
} else {
$valStr .= $value . ", ";
}
$col++;
}
$colStr = rtrim($colStr, ", ") . ") ";
$valStr = rtrim($valStr, ", ") . ") ";
$insertSql = $colStr . $valStr;
$stmt = sqlsrv_query($conn, $insertSql);
}
if (!$stmt || $result === false) {
fatalError("insertTestRow: failed to insert row $index!\n");
}
return $stmt;
}
/**
* Get a row of data to be inserted into the test table
* @param int $index : the index of a certain row of test data
* @return an array of key-value pairs
*/
function getInsertArray($index)
{
if (! UseUTF8data()) {
require_once('MsData.inc');
} else {
require_once('MsData_UTF8.inc');
}
// get array of input values
return getTestData($index);
}
/**
* Get test data based on the row and column
* @param int $rowIndex : the row index
* @param int $colIndex : the column index
* @return data of mixed type or null if something went wrong
*/
function getInsertData($rowIndex, $colIndex)
{
// get array of input values
$inputArray = getInsertArray($rowIndex);
if (empty($inputArray)) {
fatalError("getInsertData: failed to retrieve data at row $rowIndex.\n");
}
$count = 0;
foreach ($inputArray as $key => $value) {
if (++$count == $colIndex) {
if (is_array($value)) {
return $value[0];
} else {
return $value;
}
break;
}
}
return null;
}
} // end of namespace AlwaysEncrypted
namespace {
@ -449,7 +780,7 @@ function getSqlType($k)
return ("udt");
}
function getDriverType($k, $dataSize)
function getSqlsrvSqlType($k, $dataSize)
{
switch ($k) {
case 1: return (SQLSRV_SQLTYPE_INT);
@ -497,7 +828,7 @@ function isXml($k)
function isStreamable($k)
{
switch ($k) {
case 12: return (true); // nchar(512)
case 12: return (true); // char(512)
case 13: return (true); // varchar(512)
case 14: return (true); // varchar(max)
case 15: return (true); // nchar(512)
@ -666,7 +997,9 @@ function getColName($k)
case 26: return ("c26_smalldatetime");
case 27: return ("c27_timestamp");
case 28: return ("c28_xml");
default: break;
default:
fatalError("Invalid column index $k");
break;
}
return ("");
}

4
test/functional/sqlsrv/TC11_Info.phpt
View file

@ -8,7 +8,7 @@ PHPT_EXEC=true
<?php
require_once('MsCommon.inc');
function Info()
function info()
{
ob_start();
phpinfo();
@ -21,7 +21,7 @@ function Info()
$testName = "Driver Loading";
startTest($testName);
preg_match('/sqlsrv support.*/', Info(), $matches);
preg_match('/sqlsrv support.*/', info(), $matches);
var_dump($matches);
endTest($testName);

21
test/functional/sqlsrv/TC21_Connection.phpt
View file

@ -6,12 +6,12 @@ Verifies as well that invalid connection attempts fail as expected.
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
function ConnectionTest()
function connectionTest()
{
$testName = "Connection";
startTest($testName);
@ -37,21 +37,12 @@ function ConnectionTest()
endTest($testName);
}
//--------------------------------------------------------------------
// repro
//
//--------------------------------------------------------------------
function repro()
{
try {
ConnectionTest();
} catch (Exception $e) {
echo $e->getMessage();
}
try {
connectionTest();
} catch (Exception $e) {
echo $e->getMessage();
}
repro();
?>
--EXPECT--
Test "Connection" completed successfully.

12
test/functional/sqlsrv/TC22_ClientInfo.phpt
View file

@ -5,7 +5,7 @@ Verifies the functionality of "sqlsrv_client_info".
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
@ -24,14 +24,7 @@ function clientInfo()
die("Unexpected size for client_info array: ".$count1);
}
$driverName = 'DriverDllName';
$uname = php_uname();
if (isWindows()) {
$driverName = 'DriverDllName';
} else { // other than Windows
$driverName = 'DriverName';
}
$driverName = isWindows() ? 'DriverDllName' : 'DriverName';
showInfo($clientinfo1, 'ExtensionVer');
showInfo($clientinfo1, $driverName);
@ -49,7 +42,6 @@ function showInfo($clientInfo, $infoTag)
trace("$infoTag\t= $info\n");
}
try {
clientInfo();
} catch (Exception $e) {

2
test/functional/sqlsrv/TC23_ServerInfo.phpt
View file

@ -5,7 +5,7 @@ Verifies the functionality of "sqlsrv_server_info".
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');

51
test/functional/sqlsrv/TC24_Close.phpt
View file

@ -6,24 +6,22 @@ that resources are invalidated when connection is closed.
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
function ConnectionClose()
function connectionClose()
{
$testName = "Connection - Close";
startTest($testName);
setup();
$noRows = 5;
$conn1 = connect();
$tableName = 'TC24test';
$conn1 = AE\connect();
$tableName = 'TC24test';
createTable($conn1, $tableName);
insertRows($conn1, $tableName, $noRows);
// Insert some random rows
AE\createTestTable($conn1, $tableName);
AE\insertTestRows($conn1, $tableName, 5);
// Close connection twice
for ($i = 0; $i < 2; $i++) {
@ -40,43 +38,32 @@ function ConnectionClose()
}
// Invalid Statement
$conn2 = connect();
$stmt2 = selectFromTable($conn2, $tableName);
$conn2 = AE\connect();
$stmt2 = AE\selectFromTable($conn2, $tableName);
sqlsrv_close($conn2);
if (sqlsrv_fetch($stmt2)) {
die("Fetch should fail when connection is closed");
}
$conn3 = connect();
dropTable($conn3, $tableName);
sqlsrv_close($conn3);
$conn3 = AE\connect();
dropTable($conn3, $tableName);
sqlsrv_close($conn3);
endTest($testName);
}
//--------------------------------------------------------------------
// repro
//
//--------------------------------------------------------------------
function repro()
{
try {
ConnectionClose();
} catch (Exception $e) {
echo $e->getMessage();
}
try {
connectionClose();
} catch (Exception $e) {
echo $e->getMessage();
}
repro();
?>
--EXPECTREGEX--
Warning: sqlsrv_close\(\): supplied resource is not a valid ss_sqlsrv_conn resource in .*TC24_Close.php on line 20
Warning: sqlsrv_close\(\): supplied resource is not a valid ss_sqlsrv_conn resource in .*TC24_Close.php on line 18
Warning: sqlsrv_query\(\): supplied resource is not a valid ss_sqlsrv_conn resource in .*TC24_Close.php on line 27
Warning: sqlsrv_query\(\): supplied resource is not a valid ss_sqlsrv_conn resource in .*TC24_Close.php on line 25
Warning: sqlsrv_fetch\(\): supplied resource is not a valid ss_sqlsrv_stmt resource in .*TC24_Close.php on line 36
Warning: sqlsrv_fetch\(\): supplied resource is not a valid ss_sqlsrv_stmt resource in .*TC24_Close.php on line 34
Test "Connection - Close" completed successfully.

35
test/functional/sqlsrv/TC31_SimpleQuery.phpt
View file

@ -9,13 +9,13 @@ Basic verification of query statements (via "sqlsrv_query"):
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
function SimpleQuery()
function simpleQuery()
{
$testName = "Statement - Simple Query";
startTest($testName);
@ -23,44 +23,35 @@ function SimpleQuery()
setup();
$tableName = 'TC31test';
$conn1 = connect();
$conn1 = AE\connect();
createTable($conn1, $tableName);
// just create an empty table
$columns = array(new AE\ColumnMeta('int', 'dummyColumn'));
AE\createTable($conn1, $tableName, $columns);
trace("Executing SELECT query on $tableName ...");
$stmt1 = selectFromTable($conn1, $tableName);
$stmt1 = AE\selectFromTable($conn1, $tableName);
$rows = rowCount($stmt1);
;
sqlsrv_free_stmt($stmt1);
trace(" $rows rows retrieved.\n");
dropTable($conn1, $tableName);
if ($rows > 0) {
die("Table $tableName, expected to be empty, has $rows rows.");
}
dropTable($conn1, $tableName);
sqlsrv_close($conn1);
endTest($testName);
}
//--------------------------------------------------------------------
// repro
//
//--------------------------------------------------------------------
function repro()
{
try {
SimpleQuery();
} catch (Exception $e) {
echo $e->getMessage();
}
try {
simpleQuery();
} catch (Exception $e) {
echo $e->getMessage();
}
repro();
?>
--EXPECT--
Test "Statement - Simple Query" completed successfully.

42
test/functional/sqlsrv/TC32_DeleteQuery.phpt
View file

@ -6,30 +6,31 @@ validates the outcome reported by "sqlsrv_rows_affected".
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
function DeleteQuery()
function deleteQuery()
{
$testName = "Statement - Delete Query";
startTest($testName);
setup();
$conn1 = connect();
$conn1 = AE\connect();
$noRows = 10;
$tableName = 'TC32test';
createTable($conn1, $tableName);
$noRowsInserted = insertRows($conn1, $tableName, $noRows);
AE\createTestTable($conn1, $tableName);
// Insert some random rows
$noRowsInserted = AE\insertTestRows($conn1, $tableName, $noRows);
$row = 1;
$keyValue = "0";
while ($row <= $noRowsInserted) {
$stmt1 = selectFromTable($conn1, $tableName);
$stmt1 = AE\selectFromTable($conn1, $tableName);
if (sqlsrv_fetch($stmt1) === false) {
fatalError("Failed to retrieve 1st row of data from test table");
fatalError("Failed to retrieve 1st row of data from test table", true);
}
$keyValue = sqlsrv_get_field($stmt1, 0, SQLSRV_PHPTYPE_STRING(SQLSRV_ENC_CHAR));
sqlsrv_free_stmt($stmt1);
@ -37,16 +38,16 @@ function DeleteQuery()
trace("Deleting rows from $tableName ...");
$delRows = 1;
if (strlen($keyValue) == 0) {
$stmt2 = executeQuery($conn1, "DELETE TOP(1) FROM [$tableName]");
$stmt2 = AE\executeQuery($conn1, "DELETE TOP(1) FROM [$tableName]");
$cond = "(top row)";
} else {
$cond = "(c1_int = $keyValue)";
$stmt3 = selectFromTableEx($conn1, $tableName, $cond);
$cond = "(c1_int = ?)";
$params = array($keyValue);
$stmt3 = AE\selectFromTable($conn1, $tableName, $cond, $params);
$delRows = rowCount($stmt3);
sqlsrv_free_stmt($stmt3);
$stmt2 = executeQuery($conn1, "DELETE FROM [$tableName] WHERE $cond");
$stmt2 = AE\executeQuery($conn1, "DELETE FROM [$tableName]", $cond, $params );
}
$numRows1 = sqlsrv_rows_affected($stmt2);
sqlsrv_free_stmt($stmt2);
@ -73,21 +74,12 @@ function DeleteQuery()
endTest($testName);
}
//--------------------------------------------------------------------
// repro
//
//--------------------------------------------------------------------
function repro()
{
try {
DeleteQuery();
} catch (Exception $e) {
echo $e->getMessage();
}
try {
deleteQuery();
} catch (Exception $e) {
echo $e->getMessage();
}
repro();
?>
--EXPECT--
Test "Statement - Delete Query" completed successfully.

140
test/functional/sqlsrv/TC33_ComplexQuery.phpt
View file

@ -5,85 +5,129 @@ Verifies the behavior of INSERT queries with and without the IDENTITY flag set.
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
function ComplexQuery()
function complexQuery()
{
$testName = "Statement - Complex Query";
startTest($testName);
setup();
$conn1 = connect();
$conn1 = AE\connect();
$tableName = 'TC33test';
$dataTypes = "[c1_int] int IDENTITY, [c2_tinyint] tinyint, [c3_smallint] smallint, [c4_bigint] bigint, [c5_varchar] varchar(512)";
createTableEx($conn1, $tableName, $dataTypes);
$columns = array(new AE\ColumnMeta('int', 'c1_int', "IDENTITY"),
new AE\ColumnMeta('tinyint', 'c2_tinyint'),
new AE\ColumnMeta('smallint', 'c3_smallint'),
new AE\ColumnMeta('bigint', 'c4_bigint'),
new AE\ColumnMeta('varchar(512)', 'c5_varchar'));
AE\createTable($conn1, $tableName, $columns);
Execute($conn1, true, "SET IDENTITY_INSERT [$tableName] ON;");
Execute($conn1, true, "INSERT INTO [$tableName] (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_varchar) VALUES (-204401468, 168, 4787, 1583186637, 'î<ÄäC~zããa.Oa._ߣ*©<u_ßßCÃoa äãäÐßa+OühäobUa:zB_CÖ@~UÄz+ÃîÐ//Z@üo_:r,o¢ÃrßzoZß*ߪªå~ U¢a>£ÃZUÄ/ä_ZãðäåhüCã+/.obî|ößß,ð¢ðð:ÄÐ:*/>+/¢aö.öÄ<ð:>äO~*~ßÄzå¢<ª£ðý.O,>Ü,åbü@böhýC*<<hbÖä*o©¢h¢Ðüa+A/_@b/ÃBýBªß@ã~zÖZýC@äU_ßUßhvU*a@ÃðÄ:ªZAßAb£U_¢ßbãä:üåãorýÃߪ_ãÐÖªzãðåãoaü <ß~zZªaB.+åA¢ãÖ><î:/Ur î¢UßåOaÄ:a|++ª©.r~:/+ä|©ýo++v_@BZ:©©AßCð.©/Ab<,îß>UãÜÜöbb|ßÐߣ:î<<bîöa+,<_aÄ._ª>Ü<|ÖzÃz@>¢ª:a,CÜr__ª.<öÜCã+UÖU¢_üzü bÃ~ßo|, .î,b/U>äýaBZ@Ü£: bÖvýb>Ã/ÜÃ@üÖ/äb¢+r:Zß>ÐÜ|üu©ßZAC:Cßh *.ã£_ýîu|Urå.:aAUv@u>@<Öü.<ãZ böZAÜÖ£oüÐä*,ü:ðä')");
Execute($conn1, true, "SET IDENTITY_INSERT [$tableName] OFF;");
Execute($conn1, false,"INSERT INTO [$tableName] (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_varchar) VALUES (1264768176, 111, 23449, 1421472052, 'uå©C@bðUOv~,©v,BZÜ*oh>zb_åÐä<@*OOå_Ö<ãuß/oßr <ðãbÜUßÜÃÖÄ~¢~£ bÜ©î.uÜТª:|_ÐüÄBÐbüåßÃv@,<CßOäv~:+,CZîvhC/oßUuößa<å>©/Ub,+AЩî:ÖrýB+~~ßßßãÜ+_<vO@ ßÃüÖîaCzÐîå@:rý.~vh~r.ÃbÃã©å_îCär BÖÜ:BbUväåöZ+|,CîaAöC,aîbb*UÜßßA hCu¢hOb ð|ßC.<C<.aBßvuÃÖå,AÐa>ABðöU/O<ÖãüªOãuߣ~uÖ+ßÄrbî/:ÖÖo /_ÃO:uÃzðUvã£Aã_BÐ/>UCr,Äå aÄÐaãvÖZ@ªr*_::~/+.å~ð©aÄßbz*z<~rU~O+Z|A<_Büß©¢ö ::.Übýüßr/örh¢:ääU äOA~Aîr<¢äv¢Ä+hC/vßoUª+Oãªã*ð¢Bö.Zbh/ä,åä>*öðßUßý>aªbBbvßãÖ/bã|ýÖ u.zý©~äðzÐU.UA*a*.¢>î rß ~Cüßaö+rª~ß@aã/ÐCß*a,ªÄbb<o+v.åu<£B<îBZßåu£/_>*~')");
Execute($conn1, true, "SET IDENTITY_INSERT [$tableName] ON;INSERT INTO [$tableName] (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_varchar) VALUES (-411114769, 198, 1378, 140345831, 'Ü@ßaörêA*ÐüßA>_hOüv@|h~O<¢+*ÃÐCbazÜaåZ/Öö:ýãuöÐaz£ÐAh+u+rß:| U*¢ªåßÄÐ_vî@@~ChÐö_å*AAýBö¢B,ßbßå.ÃB+u*CAvÜ,ã>ªßCU<åî©ürz¢@ör¢*Öub¢BåaÜ@ª.äBv¢o~ ßýo oîu/>ÜÐÄ,ð,ðaOÖå>ðC:öZ>ßåð©<ð¢+£r.bO.©,uAßr><ov:,ÄßîåÃ+å./||CUÜÜ_ÖĪh~<ã_å/hbý Ä©uBuß<Ö@boÖýBãCÜA/öÄ:© ßUü*ývuß.Bãååo_übýr_üß>ÐÃÜ£B¢AªvaîvýßCÜUß åvöuª><îÐUC*aÖU©rªhr+>|äýî|oðröУ<ª<Ö|AªohäAî_vu~:~£Ãhü+ÃBuÄð ü@Z+Ä@hÖî¢|@bU£_ü/£ |:¢zb>@Uß© Ãão Ö@ãÐBã_öBOBÄÐhCÜb~Ö>îü rýåüUzuãrbzß/ªîUÐð©uå.ß@£__vBb©/Ür¢Öuåz£ä*å£/*ÃO');SET IDENTITY_INSERT [$tableName] OFF;");
// SET IDENTITY_INSERT ON/OFF only works at execute or run time and not at parse time
// because a prepared statement runs in a separate context
// https://technet.microsoft.com/en-us/library/ms188059(v=sql.110).aspx
$query = "SET IDENTITY_INSERT [$tableName] ON;";
$stmt = sqlsrv_query($conn1, $query);
if (!$stmt) {
die("Unexpected execution outcome for \'$query\'.");
}
// expect this to pass
$inputs = array("c1_int" => -204401468, "c2_tinyint" => 168, "c3_smallint" => 4787, "c4_bigint" =>1583186637, "c5_varchar" => "î<ÄäC~zããa.Oa._ߣ*©<u_ßßCÃoa äãäÐßa+OühäobUa:zB_CÖ@~UÄz+ÃîÐ//Z@üo_:r,o¢ÃrßzoZß*ߪªå~ U¢a>£ÃZUÄ/ä_ZãðäåhüCã+/.obî|ößß,ð¢ðð:ÄÐ:*/>+/¢aö.öÄ<ð:>äO~*~ßÄzå¢<ª£ðý.O,>Ü,åbü@böhýC*<<hbÖä*o©¢h¢Ðüa+A/_@b/ÃBýBªß@ã~zÖZýC@äU_ßUßhvU*a@ÃðÄ:ªZAßAb£U_¢ßbãä:üåãorýÃߪ_ãÐÖªzãðåãoaü <ß~zZªaB.+åA¢ãÖ><î:/Ur î¢UßåOaÄ:a|++ª©.r~:/+ä|©ýo++v_@BZ:©©AßCð.©/Ab<,îß>UãÜÜöbb|ßÐߣ:î<<bîöa+,<_aÄ._ª>Ü<|ÖzÃz@>¢ª:a,CÜr__ª.<öÜCã+UÖU¢_üzü bÃ~ßo|, .î,b/U>äýaBZ@Ü£: bÖvýb>Ã/ÜÃ@üÖ/äb¢+r:Zß>ÐÜ|üu©ßZAC:Cßh *.ã£_ýîu|Urå.:aAUv@u>@<Öü.<ãZ böZAÜÖ£oüÐä*,ü:ðä");
$stmt = insertTest($conn1, $tableName, true, $inputs);
$query = "SET IDENTITY_INSERT [$tableName] OFF;";
$stmt = sqlsrv_query($conn1, $query);
if (!$stmt) {
die("Unexpected execution outcome for \'$query\'.");
}
// expect this to fail
$inputs = array("c1_int" => 1264768176, "c2_tinyint" => 111, "c3_smallint" => 23449, "c4_bigint" =>1421472052, "c5_varchar" => "uå©C@bðUOv~,©v,BZÜ*oh>zb_åÐä<@*OOå_Ö<ãuß/oßr <ðãbÜUßÜÃÖÄ~¢~£ bÜ©î.uÜТª:|_ÐüÄBÐbüåßÃv@,<CßOäv~:+,CZîvhC/oßUuößa<å>©/Ub,+AЩî:ÖrýB+~~ßßßãÜ+_<vO@ ßÃüÖîaCzÐîå@:rý.~vh~r.ÃbÃã©å_îCär BÖÜ:BbUväåöZ+|,CîaAöC,aîbb*UÜßßA hCu¢hOb ð|ßC.<C<.aBßvuÃÖå,AÐa>ABðöU/O<ÖãüªOãuߣ~uÖ+ßÄrbî/:ÖÖo /_ÃO:uÃzðUvã£Aã_BÐ/>UCr,Äå aÄÐaãvÖZ@ªr*_::~/+.å~ð©aÄßbz*z<~rU~O+Z|A<_Büß©¢ö ::.Übýüßr/örh¢:ääU äOA~Aîr<¢äv¢Ä+hC/vßoUª+Oãªã*ð¢Bö.Zbh/ä,åä>*öðßUßý>aªbBbvßãÖ/bã|ýÖ u.zý©~äðzÐU.UA*a*.¢>î rß ~Cüßaö+rª~ß@aã/ÐCß*a,ªÄbb<o+v.åu<£B<îBZßåu£/_>*~");
$stmt = insertTest($conn1, $tableName, false, $inputs);
// expect this to pass
$query = "SET IDENTITY_INSERT [$tableName] ON; SQL; SET IDENTITY_INSERT [$tableName] OFF;";
if (AE\isColEncrypted()){
// When AE is enabled, SQL types must be specified for sqlsrv_query
$inputs = array("c1_int" => array(-411114769, null, null, SQLSRV_SQLTYPE_INT),
"c2_tinyint" => array(198, null, null, SQLSRV_SQLTYPE_TINYINT),
"c3_smallint" => array(1378, null, null, SQLSRV_SQLTYPE_SMALLINT),
"c4_bigint" => array(140345831, null, null, SQLSRV_SQLTYPE_BIGINT),
"c5_varchar" => array("Ü@ßaörêA*ÐüßA>_hOüv@|h~O<¢+*ÃÐCbazÜaåZ/Öö:ýãuöÐaz£ÐAh+u+rß:| U*¢ªåßÄÐ_vî@@~ChÐö_å*AAýBö¢B,ßbßå.ÃB+u*CAvÜ,ã>ªßCU<åî©ürz¢@ör¢*Öub¢BåaÜ@ª.äBv¢o~ ßýo oîu/>ÜÐÄ,ð,ðaOÖå>ðC:öZ>ßåð©<ð¢+£r.bO.©,uAßr><ov:,ÄßîåÃ+å./||CUÜÜ_ÖĪh~<ã_å/hbý Ä©uBuß<Ö@boÖýBãCÜA/öÄ:© ßUü*ývuß.Bãååo_übýr_üß>ÐÃÜ£B¢AªvaîvýßCÜUß åvöuª><îÐUC*aÖU©rªhr+>|äýî|oðröУ<ª<Ö|AªohäAî_vu~:~£Ãhü+ÃBuÄð ü@Z+Ä@hÖî¢|@bU£_ü/£ |:¢zb>@Uß© Ãão Ö@ãÐBã_öBOBÄÐhCÜb~Ö>îü rýåüUzuãrbzß/ªîUÐð©uå.ß@£__vBb©/Ür¢Öuåz£ä*å£/*ÃO", null, null, SQLSRV_SQLTYPE_VARCHAR(512)));
$stmt = insertTest($conn1, $tableName, true, $inputs, $query);
} else {
$inputs = array("c1_int" => -411114769, "c2_tinyint" => 198, "c3_smallint" => 1378, "c4_bigint" => 140345831, "c5_varchar" => "Ü@ßaörêA*ÐüßA>_hOüv@|h~O<¢+*ÃÐCbazÜaåZ/Öö:ýãuöÐaz£ÐAh+u+rß:| U*¢ªåßÄÐ_vî@@~ChÐö_å*AAýBö¢B,ßbßå.ÃB+u*CAvÜ,ã>ªßCU<åî©ürz¢@ör¢*Öub¢BåaÜ@ª.äBv¢o~ ßýo oîu/>ÜÐÄ,ð,ðaOÖå>ðC:öZ>ßåð©<ð¢+£r.bO.©,uAßr><ov:,ÄßîåÃ+å./||CUÜÜ_ÖĪh~<ã_å/hbý Ä©uBuß<Ö@boÖýBãCÜA/öÄ:© ßUü*ývuß.Bãååo_übýr_üß>ÐÃÜ£B¢AªvaîvýßCÜUß åvöuª><îÐUC*aÖU©rªhr+>|äýî|oðröУ<ª<Ö|AªohäAî_vu~:~£Ãhü+ÃBuÄð ü@Z+Ä@hÖî¢|@bU£_ü/£ |:¢zb>@Uß© Ãão Ö@ãÐBã_öBOBÄÐhCÜb~Ö>îü rýåüUzuãrbzß/ªîUÐð©uå.ß@£__vBb©/Ür¢Öuåz£ä*å£/*ÃO");
$stmt = insertTest($conn1, $tableName, true, $inputs, $query);
}
$stmt1 = selectFromTable($conn1, $tableName);
$rowCount = rowCount($stmt1);
sqlsrv_free_stmt($stmt1);
if ($rowCount != 2)
{
if ($rowCount != 2) {
die("Table $tableName has $rowCount rows instead of 2.");
}
dropTable($conn1, $tableName);
dropTable($conn1, $tableName);
sqlsrv_close($conn1);
endTest($testName);
}
function Execute($conn, $expectedOutcome, $query)
function insertTest($conn, $tableName, $expectedOutcome, $inputs, $query = null)
{
trace("Executing query ".ltrim(substr($query, 0, 40))." ... ");
$stmt = ExecuteQueryEx($conn, $query, true);
if ($stmt === false)
{
trace("failed.\n");
$actualOutcome = false;
$stmt = null;
if (!AE\isColEncrypted()) {
$insertSql = AE\getInsertSqlComplete($tableName, $inputs);
if (! is_null($query)) {
$sql = str_replace("SQL", $insertSql, $query);
} else {
$sql = $insertSql;
}
$stmt = sqlsrv_query($conn, $sql);
$actualOutcome = ($stmt !== false);
} else {
// must bind parameters
$insertSql = AE\getInsertSqlPlaceholders($tableName, $inputs);
$params = array();
foreach ($inputs as $key => $input) {
array_push($params, $inputs[$key]);
}
if (! is_null($query)) {
// this contains a batch of sql statements,
// with set identity_insert on or off
// thus, sqlsrv_query should be called
$sql = str_replace("SQL", $insertSql, $query);
$stmt = sqlsrv_query($conn, $sql, $params);
$actualOutcome = ($stmt !== false);
} else {
// just a regular insert, so use sqlsrv_prepare
$sql = $insertSql;
$actualOutcome = true;
$stmt = sqlsrv_prepare($conn, $sql, $params);
if ($stmt) {
$result = sqlsrv_execute($stmt);
$actualOutcome = ($result !== false);
}
}
}
else
{
trace("succeeded.\n");
sqlsrv_free_stmt($stmt);
$actualOutcome = true;
}
if ($actualOutcome != $expectedOutcome)
{
die("Unexpected query execution outcome.");
if ($actualOutcome != $expectedOutcome) {
die("Unexpected execution outcome for \'$sql\'.");
}
}
//--------------------------------------------------------------------
// repro
//
//--------------------------------------------------------------------
function repro()
{
try
{
ComplexQuery();
}
catch (Exception $e)
{
echo $e->getMessage();
}
try {
complexQuery();
} catch (Exception $e) {
echo $e->getMessage();
}
repro();
?>
--EXPECT--
Test "Statement - Complex Query" completed successfully.

13
test/functional/sqlsrv/TC34_PrepAndExec.phpt
View file

@ -6,7 +6,7 @@ Validates that a prepared statement can be successfully executed more than once.
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
@ -17,19 +17,18 @@ function prepareAndExecute($noPasses)
startTest($testName);
setup();
$conn1 = connect();
$conn1 = AE\connect();
$tableName = 'TC34test';
createTable($conn1, $tableName);
insertRows($conn1, $tableName, 1);
AE\createTestTable($conn1, $tableName);
AE\insertTestRows($conn1, $tableName, 1);
$values = array();
$fieldlVal = "";
// Prepare reference values
trace("Execute a direct SELECT query on $tableName ...");
$stmt1 = selectFromTable($conn1, $tableName);
$stmt1 = AE\selectFromTable($conn1, $tableName);
$numFields1 = sqlsrv_num_fields($stmt1);
sqlsrv_fetch($stmt1);
for ($i = 0; $i < $numFields1; $i++) {
@ -39,7 +38,7 @@ function prepareAndExecute($noPasses)
$fieldVal = sqlsrv_get_field($stmt1, $i, SQLSRV_PHPTYPE_STRING(SQLSRV_ENC_CHAR));
}
if ($fieldVal === false) {
fatalError("Failed to retrieve field $i");
fatalError("Failed to retrieve field $i", true);
}
$values[$i] = $fieldVal;
}

10
test/functional/sqlsrv/TC35_Cancel.phpt
View file

@ -5,7 +5,7 @@ Verifies that "sqlsrv_cancel" discards any pending data in current result set
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
@ -16,14 +16,14 @@ function cancel()
startTest($testName);
setup();
$conn1 = connect();
$conn1 = AE\connect();
$tableName = 'TC35test';
createTable($conn1, $tableName);
insertRows($conn1, $tableName, 5);
AE\createTestTable($conn1, $tableName);
AE\insertTestRows($conn1, $tableName, 5);
trace("Executing SELECT query on $tableName ...");
$stmt1 = selectFromTable($conn1, $tableName);
$stmt1 = AE\selectFromTable($conn1, $tableName);
if (sqlsrv_fetch($stmt1) === false) {
fatalError("Failed to retrieve data from test table");
}

27
test/functional/sqlsrv/TC36_Close.phpt
View file

@ -7,24 +7,24 @@ Validates that a closed statement cannot be reused.
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
function Close()
function close()
{
$testName = "Statement - Close";
startTest($testName);
setup();
$conn1 = connect();
$conn1 = AE\connect();
$tableName = 'TC36test';
createTable($conn1, $tableName);
AE\createTestTable($conn1, $tableName);
trace("Executing SELECT query on $tableName ...");
$stmt1 = selectFromTable($conn1, $tableName);
$stmt1 = AE\selectFromTable($conn1, $tableName);
trace(" successfull.\n");
sqlsrv_free_stmt($stmt1);
@ -48,21 +48,12 @@ function Close()
endTest($testName);
}
//--------------------------------------------------------------------
// repro
//
//--------------------------------------------------------------------
function repro()
{
try {
Close();
} catch (Exception $e) {
echo $e->getMessage();
}
try {
close();
} catch (Exception $e) {
echo $e->getMessage();
}
repro();
?>
--EXPECTREGEX--

6
test/functional/sqlsrv/TC37_QueryTimeout.phpt
View file

@ -9,7 +9,7 @@ longer than the query timeout.
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
@ -20,9 +20,9 @@ function queryTimeout()
startTest($testName);
setup();
$conn1 = connect();
$conn1 = AE\connect();
$tableName = 'TC37test';
createTable($conn1, $tableName);
AE\createTestTable($conn1, $tableName);
trace("Executing batch queries requiring 3 seconds with 1 second timeout.\n");
$query = "WAITFOR DELAY '00:00:03'; SELECT * FROM [$tableName]";

18
test/functional/sqlsrv/TC38_InvalidQuery.phpt
View file

@ -5,7 +5,7 @@ Verifies of "sqlsrv_query" response to invalid query attempts
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
@ -16,7 +16,7 @@ function invalidQuery()
startTest($testName);
setup();
$conn1 = connect();
$conn1 = AE\connect();
// Invalid Query
$stmt1 = sqlsrv_query($conn1, "INVALID QUERY");
@ -24,15 +24,16 @@ function invalidQuery()
die("Invalid query should have failed.");
}
$dataType = "[c1] int, [c2] int";
$tableName = 'TC38test';
createTableEx($conn1, $tableName, $dataType);
$columns = array(new AE\ColumnMeta('int', 'c1'),
new AE\ColumnMeta('int', 'c2'));
AE\createTable($conn1, $tableName, $columns);
// Invalid PHPTYPE parameter
$stmt2 = sqlsrv_query(
$conn1,
"INSERT INTO [$tableName] (c1, c2) VALUES (?, ?)",
array(1, array(2, SQLSRV_PARAM_IN, 'SQLSRV_PHPTYPE_UNKNOWN'))
array(1, array(2, SQLSRV_PARAM_IN, 'SQLSRV_PHPTYPE_UNKNOWN'))
);
if ($stmt2) {
die("Insert query with invalid parameter should have failed.");
@ -41,9 +42,7 @@ function invalidQuery()
// Invalid option
$stmt3 = sqlsrv_query(
$conn1,
"INSERT INTO [$tableName] (c1, c2) VALUES (?, ?)",
array(1, 2),
array('doSomething' => 1)
"INSERT INTO [$tableName] (c1, c2) VALUES (?, ?)", array(1, 2), array('doSomething' => 1)
);
if ($stmt3) {
die("Insert query with invalid option should have failed.");
@ -55,7 +54,6 @@ function invalidQuery()
if ($stmt4) {
die("Select query should have failed.");
}
sqlsrv_close($conn1);
endTest($testName);

47
test/functional/sqlsrv/TC39_Cursors.phpt
View file

@ -5,21 +5,21 @@ Verifies the functionality associated with scrollable resultsets.
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
function CursorTest($noRows1, $noRows2)
function cursorTest($noRows1, $noRows2)
{
include 'MsSetup.inc';
$testName = "Statement - Cursor Mode";
startTest($testName);
setup();
$conn1 = connect();
$conn1 = AE\connect();
$tableName = 'TC39test';
$cursor = "";
for ($k = 0; $k < 4; $k++) {
switch ($k) {
@ -27,9 +27,9 @@ function CursorTest($noRows1, $noRows2)
case 1: $cursor = SQLSRV_CURSOR_STATIC; break;
case 2: $cursor = SQLSRV_CURSOR_DYNAMIC; break;
case 3: $cursor = SQLSRV_CURSOR_KEYSET; break;
default: break;
default: break;
}
ScrollableFetch($conn1, $tableName, $noRows1, $noRows2, $cursor);
scrollableFetch($conn1, $tableName, $noRows1, $noRows2, $cursor);
}
sqlsrv_close($conn1);
@ -37,25 +37,26 @@ function CursorTest($noRows1, $noRows2)
endTest($testName);
}
function ScrollableFetch($conn, $tableName, $noRows1, $noRows2, $cursor)
function scrollableFetch($conn, $tableName, $noRows1, $noRows2, $cursor)
{
$colIndex = "c27_timestamp";
$tableIndex = "TC39index";
createTable($conn, $tableName);
createUniqueIndex($conn, $tableName, $colIndex);
AE\createTestTable($conn, $tableName);
createUniqueIndexEx($conn, $tableName, $tableIndex, $colIndex);
$stmt1 = selectFromTable($conn, $tableName);
$stmt1 = AE\selectFromTable($conn, $tableName);
if (sqlsrv_has_rows($stmt1)) {
die("Table $tableName is expected to be empty...");
}
sqlsrv_free_stmt($stmt1);
$noRows = insertRows($conn, $tableName, $noRows1);
$noRows = AE\insertTestRows($conn, $tableName, $noRows1);
$query = "SELECT * FROM [$tableName] ORDER BY $colIndex";
$options = array('Scrollable' => $cursor);
$stmt2 = selectQueryEx($conn, $query, $options);
$stmt2 = sqlsrv_query($conn, $query, null, $options);
if (!sqlsrv_has_rows($stmt2)) {
die("Table $tableName is not expected to be empty...");
}
@ -71,7 +72,7 @@ function ScrollableFetch($conn, $tableName, $noRows1, $noRows2, $cursor)
$noRows--;
}
if ($noRows2 > 0) {
$extraRows = insertRows($conn, $tableName, $noRows2);
$extraRows = AE\insertTestRows($conn, $tableName, $noRows2);
if ($cursor == SQLSRV_CURSOR_DYNAMIC) {
$noRows += $extraRows;
}
@ -88,22 +89,12 @@ function ScrollableFetch($conn, $tableName, $noRows1, $noRows2, $cursor)
dropTable($conn, $tableName);
}
//--------------------------------------------------------------------
// repro
//
//--------------------------------------------------------------------
function repro()
{
try {
CursorTest(10, 5);
} catch (Exception $e) {
echo $e->getMessage();
}
try {
cursorTest(10, 5);
} catch (Exception $e) {
echo $e->getMessage();
}
repro();
?>
--EXPECT--
Test "Statement - Cursor Mode" completed successfully.

49
test/functional/sqlsrv/TC41_FetchMetadata.phpt
View file

@ -9,26 +9,24 @@ Validates functionality with statement in both prepared and executed state.
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
function FetchMetadata()
function fetchMetadata()
{
include 'MsSetup.inc';
$testName = "Fetch - Metadata";
startTest($testName);
setup();
$conn1 = connect();
createTable($conn1, $tableName);
$tableName = 'TC41test';
$conn1 = AE\connect();
AE\createTestTable($conn1, $tableName);
AE\insertTestRows($conn1, $tableName, 1);
insertRow($conn1, $tableName);
$stmt1 = selectFromTable($conn1, $tableName);
$stmt1 = AE\selectFromTable($conn1, $tableName);
$numFields = sqlsrv_num_fields($stmt1);
trace("Expecting $numFields fields...\n");
@ -40,11 +38,11 @@ function FetchMetadata()
}
for ($k = 0; $k < $count; $k++) {
trace(" ".($k + 1)."\t");
ShowMetadata($metadata, $k, 'Name');
ShowMetadata($metadata, $k, 'Size');
ShowMetadata($metadata, $k, 'Precision');
ShowMetadata($metadata, $k, 'Scale');
ShowMetadata($metadata, $k, 'Nullable');
showMetadata($metadata, $k, 'Name');
showMetadata($metadata, $k, 'Size');
showMetadata($metadata, $k, 'Precision');
showMetadata($metadata, $k, 'Scale');
showMetadata($metadata, $k, 'Nullable');
trace("\n");
}
@ -57,31 +55,22 @@ function FetchMetadata()
endTest($testName);
}
function ShowMetadata($mdArray, $field, $info)
function showMetadata($mdArray, $field, $info)
{
$mdInfo = $mdArray[$field][$info];
$refInfo = GetMetadata($field + 1, $info);
$refInfo = getMetadata($field + 1, $info);
trace("[$info=$mdInfo]");
if ($mdInfo != $refInfo) {
die("Unexpected metadata value for $info in field ".($field + 1).": $mdInfo instead of $refInfo");
}
}
//--------------------------------------------------------------------
// repro
//
//--------------------------------------------------------------------
function repro()
{
try {
FetchMetadata();
} catch (Exception $e) {
echo $e->getMessage();
}
try {
fetchMetadata();
} catch (Exception $e) {
echo $e->getMessage();
}
repro();
?>
--EXPECT--
Test "Fetch - Metadata" completed successfully.

39
test/functional/sqlsrv/TC42_FetchField.phpt
View file

@ -6,43 +6,43 @@ retrieving fields from a table including rows with all supported SQL types (28 t
--ENV--
PHPT_EXEC=true
--SKIPIF--
<?php require('skipif.inc'); ?>
<?php require('skipif_versions_old.inc'); ?>
--FILE--
<?php
require_once('MsCommon.inc');
function FetchFields()
function fetchFields()
{
include 'MsSetup.inc';
$testName = "Fetch - Field";
startTest($testName);
setup();
$tableName = 'TC42test';
if (! isWindows()) {
$conn1 = connect(array( 'CharacterSet'=>'UTF-8' ));
$conn1 = AE\connect(array('CharacterSet'=>'UTF-8'));
} else {
$conn1 = connect();
$conn1 = AE\connect();
}
createTable($conn1, $tableName);
AE\createTestTable($conn1, $tableName);
$noRows = 10;
$noRowsInserted = insertRows($conn1, $tableName, $noRows);
$noRowsInserted = AE\insertTestRows($conn1, $tableName, $noRows);
$stmt1 = selectFromTable($conn1, $tableName);
$stmt1 = AE\selectFromTable($conn1, $tableName);
$numFields = sqlsrv_num_fields($stmt1);
trace("Retrieving $noRowsInserted rows with $numFields fields each ...");
for ($i = 0; $i < $noRowsInserted; $i++) {
$row = sqlsrv_fetch($stmt1);
if ($row === false) {
fatalError("Row $i is missing");
fatalError("Row $i is missing", true);
}
for ($j = 0; $j < $numFields; $j++) {
$fld = sqlsrv_get_field($stmt1, $j);
if ($fld === false) {
fatalError("Field $j of Row $i is missing\n");
fatalError("Field $j of Row $i is missing\n", true);
}
}
}
@ -56,21 +56,12 @@ function FetchFields()
endTest($testName);
}
//--------------------------------------------------------------------
// repro
//
//--------------------------------------------------------------------
function repro()
{
try {
FetchFields();
} catch (Exception $e) {
echo $e->getMessage();
}
try {
fetchFields();
} catch (Exception $e) {
echo $e->getMessage();
}
repro();
?>
--EXPECT--
Test "Fetch - Field" completed successfully.

Some files were not shown because too many files have changed in this diff Show more