Jenny Tam
GitHub
commit
67c2448a3f
|
|
@ -20,10 +20,10 @@ env:
|
|||
- TEST_PHP_SQL_PWD=Password123
|
||||
|
||||
before_install:
|
||||
- docker pull microsoft/mssql-server-linux
|
||||
- docker pull microsoft/mssql-server-linux:2017-latest
|
||||
|
||||
install:
|
||||
- docker run -e 'ACCEPT_EULA=Y' -e 'SA_PASSWORD=Password123' -p 1433:1433 --name=$TEST_PHP_SQL_SERVER -d microsoft/mssql-server-linux
|
||||
- docker run -e 'ACCEPT_EULA=Y' -e 'SA_PASSWORD=Password123' -p 1433:1433 --name=$TEST_PHP_SQL_SERVER -d microsoft/mssql-server-linux:2017-latest
|
||||
- docker build --build-arg PHPSQLDIR=$PHPSQLDIR -t msphpsql-dev -f Dockerfile-msphpsql .
|
||||
|
||||
before_script:
|
||||
|
|
@ -53,7 +53,6 @@ script:
|
|||
- docker stop client
|
||||
- docker ps -a
|
||||
|
||||
|
||||
notifications:
|
||||
email: false
|
||||
|
||||
|
|
|
|||
24
CHANGELOG.md
24
CHANGELOG.md
|
|
@ -3,6 +3,30 @@ All notable changes to this project will be documented in this file.
|
|||
|
||||
The format is based on [Keep a Changelog](http://keepachangelog.com/)
|
||||
|
||||
## Windows/Linux 5.1.1-preview - 2017-10-20
|
||||
Updated PECL release packages. Here is the list of updates:
|
||||
|
||||
### Fixed
|
||||
- PDO::quote with string containing ASCII NUL character (Issue [#538]( https://github.com/Microsoft/msphpsql/issues/538))
|
||||
- Appropriate error message is returned when calling nextRowset() or sqlsrv_next_result() on an empty result set (issue [#507 ](https://github.com/Microsoft/msphpsql/issues/507))
|
||||
- Decimal types with no decimals are correctly handled when AE is enabled (PR [#544](https://github.com/Microsoft/msphpsql/pull/544))
|
||||
- Search for installed ODBC drivers in Linux/macOS first before attempting to connect using the default ODBC driver
|
||||
- BIGINT as an output param no longer results in value out of range exception when the returned value is larger than a maximum integer ([PR #567](https://github.com/Microsoft/msphpsql/pull/567))
|
||||
|
||||
### Limitations
|
||||
- Always Encrypted functionalities are only supported using [MSODBC 17 preview](https://github.com/Microsoft/msphpsql/tree/dev/ODBC%2017%20binaries%20preview)
|
||||
- ODBC binaries for macOS available upon request
|
||||
- MSODBC 17 preview msodbcsql.msi only works for Windows10
|
||||
- [Always Encrypted limitations](https://github.com/Microsoft/msphpsql/wiki/Features#aelimitation)
|
||||
- When using sqlsrv_query with Always Encrypted feature, SQL type has to be specified for each input (see [here](https://github.com/Microsoft/msphpsql/wiki/Features#aebindparam))
|
||||
- No support for inout / output params when using sql_variant type
|
||||
|
||||
### Known Issues
|
||||
- Connection pooling on Linux doesn't work properly when using the MSODBC17 preview
|
||||
- When pooling is enabled in Linux or MAC
|
||||
- unixODBC <= 2.3.4 (Linux and MAC) might not return proper diagnostics information, such as error messages, warnings and informative messages
|
||||
- due to this unixODBC bug, fetch large data (such as xml, binary) as streams as a workaround. See the examples [here](https://github.com/Microsoft/msphpsql/wiki/Connection-Pooling-on-Linux-and-Mac)
|
||||
|
||||
## Windows/Linux 5.1.0-preview - 2017-09-15
|
||||
Updated PECL release packages. Here is the list of updates:
|
||||
|
||||
|
|
|
|||
|
|
@ -1 +1,6 @@
|
|||
The ODBC driver 17 preview binaries in this directory are required in order to use Always Encrypted (AE) functionality. Please note that these drivers should be considered to be preview versions -- they should not be used in production and are not supported by Microsoft. They will be replaced upon the official release of ODBC driver 17.
|
||||
|
||||
The ODBC driver 17 preview binaries in this directory are required in order to use Always Encrypted functionality. Please note that these drivers should be considered to be preview versions -- they should not be used in production and are not supported by Microsoft. They will be replaced upon the official release of ODBC driver 17.
|
||||
|
||||
On Windows, the ODBC 17 preview binaries require the Visual C/C++ 2013 runtime libraries installed separately. These are installed with the [Visual Studio C++ 2013 Redistributable](https://www.microsoft.com/en-ca/download/details.aspx?id=40784) or with the [SQL Server command line utilities](https://www.microsoft.com/en-ca/download/details.aspx?id=53591). Once you have these, simply run the msi to install.
|
||||
|
||||
For instructions on installing the binaries on Linux platforms, please see [this page](https://github.com/Microsoft/msphpsql/wiki/Install-and-configuration#odbc-17-linux-installation).
|
||||
|
|
|
|||
Binary file not shown.
Binary file not shown.
18
README.md
18
README.md
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
The Microsoft Drivers for PHP for SQL Server are PHP extensions that allow for the reading and writing of SQL Server data from within PHP scripts. The SQLSRV extension provides a procedural interface while the PDO_SQLSRV extension implements PDO for accessing data in all editions of SQL Server 2008 R2 and later (including Azure SQL DB). These drivers rely on the Microsoft ODBC Driver for SQL Server to handle the low-level communication with SQL Server.
|
||||
|
||||
This release contains the SQLSRV and PDO_SQLSRV drivers for PHP 7 with improvements on both drivers and some limitations (see Limitations below for details). Upcoming release(s) will contain more functionality, bug fixes, and more (see Plans below for more details).
|
||||
This release contains the SQLSRV and PDO_SQLSRV drivers for PHP 7.0.* or above with improvements on both drivers and some limitations (see Limitations below for details). Upcoming release(s) will contain more functionality, bug fixes, and more (see Plans below for more details).
|
||||
|
||||
SQL Server Team
|
||||
|
||||
|
|
@ -16,16 +16,18 @@ Thank you for taking time to take our February survey. Let us know how we are do
|
|||
<a href="https://www.surveymonkey.com/r/CZNSBYW"><img style="float: right;" height="67" width="156" src="https://meetsstorenew.blob.core.windows.net/contianerhd/survey.png?st=2017-02-17T22%3A03%3A00Z&se=2100-02-18T22%3A03%3A00Z&sp=rl&sv=2015-12-11&sr=b&sig=DJSFoihBptSvO%2BjvWzwpHecf8o5yfAbJoD2qW5oB8tc%3D"></a>
|
||||
|
||||
### Status of Most Recent Builds
|
||||
| AppVeyor (Windows) |Travis CI (Linux) | Coverage Status
|
||||
|-------------------------|--------------------------| ------------------
|
||||
| [![av-image][]][av-site]| [![tv-image][]][tv-site] |[![Coverage Status][]][coveralls-site]
|
||||
| AppVeyor (Windows) | Travis CI (Linux) | Coverage (Windows) | Coverage (Linux) |
|
||||
|--------------------------|--------------------------|---------------------------------------|-------------------------------------------|
|
||||
| [![av-image][]][av-site] | [![tv-image][]][tv-site] | [![Coverage Codecov][]][codecov-site] | [![Coverage Coveralls][]][coveralls-site] |
|
||||
|
||||
[av-image]: https://ci.appveyor.com/api/projects/status/xhp4nq9ouljnhxqf/branch/dev?svg=true
|
||||
[av-site]: https://ci.appveyor.com/project/Microsoft-PHPSQL/msphpsql-frhmr/branch/dev
|
||||
[tv-image]: https://travis-ci.org/Microsoft/msphpsql.svg?branch=dev
|
||||
[tv-site]: https://travis-ci.org/Microsoft/msphpsql/
|
||||
[Coverage Status]: https://coveralls.io/repos/github/Microsoft/msphpsql/badge.svg?branch=dev
|
||||
[Coverage Coveralls]: https://coveralls.io/repos/github/Microsoft/msphpsql/badge.svg?branch=dev
|
||||
[coveralls-site]: https://coveralls.io/github/Microsoft/msphpsql?branch=dev
|
||||
[Coverage Codecov]: https://codecov.io/gh/microsoft/msphpsql/branch/dev/graph/badge.svg
|
||||
[codecov-site]: https://codecov.io/gh/microsoft/msphpsql
|
||||
|
||||
## Get Started
|
||||
|
||||
|
|
@ -43,15 +45,15 @@ Thank you for taking time to take our February survey. Let us know how we are do
|
|||
|
||||
## Build (Windows)
|
||||
|
||||
Note: if you prefer, you can use the pre-compiled binary found [HERE](https://github.com/Microsoft/msphpsql/releases)
|
||||
Note: if you prefer, you can use the pre-compiled binaries found in the [releases](https://github.com/Microsoft/msphpsql/releases)
|
||||
|
||||
#### Prerequisites
|
||||
|
||||
You must first be able to build PHP 7* without including these extensions. For help with doing this, see the [official PHP website][phpbuild] for building your own PHP in Windows.
|
||||
You must first be able to build PHP 7.0.* or above without including these extensions. For help with doing this, see the [official PHP website][phpbuild] for building your own PHP in Windows.
|
||||
|
||||
#### Compile the drivers
|
||||
|
||||
The Microsoft Drivers for PHP for SQL Server have been compiled and tested with PHP 7.0.* and 7.1.* using Visual C++ 2015 as well as PHP 7.2.0 beta using Visual C++ 2017 v15.0.
|
||||
The Microsoft Drivers for PHP for SQL Server have been compiled and tested with PHP 7.0.* and 7.1.* using Visual C++ 2015 as well as PHP 7.2.0RC* using Visual C++ 2017 v15.0.
|
||||
For details, please read the documentation and/or take a look at the sample [build scripts](https://github.com/Microsoft/msphpsql/tree/dev/buildscripts#windows).
|
||||
|
||||
## Install (Windows)
|
||||
|
|
|
|||
41
appveyor.yml
41
appveyor.yml
|
|
@ -18,6 +18,15 @@ environment:
|
|||
PHP_DEPSVER: 7.0
|
||||
PHP_SDK: c:\projects\php
|
||||
matrix:
|
||||
- BUILD_PLATFORM: x86
|
||||
TEST_PHP_SQL_SERVER: (local)\SQL2016
|
||||
SQL_INSTANCE: SQL2016
|
||||
PHP_VC: 14
|
||||
PHP_MAJOR_VER: 7.1
|
||||
PHP_MINOR_VER: latest
|
||||
PHP_SDK_DIR: c:\projects\php\x86
|
||||
PHP_INSTALL_DIR: c:\projects\php\x86\bin
|
||||
platform: x86
|
||||
- BUILD_PLATFORM: x64
|
||||
TEST_PHP_SQL_SERVER: (local)\SQL2012SP1
|
||||
SQL_INSTANCE: SQL2012SP1
|
||||
|
|
@ -37,15 +46,6 @@ environment:
|
|||
PHP_SDK_DIR: c:\projects\php\x86
|
||||
PHP_INSTALL_DIR: c:\projects\php\x86\bin
|
||||
platform: x86
|
||||
- BUILD_PLATFORM: x64
|
||||
TEST_PHP_SQL_SERVER: (local)\SQL2016
|
||||
SQL_INSTANCE: SQL2016
|
||||
PHP_VC: 14
|
||||
PHP_MAJOR_VER: 7.1
|
||||
PHP_MINOR_VER: latest
|
||||
PHP_SDK_DIR: c:\projects\php\x64
|
||||
PHP_INSTALL_DIR: c:\projects\php\x64\bin
|
||||
platform: x64
|
||||
- BUILD_PLATFORM: x86
|
||||
TEST_PHP_SQL_SERVER: (local)\SQL2008R2SP2
|
||||
SQL_INSTANCE: SQL2008R2SP2
|
||||
|
|
@ -127,7 +127,12 @@ install:
|
|||
- ps: Get-Content ${env:APPVEYOR_BUILD_FOLDER}\test\functional\pdo_sqlsrv\MsSetup.inc
|
||||
- ps: (Get-Content ${env:APPVEYOR_BUILD_FOLDER}\test\functional\sqlsrv\MsSetup.inc) | ForEach-Object { $_ -replace "TARGET_SERVER", ${env:TEST_PHP_SQL_SERVER} -replace "TARGET_DATABASE", ${env:SQLSRV_DBNAME} -replace "TARGET_USERNAME", ${env:TEST_PHP_SQL_UID} -replace "TARGET_PASSWORD", ${env:TEST_PHP_SQL_PWD} } | Set-Content ${env:APPVEYOR_BUILD_FOLDER}\test\functional\sqlsrv\MsSetup.inc
|
||||
- ps: Get-Content ${env:APPVEYOR_BUILD_FOLDER}\test\functional\sqlsrv\MsSetup.inc
|
||||
|
||||
- appveyor DownloadFile http://github.com/OpenCppCoverage/OpenCppCoverage/releases/download/release-0.9.6.1/OpenCppCoverageSetup-x64-0.9.6.1.exe
|
||||
- OpenCppCoverageSetup-x64-0.9.6.1.exe /VERYSILENT
|
||||
- ps: ls "c:\Program Files"
|
||||
- set CPPCOVER="C:\\Program Files\\OpenCppCoverage"
|
||||
- set PATH=%CPPCOVER%;%PATH%
|
||||
|
||||
build_script:
|
||||
- '"C:\\Program Files (x86)\\Microsoft Visual Studio %PHP_VC%.0\\VC\\vcvarsall.bat" %BUILD_PLATFORM%'
|
||||
- Echo copy msphp code to ext folder
|
||||
|
|
@ -176,12 +181,7 @@ test_script:
|
|||
- type %APPVEYOR_BUILD_FOLDER%\test\functional\sqlsrv.log
|
||||
- php run-tests.php -p php.exe %APPVEYOR_BUILD_FOLDER%\test\functional\pdo_sqlsrv\*.phpt > %APPVEYOR_BUILD_FOLDER%\test\functional\pdo_sqlsrv.log 2>&1
|
||||
- type %APPVEYOR_BUILD_FOLDER%\test\functional\pdo_sqlsrv.log
|
||||
- python %APPVEYOR_BUILD_FOLDER%\test\functional\setup\cleanup_dbs.py -dbname %SQLSRV_DBNAME%
|
||||
- python %APPVEYOR_BUILD_FOLDER%\test\functional\setup\cleanup_dbs.py -dbname %PDOSQLSRV_DBNAME%
|
||||
|
||||
after_test:
|
||||
- cd %APPVEYOR_BUILD_FOLDER%\test\functional\
|
||||
- python output.py
|
||||
- ps: $difffiles = Get-ChildItem sqlsrv\*.diff
|
||||
- ps: $outfiles = Get-ChildItem sqlsrv\*.out
|
||||
- ps: foreach($file in $difffiles){ls $file; more $file}
|
||||
|
|
@ -190,6 +190,17 @@ after_test:
|
|||
- ps: $outfiles = Get-ChildItem pdo_sqlsrv\*.out
|
||||
- ps: foreach($file in $difffiles){ls $file; more $file}
|
||||
- ps: foreach($file in $outfiles){ls $file; more $file}
|
||||
- cd %PHP_INSTALL_DIR%
|
||||
- OpenCppCoverage.exe --sources %PHP_SDK_DIR%\php-%PHP_VERSION%-src\ext\pdo_sqlsrv --sources %PHP_SDK_DIR%\php-%PHP_VERSION%-src\ext\sqlsrv --modules *sqlsrv*.dll --export_type=cobertura:.\coverage.xml --cover_children --quiet --continue_after_cpp_exception --optimized_build -- .\php.exe .\run-tests.php -P %APPVEYOR_BUILD_FOLDER%\test\functional\
|
||||
- ls
|
||||
- python %APPVEYOR_BUILD_FOLDER%\test\functional\setup\cleanup_dbs.py -dbname %SQLSRV_DBNAME%
|
||||
- python %APPVEYOR_BUILD_FOLDER%\test\functional\setup\cleanup_dbs.py -dbname %PDOSQLSRV_DBNAME%
|
||||
- pip install codecov
|
||||
- codecov -f ".\coverage.xml"
|
||||
|
||||
after_test:
|
||||
- cd %APPVEYOR_BUILD_FOLDER%\test\functional\
|
||||
- python output.py
|
||||
- ps: (new-object net.webclient).UploadFile("https://ci.appveyor.com/api/testresults/junit/$($env:APPVEYOR_JOB_ID)", (Resolve-Path .\nativeresult1.xml))
|
||||
- ps: (new-object net.webclient).UploadFile("https://ci.appveyor.com/api/testresults/junit/$($env:APPVEYOR_JOB_ID)", (Resolve-Path .\nativeresult2.xml))
|
||||
- ps: >-
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ if( PHP_PDO_SQLSRV != "no" ) {
|
|||
|
||||
if (CHECK_LIB("odbc32.lib", "pdo_sqlsrv") && CHECK_LIB("odbccp32.lib", "pdo_sqlsrv") &&
|
||||
CHECK_LIB("version.lib", "pdo_sqlsrv") && CHECK_LIB("psapi.lib", "pdo_sqlsrv")&&
|
||||
CHECK_HEADER_ADD_INCLUDE( "core_sqlsrv.h", "CFLAGS_PDO_SQLSRV", configure_module_dirname + "\\shared")) {
|
||||
CHECK_HEADER_ADD_INCLUDE( "core_sqlsrv.h", "CFLAGS_PDO_SQLSRV", configure_module_dirname + "\\shared")) {
|
||||
CHECK_HEADER_ADD_INCLUDE("sql.h", "CFLAGS_PDO_SQLSRV_ODBC");
|
||||
CHECK_HEADER_ADD_INCLUDE("sqlext.h", "CFLAGS_PDO_SQLSRV_ODBC");
|
||||
ADD_SOURCES( configure_module_dirname + "\\shared", shared_src_class, "pdo_sqlsrv" );
|
||||
|
|
@ -40,5 +40,5 @@ if( PHP_PDO_SQLSRV != "no" ) {
|
|||
EXTENSION("pdo_sqlsrv", pdo_sqlsrv_src_class, PHP_PDO_SQLSRV_SHARED, "/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1");
|
||||
} else {
|
||||
WARNING("pdo-sqlsrv not enabled; libraries and headers not found");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1463,7 +1463,7 @@ int pdo_sqlsrv_dbh_quote( _Inout_ pdo_dbh_t* dbh, _In_reads_(unquoted_len) const
|
|||
if ( encoding == SQLSRV_ENCODING_UTF8 ) {
|
||||
quotes_needed = 3;
|
||||
}
|
||||
for ( size_t index = 0; index < unquoted_len && unquoted[ index ] != '\0'; ++index ) {
|
||||
for ( size_t index = 0; index < unquoted_len; ++index ) {
|
||||
if ( unquoted[ index ] == '\'' ) {
|
||||
++quotes_needed;
|
||||
}
|
||||
|
|
@ -1480,7 +1480,7 @@ int pdo_sqlsrv_dbh_quote( _Inout_ pdo_dbh_t* dbh, _In_reads_(unquoted_len) const
|
|||
// insert initial quote
|
||||
( *quoted )[ out_current++ ] = '\'';
|
||||
|
||||
for ( size_t index = 0; index < unquoted_len && unquoted[ index ] != '\0'; ++index ) {
|
||||
for ( size_t index = 0; index < unquoted_len; ++index ) {
|
||||
if ( unquoted[ index ] == '\'' ) {
|
||||
( *quoted )[ out_current++ ] = '\'';
|
||||
( *quoted )[ out_current++ ] = '\'';
|
||||
|
|
|
|||
|
|
@ -1067,6 +1067,33 @@ int pdo_sqlsrv_stmt_next_rowset( _Inout_ pdo_stmt_t *stmt TSRMLS_DC )
|
|||
|
||||
SQLSRV_ASSERT( driver_stmt != NULL, "pdo_sqlsrv_stmt_next_rowset: driver_data object was null" );
|
||||
|
||||
// Return the correct error in case the user calls nextRowset() on a null result set.
|
||||
// Null means that SQLNumResultCols() returns 0 and SQLRowCount does not return > 0. But first
|
||||
// check that the statement has been executed and that we are not past the end of a non-null
|
||||
// result set to make sure the user gets the correct error message. These checks are also
|
||||
// done in core_sqlsrv_next_result(), but we cannot check for null results there because that
|
||||
// function can be called without calling this one, and SQLSRV_ERROR_NO_FIELDS can then
|
||||
// be triggered incorrectly.
|
||||
CHECK_CUSTOM_ERROR( !driver_stmt->executed, driver_stmt, SQLSRV_ERROR_STATEMENT_NOT_EXECUTED ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
|
||||
CHECK_CUSTOM_ERROR( driver_stmt->past_next_result_end, driver_stmt, SQLSRV_ERROR_NEXT_RESULT_PAST_END ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
|
||||
// Now make sure the result set is not null.
|
||||
bool has_result = core_sqlsrv_has_any_result( driver_stmt );
|
||||
|
||||
// Note that if fetch_called is false but has_result is true (i.e. the user is calling
|
||||
// nextRowset() on a non-null result set before calling fetch()), it is handled
|
||||
// in core_sqlsrv_next_result() below.
|
||||
if( !driver_stmt->fetch_called ) {
|
||||
CHECK_CUSTOM_ERROR( !has_result, driver_stmt, SQLSRV_ERROR_NO_FIELDS ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
}
|
||||
|
||||
core_sqlsrv_next_result( static_cast<sqlsrv_stmt*>( stmt->driver_data ) TSRMLS_CC );
|
||||
|
||||
// clear the current meta data since the new result will generate new meta data
|
||||
|
|
|
|||
|
|
@ -398,13 +398,17 @@ pdo_error PDO_ERRORS[] = {
|
|||
{ IMSSP, (SQLCHAR*) "Invalid value for loading a custom keystore provider.", -77, false}
|
||||
},
|
||||
{
|
||||
SQLSRV_ERROR_AE_DRIVER_NOT_INSTALLED,
|
||||
SQLSRV_ERROR_CE_DRIVER_REQUIRED,
|
||||
{ IMSSP, (SQLCHAR*) "The Always Encrypted feature requires Microsoft ODBC Driver 17 for SQL Server.", -78, false }
|
||||
},
|
||||
{
|
||||
SQLSRV_ERROR_CONNECT_INVALID_DRIVER,
|
||||
{ IMSSP, (SQLCHAR*) "Invalid value %1!s! was specified for Driver option.", -79, true }
|
||||
},
|
||||
{
|
||||
SQLSRV_ERROR_SPECIFIED_DRIVER_NOT_FOUND,
|
||||
{ IMSSP, (SQLCHAR*) "The specified ODBC Driver is not found.", -80, false }
|
||||
},
|
||||
{ UINT_MAX, {} }
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -110,9 +110,9 @@ sqlsrv_conn* core_sqlsrv_connect( _In_ sqlsrv_context& henv_cp, _In_ sqlsrv_cont
|
|||
#endif // _WIN32
|
||||
|
||||
try {
|
||||
// Due to the limitations on connection pooling in unixODBC 2.3.1 driver manager, we do not consider
|
||||
// the connection string attributes to set (enable/disable) connection pooling.
|
||||
// Instead, MSPHPSQL connection pooling is set according to the ODBCINST.INI file in [ODBC] section.
|
||||
// Due to the limitations on connection pooling in unixODBC 2.3.1 driver manager, we do not consider
|
||||
// the connection string attributes to set (enable/disable) connection pooling.
|
||||
// Instead, MSPHPSQL connection pooling is set according to the ODBCINST.INI file in [ODBC] section.
|
||||
|
||||
#ifndef _WIN32
|
||||
char pooling_string[ 128 ] = {0};
|
||||
|
|
@ -125,9 +125,9 @@ sqlsrv_conn* core_sqlsrv_connect( _In_ sqlsrv_context& henv_cp, _In_ sqlsrv_cont
|
|||
is_pooled = true;
|
||||
}
|
||||
#else
|
||||
// check the connection pooling setting to determine which henv to use to allocate the connection handle
|
||||
// we do this earlier because we have to allocate the connection handle prior to setting attributes on
|
||||
// it in build_connection_string_and_set_conn_attr.
|
||||
// check the connection pooling setting to determine which henv to use to allocate the connection handle
|
||||
// we do this earlier because we have to allocate the connection handle prior to setting attributes on
|
||||
// it in build_connection_string_and_set_conn_attr.
|
||||
|
||||
if( options_ht && zend_hash_num_elements( options_ht ) > 0 ) {
|
||||
|
||||
|
|
@ -150,34 +150,94 @@ sqlsrv_conn* core_sqlsrv_connect( _In_ sqlsrv_context& henv_cp, _In_ sqlsrv_cont
|
|||
|
||||
build_connection_string_and_set_conn_attr( conn, server, uid, pwd, options_ht, valid_conn_opts, driver, conn_str TSRMLS_CC );
|
||||
|
||||
bool is_missing_driver = false;
|
||||
|
||||
if ( conn->is_driver_set ) {
|
||||
r = core_odbc_connect( conn, conn_str, is_missing_driver, is_pooled );
|
||||
// If column encryption is enabled, must use ODBC driver 17
|
||||
if( conn->ce_option.enabled && conn->driver_version != ODBC_DRIVER_UNKNOWN) {
|
||||
CHECK_CUSTOM_ERROR( conn->driver_version != ODBC_DRIVER_17, conn, SQLSRV_ERROR_CE_DRIVER_REQUIRED, get_processor_arch() ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
}
|
||||
else if ( conn->ce_option.enabled ) {
|
||||
conn_str = conn_str + CONNECTION_STRING_DRIVER_NAME[ DRIVER_VERSION::ODBC_DRIVER_17 ];
|
||||
r = core_odbc_connect( conn, conn_str, is_missing_driver, is_pooled );
|
||||
|
||||
CHECK_CUSTOM_ERROR( is_missing_driver, conn, SQLSRV_ERROR_AE_DRIVER_NOT_INSTALLED, get_processor_arch()) {
|
||||
// In non-Windows environment, unixODBC 2.3.4 and unixODBC 2.3.1 return different error states when an ODBC driver exists or not
|
||||
// Therefore, it is unreliable to check for a certain sql state error
|
||||
#ifndef _WIN32
|
||||
if( conn->driver_version != ODBC_DRIVER_UNKNOWN ) {
|
||||
// check if the ODBC driver actually exists, if not, throw an exception
|
||||
CHECK_CUSTOM_ERROR( ! core_search_odbc_driver_unix( conn->driver_version ), conn, SQLSRV_ERROR_SPECIFIED_DRIVER_NOT_FOUND ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
|
||||
r = core_odbc_connect( conn, conn_str, is_pooled );
|
||||
}
|
||||
else {
|
||||
if( conn->ce_option.enabled ) {
|
||||
// driver not specified, so check if ODBC 17 exists
|
||||
CHECK_CUSTOM_ERROR( ! core_search_odbc_driver_unix( ODBC_DRIVER_17 ), conn, SQLSRV_ERROR_CE_DRIVER_REQUIRED, get_processor_arch()) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
|
||||
conn_str = conn_str + CONNECTION_STRING_DRIVER_NAME[ODBC_DRIVER_17];
|
||||
r = core_odbc_connect( conn, conn_str, is_pooled );
|
||||
}
|
||||
else {
|
||||
// skip ODBC 11 in a non-Windows environment -- only available in Red Hat / SUSE (preview)
|
||||
// https://docs.microsoft.com/en-us/sql/connect/odbc/linux-mac/installing-the-microsoft-odbc-driver-for-sql-server#microsoft-odbc-driver-11-for-sql-server-on-linux
|
||||
|
||||
DRIVER_VERSION odbc_version = ODBC_DRIVER_UNKNOWN;
|
||||
if( core_search_odbc_driver_unix( ODBC_DRIVER_13 ) ) {
|
||||
odbc_version = ODBC_DRIVER_13;
|
||||
}
|
||||
else if ( core_search_odbc_driver_unix( ODBC_DRIVER_17 ) ) {
|
||||
odbc_version = ODBC_DRIVER_17;
|
||||
}
|
||||
|
||||
CHECK_CUSTOM_ERROR( odbc_version == ODBC_DRIVER_UNKNOWN, conn, SQLSRV_ERROR_DRIVER_NOT_INSTALLED, get_processor_arch() ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
std::string conn_str_driver = conn_str + CONNECTION_STRING_DRIVER_NAME[odbc_version];
|
||||
r = core_odbc_connect( conn, conn_str_driver, is_pooled );
|
||||
} // else ce_option enabled
|
||||
} // else driver_version not unknown
|
||||
#else
|
||||
if( conn->driver_version != ODBC_DRIVER_UNKNOWN ) {
|
||||
r = core_odbc_connect( conn, conn_str, is_pooled );
|
||||
|
||||
// check if the specified ODBC driver is there
|
||||
CHECK_CUSTOM_ERROR( core_compare_error_state( conn, r, "IM002" ), conn, SQLSRV_ERROR_SPECIFIED_DRIVER_NOT_FOUND ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
}
|
||||
else {
|
||||
if( conn->ce_option.enabled ) {
|
||||
// driver not specified, so connect using ODBC 17
|
||||
conn_str = conn_str + CONNECTION_STRING_DRIVER_NAME[ODBC_DRIVER_17];
|
||||
r = core_odbc_connect( conn, conn_str, is_pooled );
|
||||
|
||||
for ( std::size_t i = DRIVER_VERSION::FIRST; i <= DRIVER_VERSION::LAST; ++i ) {
|
||||
is_missing_driver = false;
|
||||
std::string conn_str_driver = conn_str + CONNECTION_STRING_DRIVER_NAME[ DRIVER_VERSION(i) ];
|
||||
r = core_odbc_connect( conn, conn_str_driver, is_missing_driver, is_pooled );
|
||||
CHECK_CUSTOM_ERROR( is_missing_driver && ( i == DRIVER_VERSION::LAST ), conn, SQLSRV_ERROR_DRIVER_NOT_INSTALLED, get_processor_arch()) {
|
||||
// check if the specified ODBC driver is there
|
||||
CHECK_CUSTOM_ERROR( core_compare_error_state( conn, r, "IM002" ) , conn, SQLSRV_ERROR_CE_DRIVER_REQUIRED, get_processor_arch() ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
if ( !is_missing_driver) {
|
||||
break;
|
||||
}
|
||||
} // for
|
||||
} // else ce_option enabled
|
||||
|
||||
}
|
||||
else {
|
||||
bool done = false;
|
||||
for( short i = DRIVER_VERSION::FIRST; i <= DRIVER_VERSION::LAST && ! done; ++i ) {
|
||||
std::string conn_str_driver = conn_str + CONNECTION_STRING_DRIVER_NAME[i];
|
||||
r = core_odbc_connect( conn, conn_str_driver, is_pooled );
|
||||
|
||||
if( SQL_SUCCEEDED( r ) || ! core_compare_error_state( conn, r, "IM002" ) ) {
|
||||
// something else went wrong, exit the loop now other than ODBC driver not found
|
||||
done = true;
|
||||
}
|
||||
else {
|
||||
// did it fail to find the last valid ODBC driver?
|
||||
CHECK_CUSTOM_ERROR( ( i == DRIVER_VERSION::LAST ), conn, SQLSRV_ERROR_DRIVER_NOT_INSTALLED, get_processor_arch()) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
}
|
||||
} // for
|
||||
} // else ce_option enabled
|
||||
} // else driver_version not unknown
|
||||
#endif // !_WIN32
|
||||
|
||||
CHECK_SQL_ERROR( r, conn ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
|
|
@ -233,17 +293,79 @@ sqlsrv_conn* core_sqlsrv_connect( _In_ sqlsrv_context& henv_cp, _In_ sqlsrv_cont
|
|||
return return_conn;
|
||||
}
|
||||
|
||||
// core_compare_error_state
|
||||
// This method compares the error state to the one specified
|
||||
// Parameters:
|
||||
// conn - the connection structure on which we establish the connection
|
||||
// rc - ODBC return code
|
||||
// Return - a boolean flag that indicates if the error states are the same
|
||||
|
||||
bool core_compare_error_state( _In_ sqlsrv_conn* conn, _In_ SQLRETURN rc, _In_ const char* error_state )
|
||||
{
|
||||
if( SQL_SUCCEEDED( rc ) )
|
||||
return false;
|
||||
|
||||
SQLCHAR state[ SQL_SQLSTATE_BUFSIZE ];
|
||||
SQLSMALLINT len;
|
||||
SQLRETURN sr = SQLGetDiagField( SQL_HANDLE_DBC, conn->handle(), 1, SQL_DIAG_SQLSTATE, state, SQL_SQLSTATE_BUFSIZE, &len );
|
||||
|
||||
return ( SQL_SUCCEEDED(sr) && ! strcmp(error_state, reinterpret_cast<char*>( state ) ) );
|
||||
}
|
||||
|
||||
// core_search_odbc_driver_unix
|
||||
// This method is meant to be used in a non-Windows environment,
|
||||
// searching for a particular ODBC driver name in the odbcinst.ini file
|
||||
// Parameters:
|
||||
// driver_version - a valid value in enum DRIVER_VERSION
|
||||
// Return - a boolean flag that indicates if the specified driver version is found or not
|
||||
|
||||
bool core_search_odbc_driver_unix( _In_ DRIVER_VERSION driver_version )
|
||||
{
|
||||
char szBuf[DEFAULT_CONN_STR_LEN+1]; // use a large enough buffer size
|
||||
WORD cbBufMax = DEFAULT_CONN_STR_LEN;
|
||||
WORD cbBufOut;
|
||||
char *pszBuf = szBuf;
|
||||
bool found_driver = false;
|
||||
|
||||
#ifndef _WIN32
|
||||
// get all the names of the installed drivers delimited by null characters
|
||||
if(! SQLGetInstalledDrivers( szBuf, cbBufMax, &cbBufOut ) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// extract the ODBC driver name
|
||||
std::string driver = CONNECTION_STRING_DRIVER_NAME[driver_version];
|
||||
std::size_t pos1 = driver.find_first_of("{");
|
||||
std::size_t pos2 = driver.find_first_of("}");
|
||||
std::string driver_str = driver.substr( pos1 + 1, pos2 - pos1 - 1);
|
||||
|
||||
// search for the ODBC driver...
|
||||
const char* driver_name = driver_str.c_str();
|
||||
do
|
||||
{
|
||||
if( strstr( pszBuf, driver_name ) != 0 )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
// get the next driver
|
||||
pszBuf = strchr( pszBuf, '\0' ) + 1;
|
||||
}
|
||||
while( pszBuf[1] != '\0' ); // end when there are two consecutive null characters
|
||||
#endif // !_WIN32
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// core_odbc_connect
|
||||
// calls odbc connect API to establish the connection to server
|
||||
// Parameters:
|
||||
// conn - The connection structure on which we establish the connection
|
||||
// conn_str - Connection string
|
||||
// missing_driver_error - indicates whether odbc driver is installed on client machine
|
||||
// is_pooled - indicate whether it is a pooled connection
|
||||
// Return - SQLRETURN status returned by SQLDriverConnect
|
||||
|
||||
SQLRETURN core_odbc_connect( _Inout_ sqlsrv_conn* conn, _Inout_ std::string& conn_str, _Inout_ bool& is_missing_driver, _In_ bool is_pooled )
|
||||
SQLRETURN core_odbc_connect( _Inout_ sqlsrv_conn* conn, _Inout_ std::string& conn_str, _In_ bool is_pooled )
|
||||
{
|
||||
SQLRETURN r = SQL_SUCCESS;
|
||||
sqlsrv_malloc_auto_ptr<SQLWCHAR> wconn_string;
|
||||
|
|
@ -262,29 +384,20 @@ SQLRETURN core_odbc_connect( _Inout_ sqlsrv_conn* conn, _Inout_ std::string& con
|
|||
#ifndef _WIN32
|
||||
// unixODBC 2.3.1 requires a non-wide SQLDriverConnect call while pooling enabled.
|
||||
// connection handle has been allocated using henv_cp, means pooling enabled in a PHP script
|
||||
if (is_pooled)
|
||||
{
|
||||
if (is_pooled) {
|
||||
r = SQLDriverConnect( conn->handle(), NULL, (SQLCHAR*)conn_str.c_str(), SQL_NTS, NULL, 0, &output_conn_size, SQL_DRIVER_NOPROMPT );
|
||||
}
|
||||
else
|
||||
{
|
||||
else {
|
||||
r = SQLDriverConnectW( conn->handle(), NULL, wconn_string, static_cast<SQLSMALLINT>( wconn_len ), NULL, 0, &output_conn_size, SQL_DRIVER_NOPROMPT );
|
||||
}
|
||||
#else
|
||||
r = SQLDriverConnectW( conn->handle(), NULL, wconn_string, static_cast<SQLSMALLINT>( wconn_len ), NULL, 0, &output_conn_size, SQL_DRIVER_NOPROMPT );
|
||||
#endif // !_WIN32
|
||||
|
||||
// clear the connection string from memory to remove sensitive data (such as a password).
|
||||
// clear the connection string from memory
|
||||
memset( wconn_string, 0, wconn_len * sizeof( SQLWCHAR )); // wconn_len is the number of characters, not bytes
|
||||
conn_str.clear();
|
||||
|
||||
if (!SQL_SUCCEEDED(r)) {
|
||||
SQLCHAR state[ SQL_SQLSTATE_BUFSIZE ];
|
||||
SQLSMALLINT len;
|
||||
SQLRETURN sr = SQLGetDiagField( SQL_HANDLE_DBC, conn->handle(), 1, SQL_DIAG_SQLSTATE, state, SQL_SQLSTATE_BUFSIZE, &len );
|
||||
// sql state IM002/IM003 in ODBC 17, means that the correct ODBC driver is not installed
|
||||
is_missing_driver = ( SQL_SUCCEEDED(sr) && state[0] == 'I' && state[1] == 'M' && state[2] == '0' && state[3] == '0' && (state[4] == '2' || state[4] == '3'));
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
|
|
@ -908,10 +1021,19 @@ void driver_set_func::func( _In_ connection_option const* option, _In_ zval* val
|
|||
std::string driver_option( "" );
|
||||
common_conn_str_append_func( option->odbc_name, val_str, val_len, driver_option TSRMLS_CC );
|
||||
|
||||
CHECK_CUSTOM_ERROR( std::find( CONNECTION_STRING_DRIVER_NAME.begin(), CONNECTION_STRING_DRIVER_NAME.end(), driver_option) == CONNECTION_STRING_DRIVER_NAME.end(), conn, SQLSRV_ERROR_CONNECT_INVALID_DRIVER, val_str){
|
||||
conn->driver_version = ODBC_DRIVER_UNKNOWN;
|
||||
for ( short i = DRIVER_VERSION::FIRST; i <= DRIVER_VERSION::LAST && conn->driver_version == ODBC_DRIVER_UNKNOWN; ++i ) {
|
||||
std::string driver_name = CONNECTION_STRING_DRIVER_NAME[i];
|
||||
|
||||
if (! driver_name.compare( driver_option ) ) {
|
||||
conn->driver_version = DRIVER_VERSION( i );
|
||||
}
|
||||
}
|
||||
|
||||
CHECK_CUSTOM_ERROR( conn->driver_version == ODBC_DRIVER_UNKNOWN, conn, SQLSRV_ERROR_CONNECT_INVALID_DRIVER, val_str) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
conn->is_driver_set = true;
|
||||
|
||||
conn_str += driver_option;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1039,7 +1039,8 @@ enum SERVER_VERSION {
|
|||
|
||||
// supported driver versions.
|
||||
// the latest RTWed ODBC is the first one
|
||||
enum DRIVER_VERSION : std::size_t{
|
||||
enum DRIVER_VERSION {
|
||||
ODBC_DRIVER_UNKNOWN = -1,
|
||||
FIRST = 0,
|
||||
ODBC_DRIVER_13 = FIRST,
|
||||
ODBC_DRIVER_11 = 1,
|
||||
|
|
@ -1073,14 +1074,14 @@ struct sqlsrv_conn : public sqlsrv_context {
|
|||
SERVER_VERSION server_version; // version of the server that we're connected to
|
||||
|
||||
col_encryption_option ce_option; // holds the details of what are required to enable column encryption
|
||||
bool is_driver_set;
|
||||
DRIVER_VERSION driver_version; // version of ODBC driver
|
||||
|
||||
// initialize with default values
|
||||
sqlsrv_conn( _In_ SQLHANDLE h, _In_ error_callback e, _In_opt_ void* drv, _In_ SQLSRV_ENCODING encoding TSRMLS_DC ) :
|
||||
sqlsrv_context( h, SQL_HANDLE_DBC, e, drv, encoding )
|
||||
{
|
||||
server_version = SERVER_VERSION_UNKNOWN;
|
||||
is_driver_set = false;
|
||||
driver_version = ODBC_DRIVER_UNKNOWN;
|
||||
}
|
||||
|
||||
// sqlsrv_conn has no destructor since its allocated using placement new, which requires that the destructor be
|
||||
|
|
@ -1235,7 +1236,7 @@ sqlsrv_conn* core_sqlsrv_connect( _In_ sqlsrv_context& henv_cp, _In_ sqlsrv_cont
|
|||
_Inout_z_ const char* server, _Inout_opt_z_ const char* uid, _Inout_opt_z_ const char* pwd,
|
||||
_Inout_opt_ HashTable* options_ht, _In_ error_callback err, _In_ const connection_option valid_conn_opts[],
|
||||
_In_ void* driver, _In_z_ const char* driver_func TSRMLS_DC );
|
||||
SQLRETURN core_odbc_connect( _Inout_ sqlsrv_conn* conn, _Inout_ std::string& conn_str, _Inout_ bool& is_missing_driver, _In_ bool is_pooled );
|
||||
SQLRETURN core_odbc_connect( _Inout_ sqlsrv_conn* conn, _Inout_ std::string& conn_str, _In_ bool is_pooled );
|
||||
void core_sqlsrv_close( _Inout_opt_ sqlsrv_conn* conn TSRMLS_DC );
|
||||
void core_sqlsrv_prepare( _Inout_ sqlsrv_stmt* stmt, _In_reads_bytes_(sql_len) const char* sql, _In_ SQLLEN sql_len TSRMLS_DC );
|
||||
void core_sqlsrv_begin_transaction( _Inout_ sqlsrv_conn* conn TSRMLS_DC );
|
||||
|
|
@ -1247,6 +1248,8 @@ void core_sqlsrv_get_client_info( _Inout_ sqlsrv_conn* conn, _Out_ zval *client_
|
|||
bool core_is_conn_opt_value_escaped( _Inout_ const char* value, _Inout_ size_t value_len );
|
||||
size_t core_str_zval_is_true( _Inout_ zval* str_zval );
|
||||
bool core_is_authentication_option_valid( _In_z_ const char* value, _In_ size_t value_len );
|
||||
bool core_search_odbc_driver_unix( _In_ DRIVER_VERSION driver_version );
|
||||
bool core_compare_error_state( _In_ sqlsrv_conn* conn, _In_ SQLRETURN r, _In_ const char* error_state );
|
||||
|
||||
//*********************************************************************************************************************************
|
||||
// Statement
|
||||
|
|
@ -1319,10 +1322,11 @@ struct sqlsrv_output_param {
|
|||
SQLUSMALLINT param_num; // used to index into the ind_or_len of the statement
|
||||
SQLLEN original_buffer_len; // used to make sure the returned length didn't overflow the buffer
|
||||
bool is_bool;
|
||||
bool is_long;
|
||||
|
||||
// string output param constructor
|
||||
sqlsrv_output_param( _In_ zval* p_z, _In_ SQLSRV_ENCODING enc, _In_ int num, _In_ SQLUINTEGER buffer_len ) :
|
||||
param_z( p_z ), encoding( enc ), param_num( num ), original_buffer_len( buffer_len ), is_bool( false )
|
||||
sqlsrv_output_param( _In_ zval* p_z, _In_ SQLSRV_ENCODING enc, _In_ int num, _In_ SQLUINTEGER buffer_len, _In_ bool is_long ) :
|
||||
param_z( p_z ), encoding( enc ), param_num( num ), original_buffer_len( buffer_len ), is_bool( false ), is_long( is_long )
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -1332,7 +1336,8 @@ struct sqlsrv_output_param {
|
|||
encoding( SQLSRV_ENCODING_INVALID ),
|
||||
param_num( num ),
|
||||
original_buffer_len( -1 ),
|
||||
is_bool( is_bool )
|
||||
is_bool( is_bool ),
|
||||
is_long( false )
|
||||
{
|
||||
}
|
||||
};
|
||||
|
|
@ -1428,7 +1433,7 @@ typedef sqlsrv_stmt* (*driver_stmt_factory)( sqlsrv_conn* conn, SQLHANDLE h, err
|
|||
sqlsrv_stmt* core_sqlsrv_create_stmt( _Inout_ sqlsrv_conn* conn, _In_ driver_stmt_factory stmt_factory, _In_opt_ HashTable* options_ht,
|
||||
_In_opt_ const stmt_option valid_stmt_opts[], _In_ error_callback const err, _In_opt_ void* driver TSRMLS_DC );
|
||||
void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_num, _In_ SQLSMALLINT direction, _Inout_ zval* param_z,
|
||||
_In_ SQLSRV_PHPTYPE php_out_type, _In_ SQLSRV_ENCODING encoding, _Inout_ SQLSMALLINT sql_type, _Inout_ SQLULEN column_size,
|
||||
_In_ SQLSRV_PHPTYPE php_out_type, _Inout_ SQLSRV_ENCODING encoding, _Inout_ SQLSMALLINT sql_type, _Inout_ SQLULEN column_size,
|
||||
_Inout_ SQLSMALLINT decimal_digits TSRMLS_DC );
|
||||
SQLRETURN core_sqlsrv_execute( _Inout_ sqlsrv_stmt* stmt TSRMLS_DC, _In_reads_bytes_(sql_len) const char* sql = NULL, _In_ int sql_len = 0 );
|
||||
field_meta_data* core_sqlsrv_field_metadata( _Inout_ sqlsrv_stmt* stmt, _In_ SQLSMALLINT colno TSRMLS_DC );
|
||||
|
|
@ -1639,8 +1644,9 @@ enum SQLSRV_ERROR_CODES {
|
|||
|
||||
SQLSRV_ERROR_ODBC,
|
||||
SQLSRV_ERROR_DRIVER_NOT_INSTALLED,
|
||||
SQLSRV_ERROR_AE_DRIVER_NOT_INSTALLED,
|
||||
SQLSRV_ERROR_CE_DRIVER_REQUIRED,
|
||||
SQLSRV_ERROR_CONNECT_INVALID_DRIVER,
|
||||
SQLSRV_ERROR_SPECIFIED_DRIVER_NOT_FOUND,
|
||||
SQLSRV_ERROR_ZEND_HASH,
|
||||
SQLSRV_ERROR_INVALID_PARAMETER_PHPTYPE,
|
||||
SQLSRV_ERROR_INVALID_PARAMETER_SQLTYPE,
|
||||
|
|
|
|||
|
|
@ -342,7 +342,7 @@ sqlsrv_stmt* core_sqlsrv_create_stmt( _Inout_ sqlsrv_conn* conn, _In_ driver_stm
|
|||
// The sql type is given as a hint if the driver provides it.
|
||||
|
||||
void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_num, _In_ SQLSMALLINT direction, _Inout_ zval* param_z,
|
||||
_In_ SQLSRV_PHPTYPE php_out_type, _In_ SQLSRV_ENCODING encoding, _Inout_ SQLSMALLINT sql_type, _Inout_ SQLULEN column_size,
|
||||
_In_ SQLSRV_PHPTYPE php_out_type, _Inout_ SQLSRV_ENCODING encoding, _Inout_ SQLSMALLINT sql_type, _Inout_ SQLULEN column_size,
|
||||
_Inout_ SQLSMALLINT decimal_digits TSRMLS_DC )
|
||||
{
|
||||
SQLSMALLINT c_type;
|
||||
|
|
@ -373,6 +373,7 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
|
|||
}
|
||||
bool zval_was_null = ( Z_TYPE_P( param_z ) == IS_NULL );
|
||||
bool zval_was_bool = ( Z_TYPE_P( param_z ) == IS_TRUE || Z_TYPE_P( param_z ) == IS_FALSE );
|
||||
bool zval_was_long = ( Z_TYPE_P( param_z ) == IS_LONG && php_out_type == SQLSRV_PHPTYPE_INT && (sql_type == SQL_BIGINT || sql_type == SQL_UNKNOWN_TYPE ));
|
||||
// if the user asks for for a specific type for input and output, make sure the data type we send matches the data we
|
||||
// type we expect back, since we can only send and receive the same type. Anything can be converted to a string, so
|
||||
// we always let that match if they want a string back.
|
||||
|
|
@ -383,7 +384,16 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
|
|||
if( zval_was_null || zval_was_bool ) {
|
||||
convert_to_long( param_z );
|
||||
}
|
||||
match = Z_TYPE_P( param_z ) == IS_LONG;
|
||||
if( zval_was_long ){
|
||||
convert_to_string( param_z );
|
||||
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 {
|
||||
match = Z_TYPE_P( param_z ) == IS_LONG;
|
||||
}
|
||||
break;
|
||||
case SQLSRV_PHPTYPE_FLOAT:
|
||||
if( zval_was_null ) {
|
||||
|
|
@ -415,7 +425,15 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
|
|||
if( direction == SQL_PARAM_OUTPUT ) {
|
||||
switch( php_out_type ) {
|
||||
case SQLSRV_PHPTYPE_INT:
|
||||
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 ) {
|
||||
encoding = SQLSRV_ENCODING_SYSTEM;
|
||||
}
|
||||
}
|
||||
else {
|
||||
convert_to_long( param_z );
|
||||
}
|
||||
break;
|
||||
case SQLSRV_PHPTYPE_FLOAT:
|
||||
convert_to_double( param_z );
|
||||
|
|
@ -440,6 +458,9 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
|
|||
|
||||
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 );
|
||||
}
|
||||
else {
|
||||
// if the sql type is unknown, then set the default based on the PHP type passed in
|
||||
|
|
@ -548,7 +569,7 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
|
|||
buffer, buffer_len TSRMLS_CC );
|
||||
|
||||
// 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 ));
|
||||
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 );
|
||||
|
||||
|
|
@ -1054,7 +1075,7 @@ void core_sqlsrv_next_result( _Inout_ sqlsrv_stmt* stmt TSRMLS_DC, _In_ bool fin
|
|||
CHECK_CUSTOM_ERROR( stmt->past_next_result_end, stmt, SQLSRV_ERROR_NEXT_RESULT_PAST_END ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
|
||||
|
||||
close_active_stream( stmt TSRMLS_CC );
|
||||
|
||||
//Clear column sql types and sql display sizes.
|
||||
|
|
@ -2124,6 +2145,15 @@ void finalize_output_parameters( _Inout_ sqlsrv_stmt* stmt TSRMLS_DC )
|
|||
else {
|
||||
core::sqlsrv_zval_stringl(value_z, str, str_len);
|
||||
}
|
||||
if ( output_param->is_long ) {
|
||||
zval* value_z_temp = ( zval * )sqlsrv_malloc( sizeof( zval ));
|
||||
ZVAL_COPY( value_z_temp, value_z );
|
||||
convert_to_double( value_z_temp );
|
||||
if ( Z_DVAL_P( value_z_temp ) > INT_MIN && Z_DVAL_P( value_z_temp ) < INT_MAX ) {
|
||||
convert_to_long( value_z );
|
||||
}
|
||||
sqlsrv_free( value_z_temp );
|
||||
}
|
||||
}
|
||||
break;
|
||||
case IS_LONG:
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@
|
|||
// Increase Patch for backward compatible fixes.
|
||||
#define SQLVERSION_MAJOR 5
|
||||
#define SQLVERSION_MINOR 1
|
||||
#define SQLVERSION_PATCH 0
|
||||
#define SQLVERSION_PATCH 1
|
||||
#define SQLVERSION_BUILD 0
|
||||
|
||||
// Semantic versioning pre-release
|
||||
|
|
|
|||
|
|
@ -561,6 +561,32 @@ PHP_FUNCTION( sqlsrv_next_result )
|
|||
|
||||
try {
|
||||
|
||||
// Return the correct error in case the user calls sqlsrv_next_result() on a null result set.
|
||||
// Null means that SQLNumResultCols() returns 0 and SQLRowCount does not return > 0. But first
|
||||
// check that the statement has been executed and that we are not past the end of a non-null
|
||||
// result set to make sure the user gets the correct error message. These checks are also
|
||||
// done in core_sqlsrv_next_result(), but we cannot check for null results there because that
|
||||
// function can be called without calling this one, and SQLSRV_ERROR_NO_FIELDS can then
|
||||
// be triggered incorrectly.
|
||||
CHECK_CUSTOM_ERROR( !stmt->executed, stmt, SQLSRV_ERROR_STATEMENT_NOT_EXECUTED ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
|
||||
CHECK_CUSTOM_ERROR( stmt->past_next_result_end, stmt, SQLSRV_ERROR_NEXT_RESULT_PAST_END ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
|
||||
bool has_result = core_sqlsrv_has_any_result( stmt );
|
||||
|
||||
// Note that if fetch_called is false but has_result is true (i.e. the user is calling
|
||||
// sqlsrv_next_result() on a non-null result set before calling fetch()), it is handled
|
||||
// in core_sqlsrv_next_result() below.
|
||||
if( !stmt->fetch_called ) {
|
||||
CHECK_CUSTOM_ERROR( !has_result, stmt, SQLSRV_ERROR_NO_FIELDS ) {
|
||||
throw core::CoreException();
|
||||
}
|
||||
}
|
||||
|
||||
core_sqlsrv_next_result( stmt TSRMLS_CC, true );
|
||||
|
||||
if( stmt->past_next_result_end ) {
|
||||
|
|
|
|||
|
|
@ -397,13 +397,17 @@ ss_error SS_ERRORS[] = {
|
|||
{ IMSSP, (SQLCHAR*) "Invalid value for loading a custom keystore provider.", -104, false}
|
||||
},
|
||||
{
|
||||
SQLSRV_ERROR_AE_DRIVER_NOT_INSTALLED,
|
||||
SQLSRV_ERROR_CE_DRIVER_REQUIRED,
|
||||
{ IMSSP, (SQLCHAR*) "The Always Encrypted feature requires Microsoft ODBC Driver 17 for SQL Server.", -105, false }
|
||||
},
|
||||
{
|
||||
SQLSRV_ERROR_CONNECT_INVALID_DRIVER,
|
||||
{ IMSSP, (SQLCHAR*) "Invalid value %1!s! was specified for Driver option.", -106, true }
|
||||
},
|
||||
{
|
||||
SQLSRV_ERROR_SPECIFIED_DRIVER_NOT_FOUND,
|
||||
{ IMSSP, (SQLCHAR*) "The specified ODBC Driver is not found.", -107, false }
|
||||
},
|
||||
// terminate the list of errors/warnings
|
||||
{ UINT_MAX, {} }
|
||||
};
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ if [ $PLATFORM = "Ubuntu16" ]; then
|
|||
yes | sudo apt-get install -qq unixodbc-dev >> env_setup.log
|
||||
printf "done\n"
|
||||
|
||||
printf "Installing pyodbc"
|
||||
printf "Installing pyodbc..."
|
||||
pip3 install --upgrade pip >> env_setup.log
|
||||
pip3 install pyodbc >> env_setup.log
|
||||
printf "done\n"
|
||||
|
|
@ -79,7 +79,7 @@ elif [ $PLATFORM = "RedHat7" ]; then
|
|||
(yes | sudo yum install -y unixODBC-devel autoconf >> env_setup.log)
|
||||
printf "done\n"
|
||||
|
||||
printf "Installing pyodbc"
|
||||
printf "Installing pyodbc..."
|
||||
pip3 install --upgrade pip >> env_setup.log
|
||||
pip3 install pyodbc >> env_setup.log
|
||||
printf "done\n"
|
||||
|
|
@ -89,8 +89,8 @@ elif [ $PLATFORM = "SUSE12" ]; then
|
|||
sudo zypper refresh >> env_setup.log
|
||||
printf "done\n"
|
||||
|
||||
printf "Installing autoconf, gcc, g++, git, zip, libxml, openssl, python3, pip3..."
|
||||
sudo zypper -n install autoconf gcc gcc-c++ libxml2-devel git zip libopenssl-devel python3-devel python3-pip python3-setuptools >> env_setup.log
|
||||
printf "Installing autoconf, gcc, g++, git, zip, libxml, openssl, python3..."
|
||||
sudo zypper -n install autoconf gcc gcc-c++ libxml2-devel git zip libopenssl-devel python3-devel python3-setuptools >> env_setup.log
|
||||
printf "done\n"
|
||||
|
||||
printf "Installing MSODBCSQL..."
|
||||
|
|
@ -101,9 +101,12 @@ elif [ $PLATFORM = "SUSE12" ]; then
|
|||
zypper -n install unixODBC-devel >> env_setup.log
|
||||
printf "done\n"
|
||||
|
||||
printf "Installing pyodbc"
|
||||
pip3 install --upgrade pip >> env_setup.log
|
||||
pip3 install pyodbc >> env_setup.log
|
||||
printf "Installing pyodbc..."
|
||||
wget https://github.com/mkleehammer/pyodbc/archive/master.zip
|
||||
unzip master.zip
|
||||
cd pyodbc-master/
|
||||
python3 setup.py build >> env_setup.log
|
||||
sudo python3 setup.py install >> env_setup.log
|
||||
printf "done\n"
|
||||
|
||||
elif [ $PLATFORM = "Sierra" ]; then
|
||||
|
|
|
|||
1803
test/functional/pdo_sqlsrv/MsCommon_mid-refactor.inc
Normal file
1803
test/functional/pdo_sqlsrv/MsCommon_mid-refactor.inc
Normal file
|
|
@ -0,0 +1,1803 @@
|
|||
<?php
|
||||
/*
|
||||
Microsoft SQL Server Driver for PHP - Unit Test Framework
|
||||
Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
|
||||
Description:
|
||||
Common functions (shared by all tests).
|
||||
|
||||
*/
|
||||
|
||||
//
|
||||
// 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)
|
||||
{
|
||||
$msodbcsql_ver = $conn->getAttribute(PDO::ATTR_CLIENT_VERSION)["DriverVer"];
|
||||
$server_ver = $conn->getAttribute(PDO::ATTR_SERVER_VERSION);
|
||||
$msodbcsql_maj = explode(".", $msodbcsql_ver)[0];
|
||||
if ($msodbcsql_maj < 17 || explode('.', $server_ver)[0] < 13) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Connect to the database specified in MsSetup.inc; Column Encryption keywords automatically added when $keystore is not none
|
||||
* @param string $keywords : string to append to the dsn string in PDO::_construct
|
||||
* @param array $options : attributes to pass to PDO::_construct
|
||||
* @param int $errmode : specifies how the driver reports failures: one of PDO::ERRMODE_EXCEPTION, PDO::ERRMODE_WARNING, or PDO::ERRMODE_SILENT; default is PDO::ERRMODE_EXCEPTION
|
||||
* @param bool $disableCE : flag for disabling column encryption even when keystore is NOT none
|
||||
* for testing fetching encrypted data when connection column encryption is off
|
||||
* @return PDO connection object
|
||||
*/
|
||||
function connect($keywords = '', $options=array(), $errmode = PDO::ERRMODE_EXCEPTION, $disableCE = false)
|
||||
{
|
||||
try {
|
||||
// simply use $databaseName from MsSetup.inc to facilitate testing in Azure,
|
||||
// which does not support switching databases
|
||||
require("MsSetup.inc");
|
||||
$dsn = getDSN($server, $databaseName, $keywords, $disableCE);
|
||||
$conn = new PDO($dsn, $uid, $pwd, $options);
|
||||
if ($errmode == PDO::ERRMODE_EXCEPTION || $errmode == PDO::ERRMODE_WARNING || $errmode == PDO::ERRMODE_SILENT) {
|
||||
$conn->setAttribute(PDO::ATTR_ERRMODE, $errmode);
|
||||
} else {
|
||||
printf("connect: The errmode provided must be one of exception, warning, or silent.\n");
|
||||
}
|
||||
return $conn;
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
} catch (Exception $e) {
|
||||
var_dump($e->errorInfo);
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @param string $sqlsrvserver : server name
|
||||
* @param string $database : database name
|
||||
* @param string $keywords : string to append to the dsn string in PDO::_construct
|
||||
* @param bool $disableCE : flag for disabling column encryption even when keystore is NOT none
|
||||
* @return string dsn string used for PDO constructor
|
||||
*/
|
||||
function getDSN($sqlsrvserver, $database, $keywords = '', $disableCE = false)
|
||||
{
|
||||
require("MsSetup.inc");
|
||||
$dsn = "";
|
||||
if ($sqlsrvserver) {
|
||||
$dsn .= "sqlsrv:Server=$sqlsrvserver;";
|
||||
} else {
|
||||
printf("getDSN: the sqlsrvserver provided must not be null.\n");
|
||||
exit;
|
||||
}
|
||||
if ($database) {
|
||||
$dsn .= "database=$database;";
|
||||
}
|
||||
if ($keystore != "none" && !$disableCE) {
|
||||
$dsn .= "ColumnEncryption=Enabled;";
|
||||
}
|
||||
if ($keystore == "ksp" && !$disableCE) {
|
||||
require('AE_Ksp.inc');
|
||||
$ksp_path = getKSPPath();
|
||||
$dsn .= "CEKeystoreProvider=$ksp_path;CEKeystoreName=$ksp_name;CEKeystoreEncryptKey=$encrypt_key;";
|
||||
}
|
||||
if ($keywords) {
|
||||
$dsn .= $keywords;
|
||||
}
|
||||
return $dsn;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @return string CEK name depending on the connection keywords
|
||||
*/
|
||||
function getCekName()
|
||||
{
|
||||
require 'MsSetup.inc';
|
||||
$cekName = '';
|
||||
switch ($keystore) {
|
||||
case "none":
|
||||
$cekName = '';
|
||||
break;
|
||||
case "win":
|
||||
$cekName = 'AEColumnKey';
|
||||
break;
|
||||
case "ksp":
|
||||
$cekName = 'CustomCEK';
|
||||
break;
|
||||
case "akv":
|
||||
$cekName = 'AKVColumnKey';
|
||||
break;
|
||||
default:
|
||||
echo "getCekName: Invalid keystore name.\n";
|
||||
}
|
||||
return $cekName;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* class for encapsulating column metadata needed for creating a table
|
||||
*/
|
||||
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 function __construct($dataType, $colName = null, $options = null, $encType = "deterministic")
|
||||
{
|
||||
if (is_null($colName)) {
|
||||
$this->colName = get_default_colname($dataType);
|
||||
} else {
|
||||
$this->colName = $colName;
|
||||
}
|
||||
$this->dataType = $dataType;
|
||||
$this->encType = $encType;
|
||||
$this->options = $options;
|
||||
}
|
||||
/**
|
||||
* @return string column definition for creating a table
|
||||
*/
|
||||
public function getColDef()
|
||||
{
|
||||
//return getColDef($this->colName, $this->dataType, $this->options, $this->encType);
|
||||
$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) {
|
||||
$cekName = getCekName();
|
||||
if (stripos($this->dataType, "char") !== false) {
|
||||
$append .= "COLLATE Latin1_General_BIN2 ";
|
||||
}
|
||||
$append .= sprintf("ENCRYPTED WITH (ENCRYPTION_TYPE = %s, ALGORITHM = 'AEAD_AES_256_CBC_HMAC_SHA_256', COLUMN_ENCRYPTION_KEY = $cekName) ", $this->encType);
|
||||
}
|
||||
$append .= $this->options;
|
||||
$colDef = "[" . $this->colName . "] " . $this->dataType . $append;
|
||||
return $colDef;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @return string default column name when a name is not provided in the ColumnMeta class
|
||||
*/
|
||||
function getDefaultColName($dataType)
|
||||
{
|
||||
$colName = "c_" . str_replace(",", "_", str_replace("(", "_", $dataType));
|
||||
$colName = rtrim($colName, ")");
|
||||
return $colName;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create a table
|
||||
* @param object $conn : PDO connection object
|
||||
* @param string $tbname : name of the table to be created
|
||||
* @param array $columnMetaArr : array of key value pair with column name as key and datatype as value, or array of columnMeta objects, which contain metadata for one column
|
||||
* @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
|
||||
* @return int reporting the number of rows affected (should always be 0 for creating table)
|
||||
*/
|
||||
function createTable($conn, $tbname, $columnMetaArr, $disableCE = false)
|
||||
{
|
||||
try {
|
||||
dropTable($conn, $tbname);
|
||||
$colDef = "";
|
||||
foreach ($columnMetaArr as $key => $value) {
|
||||
if (!is_object($value)) {
|
||||
$cm = new ColumnMeta($value, $key);
|
||||
$colDef = $colDef . $cm->getColDef() . ", ";
|
||||
} elseif (get_class($value) == "ColumnMeta") {
|
||||
$colDef = $colDef . $value->getColDef() . ", ";
|
||||
} else {
|
||||
printf("createTable: The input provided must be an associative array of literal values or ColumnMeta objects.\n");
|
||||
exit;
|
||||
}
|
||||
}
|
||||
$colDef = rtrim($colDef, ", ");
|
||||
$createSql = "CREATE TABLE $tbname ($colDef)";
|
||||
$numRows = $conn->exec($createSql);
|
||||
return $numRows;
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
} catch (Exception $e) {
|
||||
var_dump($e->errorInfo);
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* class for encapsulating optional parameters for PDOStatement::bindParam
|
||||
*/
|
||||
class BindParamOp
|
||||
{
|
||||
public $parameter; //parameter identifier. Parameter name or 1-based index of the parameter
|
||||
public $variable; //name of the PHP variable to bind
|
||||
public $pdoType; //PDO_PARAM_ type specified for PDOStatement::bindParam
|
||||
public $length; //length specified for PDOStatement::bindParam
|
||||
public $options; //options specified for PDOStatement::bindParam
|
||||
|
||||
public function __construct($parameter, $variable, $pdoType = null, $length = null, $options = null)
|
||||
{
|
||||
$this->parameter = $parameter;
|
||||
$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)) {
|
||||
$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");
|
||||
exit;
|
||||
}
|
||||
|
||||
if ($length >= 0) {
|
||||
$this->length = $length;
|
||||
} else {
|
||||
printf("BindParamOp construct: The length provided must be greater or equal to 0.\n");
|
||||
exit;
|
||||
}
|
||||
|
||||
$encodingAttrs = array("PDO::SQLSRV_ENCODING_BINARY", "PDO::SQLSRV_ENCODING_SYSTEM", "PDO::SQLSRV_ENCODING_UTF8", "PDO::SQLSRV_ENCODING_DEFAULT");
|
||||
if (in_array($options, $encodingAttrs)) {
|
||||
$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");
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @param object $stmt : PDO Statement object
|
||||
*/
|
||||
public function bindWithOp($stmt)
|
||||
{
|
||||
// get the constant values of pdoType, and option
|
||||
$pdoType = null;
|
||||
$options = null;
|
||||
if (!is_null($this->pdoType)) {
|
||||
$pdoType = constant($this->pdoType);
|
||||
}
|
||||
if (!is_null($this->options)) {
|
||||
$options = constant($this->options);
|
||||
}
|
||||
$stmt->bindParam($this->parameter, $this->variable, $pdoType, $this->length, $options);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Insert a row into a table
|
||||
* @param object $conn : PDO connection object
|
||||
* @param string $tbname : name of the table for the row to be inserted
|
||||
* @param array $inputs : an associative array column name and its value; value may be a literal value or a BindParamOp object
|
||||
* @param string $api : PDO_SQLSRV API used for executing the insert query
|
||||
* accepted values: "exec", "query", "prepareDirect", "prepareExecuteBind", "prepareBindParam"
|
||||
* @param bool $r : true if the row was successfully inserted, otherwise false. Default value is null to make this parameter optional.
|
||||
* @return object PDOStatement object of the insert statement
|
||||
*/
|
||||
function insertRow($conn, $tbname, $inputs, $api = null, &$r = null)
|
||||
{
|
||||
try {
|
||||
// set the default API being called depending on if column is encrypted
|
||||
if (is_null($api)) {
|
||||
if (!isColEncrypted()) {
|
||||
$api = "query";
|
||||
} else {
|
||||
$api = "prepareBindParam";
|
||||
}
|
||||
}
|
||||
$stmt = null;
|
||||
if (!isColEncrypted() && $api != "prepareExecuteBind" && $api != "prepareBindParam") {
|
||||
$insertSql = getInsertSqlComplete($tbname, $inputs);
|
||||
switch ($api) {
|
||||
case "exec":
|
||||
$conn->exec($insertSql);
|
||||
break;
|
||||
case "query":
|
||||
$stmt = $conn->query($insertSql);
|
||||
break;
|
||||
case "prepareDirect":
|
||||
$stmt = $conn->prepare($insertSql);
|
||||
$r = $stmt->execute();
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
// if AE is on, must bind param
|
||||
$insertSql = getInsertSqlPlaceholders($tbname, $inputs);
|
||||
$stmt = $conn->prepare($insertSql);
|
||||
if ($api == "prepareExecuteBind") {
|
||||
$params = array_values($inputs);
|
||||
$r = $stmt->execute($params);
|
||||
} else {
|
||||
$i = 1;
|
||||
foreach ($inputs as $key => $value) {
|
||||
if (!is_object($value)) {
|
||||
$stmt->bindParam($i, $inputs[$key]);
|
||||
} elseif (get_class($value) == "BindParamOp") {
|
||||
$value->bindWithOp($stmt);
|
||||
} else {
|
||||
printf("insertRow: The inputs provided must be a literal value or a BindParamOp object.\n");
|
||||
exit;
|
||||
}
|
||||
$i++;
|
||||
}
|
||||
$r = $stmt->execute();
|
||||
}
|
||||
}
|
||||
return $stmt;
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
} catch (Exception $e) {
|
||||
var_dump($e->errorInfo);
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @param string $tbname : name of the table for an insert sql
|
||||
* @param array $inputs : associative array containing a key value pair of column name and data to put into an insert sql string
|
||||
* @return string a complete insert sql string
|
||||
*/
|
||||
function getInsertSqlComplete($tbname, $inputs)
|
||||
{
|
||||
$colStr = "INSERT INTO $tbname (";
|
||||
$valStr = "VALUES (";
|
||||
if (empty($inputs)) {
|
||||
echo "getInsertSqlComplete: inputs for inserting a row cannot be empty.\n";
|
||||
return;
|
||||
}
|
||||
foreach ($inputs as $key => $value) {
|
||||
$colStr .= $key . ", ";
|
||||
if (is_null($value)) {
|
||||
$valStr .= "null, ";
|
||||
} elseif (is_string($value)) {
|
||||
$valStr .= "'" . $value . "', ";
|
||||
} else {
|
||||
$valStr .= $value . ", ";
|
||||
}
|
||||
}
|
||||
$colStr = rtrim($colStr, ", ") . ") ";
|
||||
$valStr = rtrim($valStr, ", ") . ") ";
|
||||
$insertSql = $colStr . $valStr;
|
||||
return $insertSql;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @param string $tbname : name of the table for an insert sql
|
||||
* @param array $input : associative array containing a key value pair of column name and data to put into an insert sql string
|
||||
* @return string an insert sql string with "?" placeholders for all values
|
||||
*/
|
||||
function getInsertSqlPlaceholders($tbname, $inputs)
|
||||
{
|
||||
if (empty($inputs)) {
|
||||
echo "getInsertSqlPlaceholders: inputs for inserting a row cannot be empty.\n";
|
||||
return "";
|
||||
}
|
||||
$colStr = "INSERT INTO $tbname (";
|
||||
$valStr = "VALUES (";
|
||||
foreach ($inputs as $key => $value) {
|
||||
$colStr .= $key . ", ";
|
||||
}
|
||||
$colStr = rtrim($colStr, ", ") . ") ";
|
||||
$valStr .= getSeqPlaceholders(count($inputs)) . ") ";
|
||||
$insertSql = $colStr . $valStr;
|
||||
return $insertSql;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @param string $spname : name of the stored procedure
|
||||
* @param int $num : number of parameters needed for the stored procedure
|
||||
* @return string a call stored procedure sql string with "?" placeholders for all parameters
|
||||
*/
|
||||
function getCallProcSqlPlaceholders($spname, $num)
|
||||
{
|
||||
$callStr = "{CALL $spname (";
|
||||
$callStr .= getSeqPlaceholders($num) . ")} ";
|
||||
return $callStr;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @param int $num : number of placeholders needed
|
||||
* @return string a string containing $num number of repeated "?" placeholders delimited by ", "
|
||||
*/
|
||||
function getSeqPlaceholders($num)
|
||||
{
|
||||
if ($num <= 0) {
|
||||
echo "getSeqPlaceholders: num provided for creating a sequence of placeholders cannot be less than 0.\n";
|
||||
return;
|
||||
}
|
||||
$placeholderStr = str_repeat("?, ", $num);
|
||||
$placeholderStr = rtrim($placeholderStr, ", ");
|
||||
return $placeholderStr;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Fetch all rows and all columns given a table name, and print them
|
||||
* @param object $conn : PDO connection object
|
||||
* @param string $tbname : name of the table to fetch from
|
||||
*/
|
||||
function fetchAll($conn, $tbname)
|
||||
{
|
||||
try {
|
||||
$sql = "SELECT * FROM $tbname";
|
||||
$stmt = $conn->query($sql);
|
||||
while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
|
||||
foreach ($row as $key => $value) {
|
||||
print("$key: $value\n");
|
||||
}
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
} catch (Exception $e) {
|
||||
var_dump($e->errorInfo);
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Use PDOStatement::fetchAll to fetch all rows given a table name
|
||||
* @param object $conn : PDO connection object
|
||||
* @param string $tbname : name of the table to fetch from
|
||||
* @param string $fetchStyle : fetch_style argument passed to PDOStatement::fetchAll
|
||||
* @return array rows in a result set
|
||||
*/
|
||||
function selectAll($conn, $tbname, $fetchStyle = null)
|
||||
{
|
||||
try {
|
||||
$sql = "SELECT * FROM $tbname";
|
||||
$stmt = $conn->query($sql);
|
||||
if ($fetchStyle) {
|
||||
$fetchStyle = constant($fetchStyle);
|
||||
}
|
||||
$data = $stmt->fetchAll($fetchStyle);
|
||||
return $data;
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
} catch (Exception $e) {
|
||||
var_dump($e->errorInfo);
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Use PDOStatement::fetch to fetch a row given a table name
|
||||
* @param object $conn : PDO connection object
|
||||
* @param string $tbname : name of the table to fetch from
|
||||
* @param string $fetchStyle : fetch_style argument passed to PDOStatement::fetch
|
||||
* @return array a row from the result set
|
||||
*/
|
||||
function selectRow($conn, $tbname, $fetchStyle = null)
|
||||
{
|
||||
try {
|
||||
$sql = "SELECT * FROM $tbname";
|
||||
$stmt = $conn->query($sql);
|
||||
$row = $stmt->fetch(constant($fetchStyle));
|
||||
return $row;
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
} catch (Exception $e) {
|
||||
var_dump($e->errorInfo);
|
||||
exit;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @return bool false if $keystore specified in MsSetup.inc is none, otherwise return true
|
||||
*/
|
||||
function isColEncrypted()
|
||||
{
|
||||
require 'MsSetup.inc';
|
||||
if ($keystore == "none" || !$dataEncrypted) {
|
||||
return false;
|
||||
} else {
|
||||
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
|
||||
}
|
||||
|
||||
|
||||
function my_print_r($to_print)
|
||||
{
|
||||
global $verbose;
|
||||
if ($verbose) {
|
||||
print_r($to_print);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function TestMode()
|
||||
{
|
||||
$testMode = getenv('PHPT_EXEC');
|
||||
return ($testMode ? true : false);
|
||||
}
|
||||
|
||||
function IsPdoMode()
|
||||
{
|
||||
require 'MsSetup.inc';
|
||||
return (($driverType === true) ? true : false);
|
||||
}
|
||||
|
||||
|
||||
function TraceMode()
|
||||
{
|
||||
require 'MsSetup.inc';
|
||||
return ((!TestMode() && $traceEnabled) ? true : false);
|
||||
}
|
||||
|
||||
function IsMarsSupported()
|
||||
{
|
||||
require 'MsSetup.inc';
|
||||
return ($marsMode ? true : false);
|
||||
}
|
||||
|
||||
function IsDaasMode()
|
||||
{
|
||||
require 'MsSetup.inc';
|
||||
return ($daasMode ? true : false);
|
||||
}
|
||||
|
||||
function FatalError($errorMsg)
|
||||
{
|
||||
if (!IsPdoMode()) {
|
||||
handle_errors();
|
||||
}
|
||||
die("$errorMsg\n");
|
||||
}
|
||||
|
||||
function Trace($msg)
|
||||
{
|
||||
if (TraceMode()) {
|
||||
echo $msg;
|
||||
}
|
||||
}
|
||||
|
||||
function TraceEx($msg, $exitMode)
|
||||
{
|
||||
if ($exitMode) {
|
||||
FatalError($msg);
|
||||
} else {
|
||||
Trace("$msg\n");
|
||||
}
|
||||
}
|
||||
|
||||
function TraceData($sqlType, $data)
|
||||
{
|
||||
if (TraceMode()) {
|
||||
$msg = strtoupper(" $sqlType:");
|
||||
echo "$msg\t";
|
||||
if (strlen($msg) <= 7) {
|
||||
echo "\t";
|
||||
}
|
||||
if (strlen($msg) <= 15) {
|
||||
echo "\t";
|
||||
}
|
||||
echo "$data\n"
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
function StartTest($testName)
|
||||
{
|
||||
require 'MsSetup.inc';
|
||||
|
||||
if (TraceMode()) {
|
||||
echo "$PhpDriver: starting \"$testName\" test...\n\n";
|
||||
}
|
||||
|
||||
if (!extension_loaded(IsPdoMode() ? "pdo" : "sqlsrv")) {
|
||||
die("$PhpDriver cannot be loaded.");
|
||||
}
|
||||
|
||||
// Set timezone
|
||||
$tz = ini_get('date.timezone');
|
||||
if (strcmp($tz, "") == 0) {
|
||||
date_default_timezone_set('America/Los_Angeles');
|
||||
$tz = date_default_timezone_get();
|
||||
}
|
||||
Trace("Timezone: $tz.\n");
|
||||
}
|
||||
|
||||
function EndTest($testName)
|
||||
{
|
||||
require 'MsSetup.inc';
|
||||
|
||||
if (TraceMode()) {
|
||||
echo "\n$PhpDriver: "
|
||||
;
|
||||
}
|
||||
echo "Test \"$testName\" completed successfully.\n"
|
||||
;
|
||||
}
|
||||
|
||||
|
||||
function Setup()
|
||||
{
|
||||
set_time_limit(0);
|
||||
|
||||
if (IsPdoMode()) { // PDO setup
|
||||
} else { // PHP setup
|
||||
sqlsrv_configure('LogSubsystems', SQLSRV_LOG_SYSTEM_ALL);
|
||||
sqlsrv_configure('LogSeverity', SQLSRV_LOG_SEVERITY_ALL);
|
||||
sqlsrv_configure('WarningsReturnAsErrors', 1);
|
||||
}
|
||||
}
|
||||
|
||||
function Configure($param, $expected)
|
||||
{
|
||||
if (!IsPdoMode()) {
|
||||
sqlsrv_configure($param, $expected);
|
||||
$actual = sqlsrv_get_config($param);
|
||||
|
||||
if ($actual == $expected) {
|
||||
Trace("Set configuration parameter $param = $actual.\n");
|
||||
} else {
|
||||
die("Failed to set configuration parameter $param = $expected.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function getTableName($table = '')
|
||||
{
|
||||
$timestamp = round(microtime(true)*1000);
|
||||
|
||||
if (strlen($table) == 0) {
|
||||
$table = 'php_test_table';
|
||||
}
|
||||
|
||||
return $table . '_' . $timestamp;
|
||||
}
|
||||
|
||||
function getProcName($proc = '')
|
||||
{
|
||||
// A temporary stored procedure name with the '#' prefix will be
|
||||
// automatically dropped once the connection is closed. Otherwise,
|
||||
// the caller should take care of dropping the temp procedure afterwards.
|
||||
|
||||
$timestamp = round(microtime(true)*1000);
|
||||
|
||||
if (strlen($proc) == 0) {
|
||||
$proc = 'php_test_proc';
|
||||
}
|
||||
|
||||
return $proc . '_' . $timestamp;
|
||||
}
|
||||
|
||||
function PDOConnect($className, $serverName, $user, $pwd, $exitMode)
|
||||
{
|
||||
require 'MsSetup.inc';
|
||||
$conn = null;
|
||||
|
||||
try {
|
||||
// simply use $databaseName from MsSetup.inc to facilitate testing in Azure,
|
||||
// which does not support switching databases
|
||||
$conn = new $className("sqlsrv:Server=$serverName;Database=$databaseName", $user, $pwd, $connectionOptions);
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_ENCODING, PDO::SQLSRV_ENCODING_SYSTEM);
|
||||
} catch (PDOException $e) {
|
||||
$conn = null;
|
||||
TraceEx("\nFailed to connect to $serverName: ".$e->getMessage(), $exitMode);
|
||||
}
|
||||
|
||||
return ($conn);
|
||||
}
|
||||
|
||||
|
||||
function ExecuteQuery($conn, $tsql)
|
||||
{
|
||||
$stmt = null;
|
||||
|
||||
if (IsPdoMode()) { // PDO
|
||||
try {
|
||||
$stmt = $conn->query($tsql);
|
||||
} catch (PDOException $e) {
|
||||
$stmt = null;
|
||||
FatalError("Query execution failed for $tsql: ".$e->getMessage());
|
||||
}
|
||||
} else { // PHP
|
||||
$stmt = sqlsrv_query($conn, $tsql);
|
||||
if ($stmt === false) {
|
||||
FatalError("Query execution failed for $tsql");
|
||||
}
|
||||
}
|
||||
return ($stmt);
|
||||
}
|
||||
|
||||
|
||||
function PrepareQuery($conn, $tsql)
|
||||
{
|
||||
$stmt = null;
|
||||
|
||||
if (IsPdoMode()) { // PDO
|
||||
try {
|
||||
$stmt = $conn->prepare($tsql);
|
||||
} catch (PDOException $e) {
|
||||
$stmt = null;
|
||||
FatalError("Query preparation failed for $tsql: ".$e->getMessage());
|
||||
}
|
||||
} else { // PHP
|
||||
$stmt = sqlsrv_prepare($conn, $tsql);
|
||||
if ($stmt === false) {
|
||||
FatalError("Query preparation failed for $tsql");
|
||||
}
|
||||
}
|
||||
|
||||
return ($stmt);
|
||||
}
|
||||
|
||||
|
||||
function ExecuteQueryEx($conn, $tsql, $modeDirect)
|
||||
{
|
||||
$stmt = null;
|
||||
|
||||
if ($modeDirect) { // direct execution
|
||||
if (IsPdoMode()) { // PDO
|
||||
try {
|
||||
$stmt = $conn->query($tsql);
|
||||
} catch (PDOException $e) {
|
||||
$stmt = null;
|
||||
}
|
||||
} else { // PHP
|
||||
$stmt = sqlsrv_query($conn, $tsql);
|
||||
}
|
||||
} else {
|
||||
$stmt = PrepareQuery($conn, $tsql);
|
||||
if (IsPdoMode()) {
|
||||
$stmt->execute();
|
||||
} else {
|
||||
sqlsrv_execute($stmt);
|
||||
}
|
||||
}
|
||||
|
||||
return ($stmt);
|
||||
}
|
||||
|
||||
|
||||
function GetSqlType($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 1: return ("int");
|
||||
case 2: return ("tinyint");
|
||||
case 3: return ("smallint");
|
||||
case 4: return ("bigint");
|
||||
case 5: return ("bit");
|
||||
case 6: return ("float");
|
||||
case 7: return ("real");
|
||||
case 8: return ("decimal(28,4)");
|
||||
case 9: return ("numeric(32,4)");
|
||||
case 10: return ("money");
|
||||
case 11: return ("smallmoney");
|
||||
case 12: return ("char(512)");
|
||||
case 13: return ("varchar(512)");
|
||||
case 14: return ("varchar(max)");
|
||||
case 15: return ("nchar(512)");
|
||||
case 16: return ("nvarchar(512)");
|
||||
case 17: return ("nvarchar(max)");
|
||||
case 18: return ("text");
|
||||
case 19: return ("ntext");
|
||||
case 20: return ("binary(512)");
|
||||
case 21: return ("varbinary(512)");
|
||||
case 22: return ("varbinary(max)");
|
||||
case 23: return ("image");
|
||||
case 24: return ("uniqueidentifier");
|
||||
case 25: return ("datetime");
|
||||
case 26: return ("smalldatetime");
|
||||
case 27: return ("timestamp");
|
||||
case 28: return ("xml");
|
||||
default: break;
|
||||
}
|
||||
return ("udt");
|
||||
}
|
||||
|
||||
function GetDriverType($k, $dataSize)
|
||||
{
|
||||
switch ($k) {
|
||||
case 1: return (SQLSRV_SQLTYPE_INT);
|
||||
case 2: return (SQLSRV_SQLTYPE_TINYINT);
|
||||
case 3: return (SQLSRV_SQLTYPE_SMALLINT);
|
||||
case 4: return (SQLSRV_SQLTYPE_BIGINT);
|
||||
case 5: return (SQLSRV_SQLTYPE_BIT);
|
||||
case 6: return (SQLSRV_SQLTYPE_FLOAT);
|
||||
case 7: return (SQLSRV_SQLTYPE_REAL);
|
||||
case 8: return (SQLSRV_SQLTYPE_DECIMAL(28, 4));
|
||||
case 9: return (SQLSRV_SQLTYPE_NUMERIC(32, 4));
|
||||
case 10: return (SQLSRV_SQLTYPE_MONEY);
|
||||
case 11: return (SQLSRV_SQLTYPE_SMALLMONEY);
|
||||
case 12: return (SQLSRV_SQLTYPE_CHAR($dataSize));
|
||||
case 13: return (SQLSRV_SQLTYPE_VARCHAR($dataSize));
|
||||
case 14: return (SQLSRV_SQLTYPE_VARCHAR('max'));
|
||||
case 15: return (SQLSRV_SQLTYPE_NCHAR($dataSize));
|
||||
case 16: return (SQLSRV_SQLTYPE_NVARCHAR($dataSize));
|
||||
case 17: return (SQLSRV_SQLTYPE_NVARCHAR('max'));
|
||||
case 18: return (SQLSRV_SQLTYPE_TEXT);
|
||||
case 19: return (SQLSRV_SQLTYPE_NTEXT);
|
||||
case 20: return (SQLSRV_SQLTYPE_BINARY($dataSize));
|
||||
case 21: return (SQLSRV_SQLTYPE_VARBINARY($dataSize));
|
||||
case 22: return (SQLSRV_SQLTYPE_VARBINARY('max'));
|
||||
case 23: return (SQLSRV_SQLTYPE_IMAGE);
|
||||
case 24: return (SQLSRV_SQLTYPE_UNIQUEIDENTIFIER);
|
||||
case 25: return (SQLSRV_SQLTYPE_DATETIME);
|
||||
case 26: return (SQLSRV_SQLTYPE_SMALLDATETIME);
|
||||
case 27: return (SQLSRV_SQLTYPE_TIMESTAMP);
|
||||
case 28: return (SQLSRV_SQLTYPE_XML);
|
||||
default: break;
|
||||
}
|
||||
return (SQLSRV_SQLTYPE_UDT);
|
||||
}
|
||||
|
||||
function IsStreamable($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 12: return (true); // nchar(512)
|
||||
case 13: return (true); // varchar(512)
|
||||
case 14: return (true); // varchar(max)
|
||||
case 15: return (true); // nchar(512)
|
||||
case 16: return (true); // nvarchar(512)
|
||||
case 17: return (true); // nvarchar(max)
|
||||
case 18: return (true); // text
|
||||
case 19: return (true); // ntext
|
||||
case 20: return (true); // binary
|
||||
case 21: return (true); // varbinary(512)
|
||||
case 22: return (true); // varbinary(max)
|
||||
case 23: return (true); // image
|
||||
case 28: return (true); // xml
|
||||
default: break;
|
||||
}
|
||||
return (false);
|
||||
}
|
||||
|
||||
function IsNumeric($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 1: return (true); // int
|
||||
case 2: return (true); // tinyint
|
||||
case 3: return (true); // smallint
|
||||
case 4: return (true); // bigint
|
||||
case 5: return (true); // bit
|
||||
case 6: return (true); // float
|
||||
case 7: return (true); // real
|
||||
case 8: return (true); // decimal(28,4)
|
||||
case 9: return (true); // numeric(32,4)
|
||||
case 10: return (true); // money
|
||||
case 11: return (true); // smallmoney
|
||||
default: break;
|
||||
}
|
||||
return (false);
|
||||
}
|
||||
|
||||
function IsChar($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 12: return (true); // nchar(512)
|
||||
case 13: return (true); // varchar(512)
|
||||
case 14: return (true); // varchar(max)
|
||||
case 15: return (true); // nchar(512)
|
||||
case 16: return (true); // nvarchar(512)
|
||||
case 17: return (true); // nvarchar(max)
|
||||
case 18: return (true); // text
|
||||
case 19: return (true); // ntext
|
||||
case 28: return (true); // xml
|
||||
default: break;
|
||||
}
|
||||
return (false);
|
||||
}
|
||||
|
||||
function IsBinary($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 20: return (true); // binary
|
||||
case 21: return (true); // varbinary(512)
|
||||
case 22: return (true); // varbinary(max)
|
||||
case 23: return (true); // image
|
||||
default: break;
|
||||
}
|
||||
return (false);
|
||||
}
|
||||
|
||||
function IsDateTime($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 25: return (true); // datetime
|
||||
case 26: return (true); // smalldatetime
|
||||
case 27: return (true); // timestamp
|
||||
default: break;
|
||||
}
|
||||
return (false);
|
||||
}
|
||||
|
||||
function IsUnicode($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 15: return (true); // nchar(512)
|
||||
case 16: return (true); // nvarchar(512)
|
||||
case 17: return (true); // nvarchar(max)
|
||||
case 19: return (true); // ntext
|
||||
default: break;
|
||||
}
|
||||
return (false);
|
||||
}
|
||||
|
||||
function IsUpdatable($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 27: return (false); // timestamp
|
||||
default: break;
|
||||
}
|
||||
return (true);
|
||||
}
|
||||
|
||||
function IsLiteral($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 12: return (true); // nchar(512)
|
||||
case 13: return (true); // varchar(512)
|
||||
case 14: return (true); // varchar(max)
|
||||
case 15: return (true); // nchar(512)
|
||||
case 16: return (true); // nvarchar(512)
|
||||
case 17: return (true); // nvarchar(max)
|
||||
case 18: return (true); // text
|
||||
case 19: return (true); // ntext
|
||||
case 24: return (true); // uniqueidentifier
|
||||
case 25: return (true); // datetime
|
||||
case 26: return (true); // smalldatetime
|
||||
case 28: return (true); // xml
|
||||
default: break;
|
||||
}
|
||||
return (false);
|
||||
}
|
||||
|
||||
function GetMetadata($k, $info)
|
||||
{
|
||||
if (strcasecmp($info, 'Name') == 0) {
|
||||
return (getColName($k));
|
||||
}
|
||||
if (strcasecmp($info, 'Size') == 0) {
|
||||
return (getColSize($k));
|
||||
}
|
||||
if (strcasecmp($info, 'Precision') == 0) {
|
||||
return (getColPrecision($k));
|
||||
}
|
||||
if (strcasecmp($info, 'Scale') == 0) {
|
||||
return (getColScale($k));
|
||||
}
|
||||
if (strcasecmp($info, 'Nullable') == 0) {
|
||||
return (getColNullable($k));
|
||||
}
|
||||
return ("");
|
||||
}
|
||||
|
||||
function GetColName($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 1: return ("c1_int");
|
||||
case 2: return ("c2_tinyint");
|
||||
case 3: return ("c3_smallint");
|
||||
case 4: return ("c4_bigint");
|
||||
case 5: return ("c5_bit");
|
||||
case 6: return ("c6_float");
|
||||
case 7: return ("c7_real");
|
||||
case 8: return ("c8_decimal");
|
||||
case 9: return ("c9_numeric");
|
||||
case 10: return ("c10_money");
|
||||
case 11: return ("c11_smallmoney");
|
||||
case 12: return ("c12_char");
|
||||
case 13: return ("c13_varchar");
|
||||
case 14: return ("c14_varchar_max");
|
||||
case 15: return ("c15_nchar");
|
||||
case 16: return ("c16_nvarchar");
|
||||
case 17: return ("c17_nvarchar_max");
|
||||
case 18: return ("c18_text");
|
||||
case 19: return ("c19_ntext");
|
||||
case 20: return ("c20_binary");
|
||||
case 21: return ("c21_varbinary");
|
||||
case 22: return ("c22_varbinary_max");
|
||||
case 23: return ("c23_image");
|
||||
case 24: return ("c24_uniqueidentifier");
|
||||
case 25: return ("c25_datetime");
|
||||
case 26: return ("c26_smalldatetime");
|
||||
case 27: return ("c27_timestamp");
|
||||
case 28: return ("c28_xml");
|
||||
default: break;
|
||||
}
|
||||
return ("");
|
||||
}
|
||||
|
||||
|
||||
function GetColSize($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 12: return ("512");
|
||||
case 13: return ("512");
|
||||
case 14: return ("0");
|
||||
case 15: return ("512");
|
||||
case 16: return ("512");
|
||||
case 17: return ("0");
|
||||
case 18: return ("2147483647");
|
||||
case 19: return ("1073741823");
|
||||
case 20: return ("512");
|
||||
case 21: return ("512");
|
||||
case 22: return ("0)");
|
||||
case 23: return ("2147483647");
|
||||
case 24: return ("36");
|
||||
//case 25: return ("23");
|
||||
//case 26: return ("16");
|
||||
case 27: return ("8");
|
||||
case 28: return ("0");
|
||||
default: break;
|
||||
}
|
||||
return ("");
|
||||
}
|
||||
|
||||
function GetColPrecision($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 1: return ("10");
|
||||
case 2: return ("3");
|
||||
case 3: return ("5");
|
||||
case 4: return ("19");
|
||||
case 5: return ("1");
|
||||
case 6: return ("53");
|
||||
case 7: return ("24");
|
||||
case 8: return ("28");
|
||||
case 9: return ("32");
|
||||
case 10: return ("19");
|
||||
case 11: return ("10");
|
||||
case 25: return ("23");
|
||||
case 26: return ("16");
|
||||
default: break;
|
||||
}
|
||||
return ("");
|
||||
}
|
||||
|
||||
function GetColScale($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 8: return ("4");
|
||||
case 9: return ("4");
|
||||
case 10: return ("4");
|
||||
case 11: return ("4");
|
||||
case 25: return ("3");
|
||||
case 26: return ("0");
|
||||
default: break;
|
||||
}
|
||||
return ("");
|
||||
}
|
||||
|
||||
function GetColNullable($k)
|
||||
{
|
||||
return (IsUpdatable($k) ? "1" : "0");
|
||||
}
|
||||
|
||||
function GetSampleData($k)
|
||||
{
|
||||
switch ($k) {
|
||||
case 1: // int
|
||||
return ("123456789");
|
||||
|
||||
case 2: // tinyint
|
||||
return ("234");
|
||||
|
||||
case 3: // smallint
|
||||
return ("5678");
|
||||
|
||||
case 4: // bigint
|
||||
return ("123456789987654321");
|
||||
|
||||
|
||||
case 5: // bit
|
||||
return ("1");
|
||||
|
||||
case 6: // float
|
||||
return ("123.456");
|
||||
|
||||
case 7: // real
|
||||
return ("789.012");
|
||||
|
||||
case 8: // decimal
|
||||
return ("12.34");
|
||||
|
||||
case 9: // numeric
|
||||
return ("567.89");
|
||||
|
||||
case 10:// money
|
||||
return ("321.54");
|
||||
|
||||
case 11:// smallmoney
|
||||
return ("67.89");
|
||||
|
||||
case 12:// char
|
||||
case 15:// nchar
|
||||
return ("The quick brown fox jumps over the lazy dog");
|
||||
|
||||
case 13:// varchar
|
||||
case 16:// nvarchar
|
||||
return ("The quick brown fox jumps over the lazy dog 9876543210");
|
||||
|
||||
case 14:// varchar(max)
|
||||
case 17:// nvarchar(max)
|
||||
return ("The quick brown fox jumps over the lazy dog 0123456789");
|
||||
|
||||
case 18:// text
|
||||
case 19:// ntext
|
||||
return ("0123456789 The quick brown fox jumps over the lazy dog");
|
||||
|
||||
case 20:// binary
|
||||
return ("0123456789");
|
||||
|
||||
case 21:// varbinary
|
||||
return ("01234567899876543210");
|
||||
|
||||
case 22:// varbinary(max)
|
||||
return ("98765432100123456789");
|
||||
|
||||
case 23:// image
|
||||
return ("01234567899876543210");
|
||||
|
||||
case 24:// uniqueidentifier
|
||||
return ("12345678-9012-3456-7890-123456789012");
|
||||
|
||||
case 25:// datetime
|
||||
case 26:// smalldatetime
|
||||
return (date("Y-m-d"));
|
||||
|
||||
case 27:// timestamp
|
||||
return (null);
|
||||
|
||||
case 28:// xml
|
||||
return ("<XmlTestData><Letters1>The quick brown fox jumps over the lazy dog</Letters1><Digits1>0123456789</Digits1></XmlTestData>");
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return (null);
|
||||
}
|
||||
|
||||
|
||||
function CreateDB($conn, $dbName)
|
||||
{
|
||||
Trace("Creating database $dbName ...");
|
||||
$tsql = "CREATE DATABASE [$dbName]";
|
||||
DropDB($conn, $dbName);
|
||||
|
||||
if (IsPdoMode()) {
|
||||
$outcome = $conn->exec($tsql);
|
||||
if ($outcome === false) {
|
||||
FatalError("Failed to create test database: $dbName");
|
||||
}
|
||||
} else {
|
||||
$stmt = sqlsrv_query($conn, $tsql);
|
||||
if ($stmt === false) {
|
||||
FatalError("Failed to create test database: $dbName");
|
||||
}
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
Trace(" completed successfully.\n");
|
||||
}
|
||||
|
||||
function DropDB($conn, $dbName)
|
||||
{
|
||||
$tsql = "DROP DATABASE [$dbName]";
|
||||
if (IsPdoMode()) {
|
||||
$mode = $conn->getAttribute(PDO::ATTR_ERRMODE);
|
||||
|
||||
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
|
||||
|
||||
$outcome = $conn->exec($tsql);
|
||||
$conn->setAttribute(PDO::ATTR_ERRMODE, $mode);
|
||||
} else {
|
||||
$stmt = sqlsrv_query($conn, $tsql);
|
||||
if ($stmt === false) {
|
||||
} else {
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
function CreateTable($conn, $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);
|
||||
if (IsDaasMode())
|
||||
{
|
||||
$colIndex = "[c1_int], [c2_tinyint], [c3_smallint], [c4_bigint], [c5_bit], [c6_float], [c7_real], [c8_decimal], [c9_numeric]";
|
||||
CreateTableIndex($conn, $tableName, $colIndex);
|
||||
}
|
||||
}
|
||||
*/
|
||||
function CreateTableEx($conn, $tableName, $dataType)
|
||||
{
|
||||
Trace("Creating table $tableName ...");
|
||||
$tsql = "CREATE TABLE [$tableName] ($dataType)";
|
||||
DropTable($conn, $tableName);
|
||||
|
||||
if (IsPdoMode()) {
|
||||
$outcome = $conn->exec($tsql);
|
||||
if ($outcome === false) {
|
||||
FatalError("Failed to create test table: $tsql");
|
||||
}
|
||||
} else {
|
||||
$stmt = sqlsrv_query($conn, $tsql);
|
||||
if ($stmt === false) {
|
||||
FatalError("Failed to create test table: $tsql");
|
||||
}
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
Trace(" completed successfully.\n");
|
||||
}
|
||||
|
||||
|
||||
function CreateTableIndex($conn, $tableName, $colIndex)
|
||||
{
|
||||
require 'MsSetup.inc';
|
||||
CreateTableIndexEx($conn, $tableName, $tableIndex, $colIndex);
|
||||
}
|
||||
|
||||
|
||||
function CreateTableIndexEx($conn, $tableName, $tableIndex, $colIndex)
|
||||
{
|
||||
Trace("Creating table index for $tableName ...");
|
||||
$sqlIndex = "CREATE CLUSTERED INDEX [$tableIndex] ON [$tableName]($colIndex)";
|
||||
if (IsPdoMode()) {
|
||||
$outcome = $conn->exec($sqlIndex);
|
||||
if ($outcome === false) {
|
||||
FatalError("Failed to create clustered index for test table: $sqlIndex");
|
||||
}
|
||||
} else {
|
||||
$stmt = sqlsrv_query($conn, $sqlIndex);
|
||||
if ($stmt === false) {
|
||||
FatalError("Failed to create clustered index for test table: $sqlIndex");
|
||||
}
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
Trace(" completed successfully.\n");
|
||||
}
|
||||
|
||||
function CreateUniqueIndex($conn, $tableName, $colIndex)
|
||||
{
|
||||
require 'MsSetup.inc';
|
||||
CreateUniqueIndexEx($conn, $tableName, $tableIndex, $colIndex);
|
||||
}
|
||||
|
||||
function CreateUniqueIndexEx($conn, $tableName, $tableIndex, $colIndex)
|
||||
{
|
||||
Trace("Creating unique table index for $tableName ...");
|
||||
$sqlIndex = "CREATE UNIQUE INDEX [$tableIndex] ON [$tableName]($colIndex)";
|
||||
if (IsPdoMode()) {
|
||||
$outcome = $conn->exec($sqlIndex);
|
||||
if ($outcome === false) {
|
||||
FatalError("Failed to create unique index for test table: $sqlIndex");
|
||||
}
|
||||
} else {
|
||||
$stmt = sqlsrv_query($conn, $sqlIndex);
|
||||
if ($stmt === false) {
|
||||
FatalError("Failed to create unique index for test table: $sqlIndex");
|
||||
}
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
Trace(" completed successfully.\n");
|
||||
}
|
||||
|
||||
function dropTable($conn, $tableName)
|
||||
{
|
||||
$tsql = "IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'" . $tableName . "') AND type in (N'U')) DROP TABLE $tableName";
|
||||
if (IsPdoMode()) {
|
||||
$mode = $conn->getAttribute(PDO::ATTR_ERRMODE);
|
||||
|
||||
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
|
||||
|
||||
$outcome = $conn->exec($tsql);
|
||||
$conn->setAttribute(PDO::ATTR_ERRMODE, $mode);
|
||||
} else {
|
||||
$stmt = sqlsrv_query($conn, $tsql);
|
||||
if ($stmt === false) {
|
||||
} else {
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function SelectFromTable($conn, $tableName)
|
||||
{
|
||||
return (SelectFromTableEx($conn, $tableName, null));
|
||||
}
|
||||
|
||||
function SelectFromTableEx($conn, $tableName, $cond)
|
||||
{
|
||||
if (($cond != null) && (strlen($cond) > 0)) {
|
||||
return (SelectQuery($conn, "SELECT * FROM [$tableName] WHERE $cond"));
|
||||
} else {
|
||||
return (SelectQuery($conn, "SELECT * FROM [$tableName]"));
|
||||
}
|
||||
}
|
||||
|
||||
function SelectQuery($conn, $query)
|
||||
{
|
||||
return (SelectQueryEx($conn, $query, null));
|
||||
}
|
||||
|
||||
function SelectQueryEx($conn, $query, $options)
|
||||
{
|
||||
$numFields = 0;
|
||||
if (IsPDOMode()) {
|
||||
$stmt = ExecuteQuery($conn, $query);
|
||||
$numFields = $stmt->columnCount();
|
||||
} else {
|
||||
if ($options != null) {
|
||||
$stmt = sqlsrv_query($conn, $query, null, $options);
|
||||
} else {
|
||||
$stmt = sqlsrv_query($conn, $query);
|
||||
}
|
||||
if ($stmt === false) {
|
||||
FatalError("Failed to query test table");
|
||||
}
|
||||
|
||||
$numFields = sqlsrv_num_fields($stmt);
|
||||
}
|
||||
if ($numFields <= 0) {
|
||||
die("Unexpected number of fields: .$numFields");
|
||||
}
|
||||
return ($stmt);
|
||||
}
|
||||
|
||||
function RowCount($stmt)
|
||||
{
|
||||
$rowCount = 0;
|
||||
if (IsPdoMode()) {
|
||||
while ($stmt->fetchColumn()) {
|
||||
$rowCount++;
|
||||
}
|
||||
} else {
|
||||
while (sqlsrv_fetch($stmt)) {
|
||||
$rowCount++;
|
||||
}
|
||||
}
|
||||
return ($rowCount);
|
||||
}
|
||||
|
||||
|
||||
function NumRows($conn, $tableName)
|
||||
{
|
||||
$stmt = SelectFromTable($conn, $tableName);
|
||||
$rowCount = RowCount($stmt);
|
||||
if (IsPdoMode()) {
|
||||
$stmt = null;
|
||||
} else {
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
|
||||
return ($rowCount);
|
||||
}
|
||||
|
||||
|
||||
function InsertQuery($tableName)
|
||||
{
|
||||
include_once 'MsData_UTF8.inc';
|
||||
return (InsertQueryExUTF8($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)
|
||||
{
|
||||
$tsql = InsertQuery($tableName);
|
||||
$stmt = null;
|
||||
|
||||
if (IsPdoMode())
|
||||
{
|
||||
$stmt = $conn->exec($tsql);
|
||||
}
|
||||
else
|
||||
{
|
||||
$stmt = sqlsrv_query($conn, $tsql);
|
||||
}
|
||||
return (InsertCheck($stmt));
|
||||
}
|
||||
*/
|
||||
function InsertRowEx($conn, $tableName, $dataCols, $dataValues, $dataOptions)
|
||||
{
|
||||
$tsql = "INSERT INTO [$tableName] ($dataCols) VALUES ($dataValues)";
|
||||
$stmt = null;
|
||||
|
||||
if (IsPdoMode()) {
|
||||
$stmt = $conn->exec($tsql);
|
||||
} else {
|
||||
$stmt = sqlsrv_query($conn, $tsql, $dataOptions);
|
||||
}
|
||||
return (InsertCheck($stmt));
|
||||
}
|
||||
|
||||
function InsertRowByIndex($conn, $tableName, $index)
|
||||
{
|
||||
$tsql = InsertQueryEx($tableName, $index);
|
||||
$stmt = null;
|
||||
|
||||
if (IsPdoMode()) {
|
||||
$stmt = $conn->exec($tsql);
|
||||
} else {
|
||||
$stmt = sqlsrv_query($conn, $tsql);
|
||||
}
|
||||
return (InsertCheck($stmt));
|
||||
}
|
||||
|
||||
function InsertStream($conn, $tableName, $dataCols, $dataValues, $dataOptions, $atExec)
|
||||
{
|
||||
$tsql = "INSERT INTO [$tableName] ($dataCols) VALUES ($dataValues)";
|
||||
$stmt = null;
|
||||
|
||||
if (IsPdoMode()) {
|
||||
$stmt = $conn->exec($tsql);
|
||||
} else {
|
||||
if ($atExec) {
|
||||
$stmt = sqlsrv_query($conn, $tsql, $dataOptions, array('SendStreamParamsAtExec' => 1));
|
||||
} else {
|
||||
$stmt = sqlsrv_query($conn, $tsql, $dataOptions);
|
||||
if ($stmt) {
|
||||
while (sqlsrv_send_stream_data($stmt)) {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (InsertCheck($stmt));
|
||||
}
|
||||
|
||||
|
||||
function InsertCheck($stmt)
|
||||
{
|
||||
$numRows = 0;
|
||||
|
||||
if ($stmt === false) {
|
||||
FatalError("Failed to insert row into test table");
|
||||
}
|
||||
if (IsPdoMode()) {
|
||||
$numRows = $stmt;
|
||||
} else {
|
||||
$numRows = sqlsrv_rows_affected($stmt);
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
if ($numRows != 1) {
|
||||
die("Unexpected row count at insert: ".$numRows);
|
||||
}
|
||||
return (true);
|
||||
}
|
||||
|
||||
function GetInsertData($rowIndex, $colIndex, $skip)
|
||||
{
|
||||
$query = InsertQueryEx("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);
|
||||
}
|
||||
$pos = strpos($data, ")");
|
||||
if ($pos === false) {
|
||||
die("Failed to isolate data on row $rowIndex, column $pos");
|
||||
}
|
||||
$data = substr($data, 0, $pos);
|
||||
if (strcasecmp($data, "null") == 0) {
|
||||
$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);
|
||||
|
||||
if (!IsPdoMode()) {
|
||||
$stmt = sqlsrv_query($conn, "CREATE PROC [$procName] ($procArgs) AS BEGIN $procCode END");
|
||||
if ($stmt === false) {
|
||||
FatalError("Failed to create test procedure");
|
||||
}
|
||||
sqlsrv_free_stmt($stmt);
|
||||
} else {
|
||||
$stmt = $conn->query("CREATE PROC [$procName] ($procArgs) AS BEGIN $procCode END");
|
||||
}
|
||||
}
|
||||
|
||||
function dropProc($conn, $procName)
|
||||
{
|
||||
if (!IsPdoMode()) {
|
||||
$stmt = sqlsrv_query($conn, "DROP PROC [$procName]");
|
||||
sqlsrv_free_stmt($stmt);
|
||||
} else {
|
||||
$query = "IF OBJECT_ID('[$procName]', 'P') IS NOT NULL DROP PROCEDURE [$procName]";
|
||||
$stmt = $conn->query($query);
|
||||
}
|
||||
}
|
||||
|
||||
function CallProc($conn, $procName, $procArgs, $procValues)
|
||||
{
|
||||
$stmt = CallProcEx($conn, $procName, "", $procArgs, $procValues);
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
|
||||
function CallProcEx($conn, $procName, $procPrefix, $procArgs, $procValues)
|
||||
{
|
||||
$stmt = sqlsrv_query($conn, "{ $procPrefix CALL [$procName] ($procArgs)}", $procValues);
|
||||
if ($stmt === false) {
|
||||
FatalError("Failed to call test procedure");
|
||||
}
|
||||
return ($stmt);
|
||||
}
|
||||
|
||||
|
||||
function CreateFunc($conn, $funcName, $funcArgs, $retType, $funcCode)
|
||||
{
|
||||
DropFunc($conn, $funcName);
|
||||
$stmt = sqlsrv_query($conn, "CREATE FUNCTION [$funcName] ($funcArgs) RETURNS $retType AS BEGIN $funcCode END");
|
||||
if ($stmt === false) {
|
||||
FatalError("Failed to create test function");
|
||||
}
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
|
||||
function DropFunc($conn, $funcName)
|
||||
{
|
||||
$stmt = sqlsrv_query($conn, "DROP FUNCTION [$funcName]");
|
||||
if ($stmt === false) {
|
||||
} else {
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function CallFunc($conn, $funcName, $funcArgs, $funcValues)
|
||||
{
|
||||
$stmt = sqlsrv_query($conn, "{ ? = CALL [$funcName]($funcArgs)}", $funcValues);
|
||||
if ($stmt === false) {
|
||||
FatalError("Failed to call test function");
|
||||
}
|
||||
sqlsrv_free_stmt($stmt);
|
||||
}
|
||||
|
||||
function handle_errors()
|
||||
{
|
||||
$errors = sqlsrv_errors(SQLSRV_ERR_ERRORS);
|
||||
$count = count($errors);
|
||||
if ($count == 0) {
|
||||
$errors = sqlsrv_errors(SQLSRV_ERR_ALL);
|
||||
$count = count($errors);
|
||||
}
|
||||
if ($count > 0) {
|
||||
for ($i = 0; $i < $count; $i++) {
|
||||
Trace($errors[$i]['message']."\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function str2hex($dataIn)
|
||||
{
|
||||
$dataOut = "";
|
||||
$len = strlen($dataIn);
|
||||
for ($i = 0; $i < $len; $i++) {
|
||||
$ch = strtoupper(substr($dataIn, $i, 1));
|
||||
if ($ch == "A") {
|
||||
$dataOut = $dataOut."41";
|
||||
} elseif ($ch == "B") {
|
||||
$dataOut = $dataOut."42";
|
||||
} elseif ($ch == "C") {
|
||||
$dataOut = $dataOut."43";
|
||||
} elseif ($ch == "D") {
|
||||
$dataOut = $dataOut."44";
|
||||
} elseif ($ch == "E") {
|
||||
$dataOut = $dataOut."45";
|
||||
} elseif ($ch == "F") {
|
||||
$dataOut = $dataOut."46";
|
||||
} else {
|
||||
$dataOut = $dataOut."3".$ch;
|
||||
}
|
||||
}
|
||||
return ($dataOut);
|
||||
}
|
||||
|
||||
function PhpVersionComponents(&$major, &$minor, &$sub)
|
||||
{
|
||||
$str_version = phpversion();
|
||||
|
||||
$major = strtok($str_version, ".");
|
||||
$minor = strtok(".");
|
||||
$sub = strtok(".");
|
||||
}
|
||||
|
|
@ -1,32 +1,37 @@
|
|||
--TEST--
|
||||
Connection option APP name unicode
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$appName = "APP_PoP_银河";
|
||||
try {
|
||||
$appName = "APP_PoP_银河";
|
||||
|
||||
// Connect
|
||||
$conn = new PDO("sqlsrv:server=$server;APP=$appName","$uid","$pwd");
|
||||
// Connect
|
||||
$conn = connect("APP=$appName");
|
||||
|
||||
// Query and Fetch
|
||||
$query = "SELECT APP_NAME()";
|
||||
// Query and Fetch
|
||||
$query = "SELECT APP_NAME()";
|
||||
|
||||
$stmt = $conn->query($query);
|
||||
while ( $row = $stmt->fetch(PDO::FETCH_NUM) ){
|
||||
echo $row[0]."\n";
|
||||
$stmt = $conn->query($query);
|
||||
while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
|
||||
echo $row[0]."\n";
|
||||
}
|
||||
|
||||
$stmt = $conn->query($query);
|
||||
while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
|
||||
echo $row['']."\n";
|
||||
}
|
||||
|
||||
// Free the connection and statement
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
echo "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
|
||||
$stmt = $conn->query($query);
|
||||
while ( $row = $stmt->fetch(PDO::FETCH_ASSOC) ){
|
||||
echo $row['']."\n";
|
||||
}
|
||||
|
||||
// Free the connection
|
||||
$conn=null;
|
||||
echo "Done"
|
||||
?>
|
||||
|
||||
--EXPECTREGEX--
|
||||
|
|
|
|||
|
|
@ -1,50 +1,54 @@
|
|||
--TEST--
|
||||
Insert with quoted parameters
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Connect
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", "$uid", "$pwd" );
|
||||
try {
|
||||
// Connect
|
||||
$conn = connect();
|
||||
|
||||
$param = 'a \' g';
|
||||
$param2 = $conn->quote( $param );
|
||||
$param = 'a \' g';
|
||||
$param2 = $conn->quote($param);
|
||||
|
||||
// Create a temporary table
|
||||
$tableName = '#tmpTable';
|
||||
$query = "CREATE TABLE $tableName (col1 VARCHAR(10), col2 VARCHAR(20))";
|
||||
$stmt = $conn->exec($query);
|
||||
if( $stmt === false ) { die(); }
|
||||
// Create a temporary table
|
||||
$tableName = getTableName();
|
||||
$stmt = createTable($conn, $tableName, array("col1" => "varchar(10)", "col2" => "varchar(20)"));
|
||||
|
||||
// Inserd data
|
||||
$query = "INSERT INTO $tableName VALUES( ?, '1' )";
|
||||
$stmt = $conn->prepare( $query );
|
||||
$stmt->execute(array($param));
|
||||
// Insert data
|
||||
if (!isColEncrypted()) {
|
||||
$query = "INSERT INTO $tableName VALUES(?, '1')";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute(array($param));
|
||||
} else {
|
||||
insertRow($conn, $tableName, array("col1" => $param, "col2" => "1"), "prepareExecuteBind");
|
||||
}
|
||||
|
||||
// Inserd data
|
||||
$query = "INSERT INTO $tableName VALUES( ?, ? )";
|
||||
$stmt = $conn->prepare( $query );
|
||||
$stmt->execute(array($param, $param2));
|
||||
// Insert data
|
||||
insertRow($conn, $tableName, array("col1" => $param, "col2" => $param2), "prepareExecuteBind");
|
||||
|
||||
// Query
|
||||
$query = "SELECT * FROM $tableName";
|
||||
$stmt = $conn->query($query);
|
||||
while ( $row = $stmt->fetch( PDO::FETCH_ASSOC ) ){
|
||||
print_r( $row['col1'] ." was inserted\n" );
|
||||
// Query
|
||||
$query = "SELECT * FROM $tableName";
|
||||
$stmt = $conn->query($query);
|
||||
while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
|
||||
print_r($row['col1'] ." was inserted\n");
|
||||
}
|
||||
|
||||
// Revert the inserts
|
||||
$query = "delete from $tableName where col1 = ?";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute(array($param));
|
||||
|
||||
//free the statement and connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
|
||||
// Revert the inserts
|
||||
$query = "delete from $tableName where col1 = ?";
|
||||
$stmt = $conn->prepare( $query );
|
||||
$stmt->execute(array($param));
|
||||
|
||||
//free the statement and connection
|
||||
$stmt=null;
|
||||
$conn=null;
|
||||
?>
|
||||
--EXPECT--
|
||||
a ' g was inserted
|
||||
a ' g was inserted
|
||||
|
||||
a ' g was inserted
|
||||
|
|
@ -1,24 +1,28 @@
|
|||
--TEST--
|
||||
uses an input/output parameter
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$dbh = new PDO( "sqlsrv:server=$server; database=$databaseName", "$uid", "$pwd" );
|
||||
try {
|
||||
$dbh = connect();
|
||||
|
||||
$dbh->query("IF OBJECT_ID('dbo.sp_ReverseString', 'P') IS NOT NULL DROP PROCEDURE dbo.sp_ReverseString");
|
||||
$dbh->query("CREATE PROCEDURE dbo.sp_ReverseString @String as VARCHAR(2048) OUTPUT as SELECT @String = REVERSE(@String)");
|
||||
$stmt = $dbh->prepare("EXEC dbo.sp_ReverseString ?");
|
||||
$string = "123456789";
|
||||
$stmt->bindParam(1, $string, PDO::PARAM_STR | PDO::PARAM_INPUT_OUTPUT, 2048);
|
||||
$stmt->execute();
|
||||
print "Result: ".$string."\n"; // Expect 987654321
|
||||
dropProc($dbh, "sp_ReverseString");
|
||||
$dbh->query("CREATE PROCEDURE dbo.sp_ReverseString @String as VARCHAR(2048) OUTPUT as SELECT @String = REVERSE(@String)");
|
||||
$stmt = $dbh->prepare("EXEC dbo.sp_ReverseString ?");
|
||||
$string = "123456789";
|
||||
$stmt->bindParam(1, $string, PDO::PARAM_STR | PDO::PARAM_INPUT_OUTPUT, 2048);
|
||||
$stmt->execute();
|
||||
print "Result: ".$string."\n"; // Expect 987654321
|
||||
|
||||
//free the statement and connection
|
||||
$stmt = null;
|
||||
$dbh = null;
|
||||
//free the statement and connection
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
Result: 987654321
|
||||
|
|
|
|||
|
|
@ -1,48 +1,86 @@
|
|||
--TEST--
|
||||
Number of rows in a result set
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", "$uid", "$pwd" );
|
||||
try {
|
||||
$conn = connect();
|
||||
|
||||
// Create table
|
||||
$tableName = '#tmpTable1';
|
||||
$stmt = $conn->exec("CREATE TABLE $tableName (c1 VARCHAR(32))");
|
||||
$stmt=null;
|
||||
// Create table
|
||||
$tableName = getTableName();
|
||||
createTable($conn, $tableName, array("c1" => "varchar(32)"));
|
||||
|
||||
// Insert data
|
||||
$query = "INSERT INTO $tableName VALUES ('Salmon'),('Butterfish'),('Cod'),('NULL'),('Crab')";
|
||||
$stmt = $conn->query($query);
|
||||
$res[] = $stmt->rowCount();
|
||||
if (!isColEncrypted()) {
|
||||
// Insert data
|
||||
$query = "INSERT INTO $tableName VALUES ('Salmon'),('Butterfish'),('Cod'),('NULL'),('Crab')";
|
||||
$stmt = $conn->query($query);
|
||||
$res[] = $stmt->rowCount();
|
||||
|
||||
// Update data
|
||||
$query = "UPDATE $tableName SET c1='Salmon' WHERE c1='Cod'";
|
||||
$stmt = $conn->query($query);
|
||||
$res[] = $stmt->rowCount();
|
||||
|
||||
// Update data
|
||||
$query = "UPDATE $tableName SET c1='Salmon' WHERE c1='NULL'";
|
||||
$stmt = $conn->query($query);
|
||||
$res[] = $stmt->rowCount();
|
||||
|
||||
// Update data
|
||||
$query = "UPDATE $tableName SET c1='Salmon' WHERE c1='Cod'";
|
||||
$stmt = $conn->query($query);
|
||||
$res[] = $stmt->rowCount();
|
||||
// Update data
|
||||
$query = "UPDATE $tableName SET c1='Salmon' WHERE c1='NO_NAME'";
|
||||
$stmt = $conn->query($query);
|
||||
$res[] = $stmt->rowCount();
|
||||
|
||||
// Update data
|
||||
$query = "UPDATE $tableName SET c1='Salmon' WHERE c1='NULL'";
|
||||
$stmt = $conn->query($query);
|
||||
$res[] = $stmt->rowCount();
|
||||
// Update data
|
||||
$query = "UPDATE $tableName SET c1='N/A'";
|
||||
$stmt = $conn->query($query);
|
||||
$res[] = $stmt->rowCount();
|
||||
|
||||
unset($stmt);
|
||||
} else {
|
||||
// Insert data
|
||||
// bind parameter does not work with inserting multiple rows in one SQL command, thus need to insert each row separately
|
||||
$query = "INSERT INTO $tableName VALUES (?)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$params = array("Salmon", "Butterfish", "Cod", "NULL", "Crab");
|
||||
foreach ($params as $param) {
|
||||
$stmt->execute(array($param));
|
||||
}
|
||||
$res[] = count($params);
|
||||
|
||||
// Update data
|
||||
$query = "UPDATE $tableName SET c1=? WHERE c1=?";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute(array("Salmon", "Cod"));
|
||||
$res[] = $stmt->rowCount();
|
||||
|
||||
// Update data
|
||||
$stmt->execute(array("Salmon", "NULL"));
|
||||
$res[] = $stmt->rowCount();
|
||||
|
||||
// Update data
|
||||
$stmt->execute(array("Salmon", "NO_NAME"));
|
||||
$res[] = $stmt->rowCount();
|
||||
|
||||
$query = "UPDATE $tableName SET c1=?";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute(array("N/A"));
|
||||
$res[] = $stmt->rowCount();
|
||||
|
||||
unset($stmt);
|
||||
}
|
||||
|
||||
// Update data
|
||||
$query = "UPDATE $tableName SET c1='Salmon' WHERE c1='NO_NAME'";
|
||||
$stmt = $conn->query($query);
|
||||
$res[] = $stmt->rowCount();
|
||||
print_r($res);
|
||||
|
||||
// Update data
|
||||
$query = "UPDATE $tableName SET c1='N/A'";
|
||||
$stmt = $conn->query($query);
|
||||
$res[] = $stmt->rowCount();
|
||||
|
||||
print_r($res);
|
||||
|
||||
$stmt=null;
|
||||
$conn=null;
|
||||
print "Done"
|
||||
dropTable($conn, $tableName);
|
||||
unset($conn);
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
Array
|
||||
|
|
|
|||
|
|
@ -1,47 +1,58 @@
|
|||
--TEST--
|
||||
Number MAX_INT to string with custom formats
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
/* Sample number MAX_INT */
|
||||
$sample = 2*(2**30-1)+1;
|
||||
var_dump ($sample);
|
||||
try{
|
||||
/* Sample number MAX_INT */
|
||||
$sample = 2*(2**30-1)+1;
|
||||
var_dump ($sample);
|
||||
|
||||
/* Connect */
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
/* Connect */
|
||||
$conn = connect();
|
||||
|
||||
// Create table
|
||||
$tableName = '#testCustomFormats';
|
||||
$query = "CREATE TABLE $tableName (col1 INT)";
|
||||
$stmt = $conn->exec($query);
|
||||
// Create table
|
||||
$tableName = 'testCustomFormats';
|
||||
createTable($conn, $tableName, array("col1" => "int"));
|
||||
|
||||
// Query number with custom format
|
||||
$query ="SELECT CAST($sample as varchar) + '.00'";
|
||||
$stmt = $conn->query($query);
|
||||
$data = $stmt->fetchColumn();
|
||||
var_dump ($data);
|
||||
// Query number with custom format
|
||||
$query = "SELECT CAST($sample as varchar) + '.00'";
|
||||
$stmt = $conn->query($query);
|
||||
$data = $stmt->fetchColumn();
|
||||
var_dump($data);
|
||||
|
||||
// Insert data using bind parameters
|
||||
$query = "INSERT INTO $tableName VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
// Insert data using bind parameters
|
||||
$query = "INSERT INTO $tableName VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
// Fetching. Prepare with client buffered cursor
|
||||
$query = "SELECT TOP 1 cast(col1 as varchar) + '.00 EUR' FROM $tableName";
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
// Fetching. Prepare with client buffered cursor
|
||||
if (!isColEncrypted())
|
||||
$query = "SELECT TOP 1 cast(col1 as varchar) + '.00 EUR' FROM $tableName";
|
||||
else
|
||||
// cannot explicitly cast data to another type from an encrypted column
|
||||
$query = "SELECT TOP 1 col1 FROM $tableName";
|
||||
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
if (isColEncrypted())
|
||||
$value .= ".00 EUR";
|
||||
var_dump($value);
|
||||
|
||||
//Free the statement and connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
//Free the statement and connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
print "Done";
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
|
||||
--EXPECT--
|
||||
|
|
|
|||
|
|
@ -1,53 +1,66 @@
|
|||
--TEST--
|
||||
Number MAX_INT to string with custom formats, see pdo_014. Pooling enabled.
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$pooling = true;
|
||||
try {
|
||||
$pooling = true;
|
||||
|
||||
/* Sample number MAX_INT */
|
||||
$sample = 2*(2**30-1)+1;
|
||||
/* Sample number MAX_INT */
|
||||
$sample = 2*(2**30-1)+1;
|
||||
|
||||
/* Connect + create a new pool */
|
||||
$conn0 = new PDO("sqlsrv:server=$server;database=$databaseName;ConnectionPooling=$pooling", $uid, $pwd);
|
||||
$conn0->query("select 1");
|
||||
$conn0 = null;
|
||||
/* Connect + create a new pool */
|
||||
$conn0 = connect("ConnectionPooling=$pooling");
|
||||
$conn0->query("select 1");
|
||||
unset($conn0);
|
||||
|
||||
/* Connect */
|
||||
$conn = new PDO("sqlsrv:server=$server;database=$databaseName;ConnectionPooling=$pooling", $uid, $pwd);
|
||||
/* Connect */
|
||||
$conn = connect("ConnectionPooling=$pooling");
|
||||
|
||||
// Create a temporary table
|
||||
$tableName = '#testFormats';
|
||||
$query = "CREATE TABLE $tableName (col1 INT)";
|
||||
$stmt = $conn->exec($query);
|
||||
// Create a temporary table
|
||||
$tableName = 'testFormats';
|
||||
createTable($conn, $tableName, array("col1" => "int"));
|
||||
|
||||
// Query number with custom format
|
||||
$query ="SELECT CAST($sample as varchar) + '.00'";
|
||||
$stmt = $conn->query($query);
|
||||
$data = $stmt->fetchColumn();
|
||||
var_dump ($data);
|
||||
// Query number with custom format
|
||||
$query = "SELECT CAST($sample as varchar) + '.00'";
|
||||
$stmt = $conn->query($query);
|
||||
$data = $stmt->fetchColumn();
|
||||
var_dump($data);
|
||||
|
||||
// Insert data using bind parameters
|
||||
$query = "INSERT INTO $tableName VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
// Insert data using bind parameters
|
||||
$query = "INSERT INTO $tableName VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
// Fetching. Prepare with client buffered cursor
|
||||
$query = "SELECT TOP 1 cast(col1 as varchar) + '.00 EUR' FROM $tableName";
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
// Fetching. Prepare with client buffered cursor
|
||||
if (!isColEncrypted()) {
|
||||
$query = "SELECT TOP 1 cast(col1 as varchar) + '.00 EUR' FROM $tableName";
|
||||
} else {
|
||||
// cannot explicitly cast data to another type from an encrypted column
|
||||
$query = "SELECT TOP 1 col1 FROM $tableName";
|
||||
}
|
||||
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
if (isColEncrypted()) {
|
||||
$value .= ".00 EUR";
|
||||
}
|
||||
var_dump($value);
|
||||
|
||||
//Free the statement and connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
//Free the statement and connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
print "Done";
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
|
||||
--EXPECT--
|
||||
|
|
|
|||
|
|
@ -1,41 +1,44 @@
|
|||
--TEST--
|
||||
Bind integer parameters; allow fetch numeric types.
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
/* Sample numbers MIN_INT, MAX_INT */
|
||||
$sample = array(-2**31, 2**31-1);
|
||||
try {
|
||||
/* Sample numbers MIN_INT, MAX_INT */
|
||||
$sample = array(-2**31, 2**31-1);
|
||||
|
||||
/* Connect */
|
||||
$conn_ops['pdo'][PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE] = TRUE;
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName", $uid, $pwd, $conn_ops['pdo']);
|
||||
/* Connect */
|
||||
$conn = connect('', array(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE => TRUE));
|
||||
|
||||
// Create table
|
||||
$tableName = '#testPDO016';
|
||||
$sql = "CREATE TABLE $tableName (c1 INT, c2 INT)";
|
||||
$stmt = $conn->exec($sql);
|
||||
// Create table
|
||||
$tableName = 'testPDO016';
|
||||
createTable($conn, $tableName, array("c1" => "int", "c2" => "int"));
|
||||
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName VALUES (:num1, :num2)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(':num1', $sample[0], PDO::PARAM_INT);
|
||||
$stmt->bindParam(':num2', $sample[1], PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName VALUES (:num1, :num2)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(':num1', $sample[0], PDO::PARAM_INT);
|
||||
$stmt->bindParam(':num2', $sample[1], PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
// Fetch, get data
|
||||
$sql = "SELECT * FROM $tableName";
|
||||
$stmt = $conn->query($sql);
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump ($row);
|
||||
// Fetch, get data
|
||||
$sql = "SELECT * FROM $tableName";
|
||||
$stmt = $conn->query($sql);
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump($row);
|
||||
|
||||
// Close connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
// Close connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
print "Done";
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
|
||||
--EXPECT--
|
||||
|
|
|
|||
|
|
@ -1,40 +1,51 @@
|
|||
--TEST--
|
||||
Fetch string with new line and tab characters
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Connect
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
try {
|
||||
// Connect
|
||||
$conn = connect();
|
||||
|
||||
// Create table
|
||||
$tableName = '#pdo_017';
|
||||
$sql = "CREATE TABLE $tableName (c1 VARCHAR(32), c2 CHAR(32), c3 NVARCHAR(32), c4 NCHAR(32))";
|
||||
$stmt = $conn->exec($sql);
|
||||
// Create table
|
||||
$tableName = 'pdo_017';
|
||||
createTable($conn, $tableName, array("c1" => "varchar(32)", "c2" => "char(32)", "c3" => "nvarchar(32)", "c4" => "nchar(32)"));
|
||||
|
||||
// Bind parameters and insert data
|
||||
$sql = "INSERT INTO $tableName VALUES (:val1, :val2, :val3, :val4)";
|
||||
$value = "I USE\nMSPHPSQL\tDRIVERS WITH PHP7";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(':val1', $value);
|
||||
$stmt->bindParam(':val2', $value);
|
||||
$stmt->bindParam(':val3', $value);
|
||||
$stmt->bindParam(':val4', $value);
|
||||
$stmt->execute();
|
||||
// Bind parameters and insert data
|
||||
$sql = "INSERT INTO $tableName VALUES (:val1, :val2, :val3, :val4)";
|
||||
$value = "I USE\nMSPHPSQL\tDRIVERS WITH PHP7";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(':val1', $value);
|
||||
$stmt->bindParam(':val2', $value);
|
||||
$stmt->bindParam(':val3', $value);
|
||||
$stmt->bindParam(':val4', $value);
|
||||
$stmt->execute();
|
||||
|
||||
// Get data
|
||||
$sql = "SELECT UPPER(c1) AS VARCHAR, UPPER(c2) AS CHAR,
|
||||
UPPER(c3) AS NVARCHAR, UPPER(c4) AS NCHAR FROM $tableName";
|
||||
$stmt = $conn->query($sql);
|
||||
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
var_dump($row);
|
||||
// Get data
|
||||
if (!isColEncrypted()) {
|
||||
$sql = "SELECT UPPER(c1) AS VARCHAR, UPPER(c2) AS CHAR,
|
||||
UPPER(c3) AS NVARCHAR, UPPER(c4) AS NCHAR FROM $tableName";
|
||||
$stmt = $conn->query($sql);
|
||||
} else {
|
||||
// upper function is not supported in Always Encrypted
|
||||
$sql = "SELECT c1 AS VARCHAR, c2 AS CHAR,
|
||||
c3 AS NVARCHAR, c4 AS NCHAR FROM $tableName";
|
||||
$stmt = $conn->query($sql);
|
||||
}
|
||||
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
var_dump($row);
|
||||
|
||||
// Close connection
|
||||
$stmt=null;
|
||||
$conn=null;
|
||||
print "Done"
|
||||
// Close connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
|
||||
--EXPECT--
|
||||
|
|
|
|||
|
|
@ -1,56 +1,91 @@
|
|||
--TEST--
|
||||
Moves the cursor to the next result set
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
/* Connect */
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
try {
|
||||
/* Connect */
|
||||
$conn = connect();
|
||||
|
||||
// Create table
|
||||
$tableName = '#testResultSet';
|
||||
$sql = "CREATE TABLE $tableName (c1 INT, c2 VARCHAR(40))";
|
||||
$stmt = $conn->exec($sql);
|
||||
// Create table
|
||||
$tableName = 'testResultSet';
|
||||
createTable($conn, $tableName, array("c1" => "int", "c2" => "varchar(40)"));
|
||||
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
for($t=200; $t<220; $t++) {
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(1, $t);
|
||||
$ts = sha1($t);
|
||||
$stmt->bindParam(2, $ts);
|
||||
$stmt->execute();
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
$inputs = array();
|
||||
for ($t=200; $t<220; $t++) {
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(1, $t);
|
||||
$ts = sha1($t);
|
||||
$stmt->bindParam(2, $ts);
|
||||
$stmt->execute();
|
||||
array_push($inputs, array($t, $ts));
|
||||
}
|
||||
|
||||
// Fetch, get data and move the cursor to the next result set
|
||||
if (!isColEncrypted()) {
|
||||
$sql = "SELECT * from $tableName WHERE c1 = '204' OR c1 = '210';
|
||||
SELECT Top 3 * FROM $tableName ORDER BY c1 DESC";
|
||||
$stmt = $conn->query($sql);
|
||||
$expected = array(array(219, sha1(219)), array(218, sha1(218)), array(217, sha1(217)));
|
||||
} else {
|
||||
// ORDER BY does not work for encrypted columns. In
|
||||
//https://docs.microsoft.com/en-us/sql/relational-databases/security/encryption/always-encrypted-database-engine,
|
||||
//the Feature Details section states that operators such as greater/less than does not work for encrypted columns, and ORDER BY is based on that
|
||||
$sql = "SELECT * FROM $tableName WHERE c1 = ? OR c1 = ?;
|
||||
SELECT Top 3 * FROM $tableName";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute(array('204', '210'));
|
||||
}
|
||||
$data1 = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
$stmt->nextRowset();
|
||||
$data2 = $stmt->fetchAll(PDO::FETCH_NUM);
|
||||
|
||||
// Array: FETCH_ASSOC
|
||||
foreach ($data1 as $a) {
|
||||
echo $a['c1'] . "|" . $a['c2'] . "\n";
|
||||
}
|
||||
|
||||
// Array: FETCH_NUM
|
||||
if (!isColEncrypted()) {
|
||||
$i = 0;
|
||||
foreach ($data2 as $a) {
|
||||
if ($expected[$i][0] != $a[0] || $expected[$i][1] != $a[1]) {
|
||||
echo "Values in row $i does not match the expected output.\n";
|
||||
}
|
||||
$i++;
|
||||
}
|
||||
} else {
|
||||
// don't know the order of the result set; simply compare to see if the result set is in $inputs
|
||||
foreach ($data2 as $a) {
|
||||
$match = false;
|
||||
foreach ($inputs as $input) {
|
||||
if ($a[0] == $input[0] && $a[1] == $input[1]) {
|
||||
$match = true;
|
||||
}
|
||||
}
|
||||
if (!$match) {
|
||||
echo "Value fetched for $a[0] is incorrect.\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Close connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($con);
|
||||
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
|
||||
// Fetch, get data and move the cursor to the next result set
|
||||
$sql = "SELECT * from $tableName WHERE c1 = '204' OR c1 = '210';
|
||||
SELECT Top 3 * FROM $tableName ORDER BY c1 DESC";
|
||||
$stmt = $conn->query($sql);
|
||||
$data1 = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
$stmt->nextRowset();
|
||||
$data2 = $stmt->fetchAll(PDO::FETCH_NUM);
|
||||
|
||||
// Array: FETCH_ASSOC
|
||||
foreach ($data1 as $a)
|
||||
echo $a['c1'] . "|" . $a['c2'] . "\n";
|
||||
|
||||
// Array: FETCH_NUM
|
||||
foreach ($data2 as $a)
|
||||
echo $a[0] . "|" . $a[1] . "\n";
|
||||
|
||||
// Close connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
|
||||
print "Done";
|
||||
?>
|
||||
|
||||
--EXPECT--
|
||||
204|1cc641954099c249e0e4ef0402da3fd0364d95f0
|
||||
210|135debd4837026bf06c7bfc5d1e0c6a31611af1d
|
||||
219|c0ba17c23a26ff8c314478bc69f30963a6e4a754
|
||||
218|3d5bdf107de596ce77e8ce48a61b585f52bbb61d
|
||||
217|49e3d046636e06b2d82ee046db8e6eb9a2e11e16
|
||||
Done
|
||||
|
|
|
|||
|
|
@ -1,61 +1,96 @@
|
|||
--TEST--
|
||||
Moves the cursor to the next result set with pooling enabled
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Create a pool
|
||||
$conn0 = new PDO("sqlsrv:server=$server; database=$databaseName;ConnectionPooling=1", $uid, $pwd);
|
||||
$conn0->query("SELECT 1");
|
||||
$conn0 = null;
|
||||
try {
|
||||
// Create a pool
|
||||
$conn0 = connect("ConnectionPooling=1");
|
||||
$conn0->query("SELECT 1");
|
||||
unset($conn0);
|
||||
|
||||
// Connect
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName;ConnectionPooling=1", $uid, $pwd);
|
||||
// Connect
|
||||
$conn = connect("ConnectionPooling=1");
|
||||
|
||||
// Create table
|
||||
$tableName = '#nextResultPooling';
|
||||
$sql = "CREATE TABLE $tableName (c1 INT, c2 XML)";
|
||||
$stmt = $conn->exec($sql);
|
||||
// Create table
|
||||
$tableName = 'nextResultPooling';
|
||||
createTable($conn, $tableName, array("c1" => "int", "c2" => "varchar(10)"));
|
||||
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
for($t=200; $t<220; $t++) {
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(1, $t);
|
||||
$ts = substr(sha1($t),0,5);
|
||||
$stmt->bindParam(2, $ts);
|
||||
$stmt->execute();
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
$inputs = array();
|
||||
for ($t=200; $t<220; $t++) {
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(1, $t);
|
||||
$ts = substr(sha1($t), 0, 5);
|
||||
$stmt->bindParam(2, $ts);
|
||||
$stmt->execute();
|
||||
array_push($inputs, array($t, $ts));
|
||||
}
|
||||
|
||||
// Fetch, get data and move the cursor to the next result set
|
||||
if (!isColEncrypted()) {
|
||||
$sql = "SELECT * from $tableName WHERE c1 = '204' OR c1 = '210';
|
||||
SELECT Top 3 * FROM $tableName ORDER BY c1 DESC";
|
||||
$stmt = $conn->query($sql);
|
||||
$expected = array(array(219, substr(sha1(219), 0, 5)), array(218, substr(sha1(218), 0, 5)), array(217, substr(sha1(217), 0, 5)));
|
||||
} else {
|
||||
// ORDER BY does not work for encrypted columns. In
|
||||
//https://docs.microsoft.com/en-us/sql/relational-databases/security/encryption/always-encrypted-database-engine,
|
||||
//the Feature Details section states that operators such as greater/less than does not work for encrypted columns, and ORDER BY is based on that
|
||||
$sql = "SELECT * FROM $tableName WHERE c1 = ? OR c1 = ?;
|
||||
SELECT Top 3 * FROM $tableName";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute(array('204', '210'));
|
||||
}
|
||||
$data1 = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
$stmt->nextRowset();
|
||||
$data2 = $stmt->fetchAll(PDO::FETCH_NUM);
|
||||
|
||||
// Array: FETCH_ASSOC
|
||||
foreach ($data1 as $a) {
|
||||
echo $a['c1']."|".$a['c2']."\n";
|
||||
}
|
||||
|
||||
// Array: FETCH_NUM
|
||||
if (!isColEncrypted()) {
|
||||
$i = 0;
|
||||
foreach ($data2 as $a) {
|
||||
if ($expected[$i][0] != $a[0] || $expected[$i][1] != $a[1]) {
|
||||
echo "Values in row $i does not match the expected output.\n";
|
||||
}
|
||||
$i++;
|
||||
}
|
||||
} else {
|
||||
// don't know the order of the result set; simply compare to see if the result set is in $inputs
|
||||
foreach ($data2 as $a) {
|
||||
$match = false;
|
||||
foreach ($inputs as $input) {
|
||||
if ($a[0] == $input[0] && $a[1] == $input[1]) {
|
||||
$match = true;
|
||||
}
|
||||
}
|
||||
if (!$match) {
|
||||
echo "Value fetched for $a[0] is incorrect.\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Close connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
|
||||
// Fetch, get data and move the cursor to the next result set
|
||||
$sql = "SELECT * from $tableName WHERE c1 = '204' OR c1 = '210';
|
||||
SELECT Top 3 * FROM $tableName ORDER BY c1 DESC";
|
||||
$stmt = $conn->query($sql);
|
||||
$data1 = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
$stmt->nextRowset();
|
||||
$data2 = $stmt->fetchAll(PDO::FETCH_NUM);
|
||||
|
||||
// Array: FETCH_ASSOC
|
||||
foreach ($data1 as $a)
|
||||
echo $a['c1']."|".$a['c2']."\n";
|
||||
|
||||
// Array: FETCH_NUM
|
||||
foreach ($data2 as $a)
|
||||
echo $a[0] . "|".$a[1]."\n";
|
||||
|
||||
// Close connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
|
||||
print "Done";
|
||||
?>
|
||||
|
||||
--EXPECT--
|
||||
204|1cc64
|
||||
210|135de
|
||||
219|c0ba1
|
||||
218|3d5bd
|
||||
217|49e3d
|
||||
Done
|
||||
|
|
|
|||
|
|
@ -1,50 +1,53 @@
|
|||
--TEST--
|
||||
Bind parameters using an array
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Connect
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
try {
|
||||
// Connect
|
||||
$conn = connect();
|
||||
|
||||
// Create table
|
||||
$tableName = '#bindParams';
|
||||
$sql = "CREATE TABLE $tableName (ID TINYINT, SID CHAR(5))";
|
||||
$stmt = $conn->exec($sql);
|
||||
// Create table
|
||||
$tableName = 'bindParams';
|
||||
$sql = "CREATE TABLE $tableName (ID TINYINT, SID CHAR(5))";
|
||||
$stmt = $conn->exec($sql);
|
||||
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
for($t=100; $t<103; $t++) {
|
||||
$stmt = $conn->prepare($sql);
|
||||
$ts = substr(sha1($t),0,5);
|
||||
$params = array($t,$ts);
|
||||
$stmt->execute($params);
|
||||
createTable($conn, $tableName, array("ID" => "tinyint", "SID" => "char(5)"));
|
||||
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
for ($t=100; $t<103; $t++) {
|
||||
$stmt = $conn->prepare($sql);
|
||||
$ts = substr(sha1($t),0,5);
|
||||
$params = array($t,$ts);
|
||||
$stmt->execute($params);
|
||||
}
|
||||
|
||||
// Query, but do not fetch
|
||||
$sql = "SELECT * from $tableName";
|
||||
$stmt = $conn->query($sql);
|
||||
|
||||
// Insert duplicate row, ID = 100
|
||||
$t = 100;
|
||||
insertRow($conn, $tableName, array( "ID" => $t, "SID" => substr( sha1( $t ), 0, 5 )), "prepareExecuteBind");
|
||||
|
||||
// Fetch. The result set should not contain duplicates
|
||||
$data = $stmt->fetchAll();
|
||||
foreach ($data as $a)
|
||||
echo $a['ID'] . "|" . $a['SID'] . "\n";
|
||||
|
||||
// Close connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
|
||||
// Query, but do not fetch
|
||||
$sql = "SELECT * from $tableName";
|
||||
$stmt = $conn->query($sql);
|
||||
|
||||
// Insert duplicate row, ID = 100
|
||||
$t = 100;
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
$stmt1 = $conn->prepare($sql);
|
||||
$ts = substr(sha1($t),0,5);
|
||||
$params = array($t,$ts);
|
||||
$stmt1->execute($params);
|
||||
|
||||
// Fetch. The result set should not contain duplicates
|
||||
$data = $stmt->fetchAll();
|
||||
foreach ($data as $a)
|
||||
echo $a['ID'] . "|" . $a['SID'] . "\n";
|
||||
|
||||
// Close connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
|
||||
print "Done";
|
||||
?>
|
||||
|
||||
--EXPECT--
|
||||
|
|
|
|||
|
|
@ -1,45 +1,47 @@
|
|||
--TEST--
|
||||
Bind parameters VARCHAR(n) extended ASCII
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Connect
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
try {
|
||||
// Connect
|
||||
$conn = connect();
|
||||
|
||||
// Create table
|
||||
$tableName = '#extendedAscii';
|
||||
$sql = "CREATE TABLE $tableName (code CHAR(2), city VARCHAR(32))";
|
||||
$stmt = $conn->exec($sql);
|
||||
// Create table
|
||||
$tableName = 'extendedAscii';
|
||||
createTable( $conn, $tableName, array("code" => "char(2)", "city" => "varchar(32)"));
|
||||
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
|
||||
// First row
|
||||
$stmt = $conn->prepare($sql);
|
||||
$params = array("FI","Järvenpää");
|
||||
$stmt->execute($params);
|
||||
// First row
|
||||
$stmt = $conn->prepare($sql);
|
||||
$params = array("FI","Järvenpää");
|
||||
$stmt->execute($params);
|
||||
|
||||
// Second row
|
||||
$params = array("DE","München");
|
||||
$stmt->execute($params);
|
||||
// Second row
|
||||
$params = array("DE","München");
|
||||
$stmt->execute($params);
|
||||
|
||||
// Query, fetch
|
||||
$sql = "SELECT * from $tableName";
|
||||
$stmt = $conn->query($sql);
|
||||
$data = $stmt->fetchAll();
|
||||
// Query, fetch
|
||||
$data = selectAll($conn, $tableName);
|
||||
|
||||
// Print out
|
||||
foreach ($data as $a)
|
||||
echo $a[0] . "|" . $a[1] . "\n";
|
||||
// Print out
|
||||
foreach ($data as $a)
|
||||
echo $a[0] . "|" . $a[1] . "\n";
|
||||
|
||||
// Close connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
// Close connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
print "Done";
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
|
||||
--EXPECT--
|
||||
|
|
|
|||
|
|
@ -1,17 +1,17 @@
|
|||
--TEST--
|
||||
Unicode XML message using bindValue()
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Connect
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
$conn = connect();
|
||||
|
||||
// Create a temporary table
|
||||
$tableName = '#testXMLBindValue';
|
||||
// XML encrypted is not supported, thus do not create table with encrypted columns
|
||||
$sql = "CREATE TABLE $tableName (ID INT PRIMARY KEY NOT NULL IDENTITY, XMLMessage XML)";
|
||||
$stmt = $conn->exec($sql);
|
||||
|
||||
|
|
@ -29,8 +29,7 @@ $xml2 = '<?xml version="1.0" encoding="utf-16"?>
|
|||
</PTag>';
|
||||
|
||||
// Insert data
|
||||
try
|
||||
{
|
||||
try {
|
||||
$stmt = $conn->prepare("INSERT INTO $tableName (XMLMessage) VALUES (:msg)");
|
||||
$stmt->bindValue(':msg', $xml1);
|
||||
$stmt->execute();
|
||||
|
|
@ -38,19 +37,17 @@ try
|
|||
$stmt = $conn->prepare("INSERT INTO $tableName (XMLMessage) VALUES (?)");
|
||||
$stmt->bindValue(1, $xml2);
|
||||
$stmt->execute();
|
||||
}
|
||||
catch (PDOException $ex) {
|
||||
} catch (PDOException $ex) {
|
||||
echo "Error: " . $ex->getMessage();
|
||||
}
|
||||
|
||||
// Get data
|
||||
$stmt = $conn->query("select * from $tableName");
|
||||
$row = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
var_dump($row);
|
||||
|
||||
$row = selectAll($conn, $tableName, "PDO::FETCH_ASSOC");
|
||||
var_dump($row);
|
||||
|
||||
// Close connection
|
||||
$stmt=null;
|
||||
$conn=null;
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
print "Done"
|
||||
?>
|
||||
|
|
|
|||
|
|
@ -1,32 +1,38 @@
|
|||
--TEST--
|
||||
Bind values with PDO::PARAM_BOOL, enable/disable fetch numeric type attribute
|
||||
--SKIPIF--
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require("MsSetup.inc");
|
||||
require_once( "MsCommon_mid-refactor.inc" );
|
||||
|
||||
// Sample data
|
||||
$sample = array([true, false],[-12, 0x2A],[0.00, NULL]);
|
||||
try {
|
||||
// Sample data
|
||||
$sample = array([true, false],[-12, 0x2A],[0.00, NULL]);
|
||||
$tableName = "pdo_test_table";
|
||||
|
||||
// Connect
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
// Connect
|
||||
$conn = connect();
|
||||
|
||||
// Run test
|
||||
Test();
|
||||
// Run test
|
||||
Test();
|
||||
|
||||
// Set PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE = false (default)
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, FALSE);
|
||||
Test();
|
||||
// Set PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE = false (default)
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, FALSE);
|
||||
Test();
|
||||
|
||||
// Set PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE = true
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, TRUE);
|
||||
Test();
|
||||
// Set PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE = true
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, TRUE);
|
||||
Test();
|
||||
|
||||
// Close connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
// Close connection
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
print "Done";
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
|
||||
// Generic test starts here
|
||||
function Test()
|
||||
|
|
@ -34,13 +40,8 @@ function Test()
|
|||
global $conn, $tableName, $sample;
|
||||
|
||||
// Drop table if exists
|
||||
$sql = "IF OBJECT_ID('$tableName') IS NOT NULL DROP TABLE $tableName";
|
||||
$stmt = $conn->query($sql);
|
||||
createTable($conn, $tableName, array("c1" => "int", "c2" => "bit"));
|
||||
|
||||
// Create table
|
||||
$sql = "CREATE TABLE $tableName (c1 INT, c2 BIT)";
|
||||
$stmt = $conn->query($sql) ?: die();
|
||||
|
||||
// Insert data using bind values
|
||||
$sql = "INSERT INTO $tableName VALUES (:v1, :v2)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
|
|
@ -56,8 +57,13 @@ function Test()
|
|||
$row = $stmt->fetchAll(PDO::FETCH_NUM);
|
||||
|
||||
// Print out
|
||||
for($i=0; $i<$stmt->rowCount(); $i++)
|
||||
{ var_dump($row[$i][0]); var_dump($row[$i][1]); }
|
||||
for ($i=0; $i<$stmt->rowCount(); $i++) {
|
||||
var_dump($row[$i][0]); var_dump($row[$i][1]);
|
||||
}
|
||||
|
||||
// clean up
|
||||
dropTable( $conn, $tableName );
|
||||
unset( $stmt );
|
||||
}
|
||||
?>
|
||||
|
||||
|
|
|
|||
|
|
@ -1,46 +1,46 @@
|
|||
--TEST--
|
||||
Insert binary HEX data then fetch it back as string
|
||||
--DESCRIPTION--
|
||||
Insert binary HEX data into an nvarchar field then read it back as UTF-8 string
|
||||
Insert binary HEX data into an nvarchar field then read it back as UTF-8 string
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
try
|
||||
{
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
try {
|
||||
// Connect
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn = connect();
|
||||
|
||||
// Create table
|
||||
$tableName = '#pdo_033test';
|
||||
$sql = "CREATE TABLE $tableName (c1 NVARCHAR(100))";
|
||||
$stmt = $conn->exec($sql);
|
||||
$tableName = 'pdo_033test';
|
||||
createTable($conn, $tableName, array("c1" => "nvarchar(100)"));
|
||||
|
||||
$input = pack( "H*", '49006427500048005000' ); // I'LOVE_SYMBOL'PHP
|
||||
$input = pack("H*", '49006427500048005000'); // I'LOVE_SYMBOL'PHP
|
||||
$result;
|
||||
$stmt = insertRow($conn, $tableName, array("c1" => new BindParamOp(1, $input, "PDO::PARAM_STR", 0, "PDO::SQLSRV_ENCODING_BINARY")), "prepareBindParam", $result);
|
||||
|
||||
$stmt = $conn->prepare("INSERT INTO $tableName (c1) VALUES (?)");
|
||||
$stmt->bindParam(1, $input, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_BINARY);
|
||||
$result = $stmt->execute();
|
||||
if (! $result)
|
||||
if (!$result) {
|
||||
echo "Failed to insert!\n";
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
exit;
|
||||
}
|
||||
|
||||
$stmt = $conn->query("SELECT * FROM $tableName");
|
||||
$utf8 = $stmt->fetchColumn();
|
||||
|
||||
echo "\n". $utf8 ."\n";
|
||||
echo "$utf8\n";
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
catch (Exception $e)
|
||||
{
|
||||
echo $e->getMessage();
|
||||
}
|
||||
|
||||
|
||||
print "Done";
|
||||
|
||||
?>
|
||||
|
||||
--EXPECT--
|
||||
|
|
|
|||
|
|
@ -1,20 +1,18 @@
|
|||
--TEST--
|
||||
GitHub Issue #35 binary encoding error when binding by name
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
function test()
|
||||
{
|
||||
require_once("MsSetup.inc");
|
||||
try {
|
||||
require_once( "MsCommon_mid-refactor.inc" );
|
||||
|
||||
// Connect
|
||||
$conn = new PDO( "sqlsrv:server=$server ; database=$databaseName", $uid, $pwd);
|
||||
$conn = connect();
|
||||
|
||||
// Create a temp table
|
||||
$tableName = "#testTableIssue35";
|
||||
$sql = "CREATE TABLE $tableName (Value varbinary(max))";
|
||||
$stmt = $conn->exec($sql);
|
||||
// Create a table
|
||||
$tableName = "testTableIssue35";
|
||||
createTable($conn, $tableName, array("Value" => "varbinary(max)"));
|
||||
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName VALUES (?)";
|
||||
|
|
@ -34,14 +32,14 @@ function test()
|
|||
var_dump($val1 === $value);
|
||||
|
||||
// Close connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
print "Done\n";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
|
||||
test();
|
||||
print "Done";
|
||||
?>
|
||||
--EXPECT--
|
||||
bool(true)
|
||||
Done
|
||||
|
||||
Done
|
||||
|
|
@ -1,41 +1,60 @@
|
|||
--TEST--
|
||||
Retrieve error information; supplied values does not match table definition
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Connect
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
try {
|
||||
// Connect
|
||||
// set errmode to silent to compare sqlstates in the test
|
||||
$conn = connect("", array(), PDO::ERRMODE_SILENT);
|
||||
|
||||
// Create table
|
||||
$tableName = '#pdo_040test';
|
||||
$sql = "CREATE TABLE $tableName (code INT)";
|
||||
$stmt = $conn->exec($sql);
|
||||
// Create table
|
||||
$tableName = 'pdo_040test';
|
||||
// common function insertRow() is not used here since the test deliberately executes an invalid insertion statement
|
||||
// thus it's not necessary to create an encrypted column for testing column encryption
|
||||
$sql = "CREATE TABLE $tableName (code INT)";
|
||||
$stmt = $conn->exec($sql);
|
||||
|
||||
// Insert data using bind parameters
|
||||
// Number of supplied values does not match table definition
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$params = array(2010,"London");
|
||||
// Insert data using bind parameters
|
||||
// Number of supplied values does not match table definition
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$params = array(2010,"London");
|
||||
|
||||
// SQL statement has an error, which is then reported
|
||||
$stmt->execute($params);
|
||||
print_r($stmt->errorInfo());
|
||||
// SQL statement has an error, which is then reported
|
||||
$stmt->execute($params);
|
||||
$error = $stmt->errorInfo();
|
||||
|
||||
// Close connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
$success = true;
|
||||
if (!isColEncrypted()) {
|
||||
// 21S01 is the expected ODBC Column name or number of supplied values does not match table definition error
|
||||
if ($error[0] != "21S01") {
|
||||
$success = false;
|
||||
}
|
||||
} else {
|
||||
// 07009 is the expected ODBC Invalid Descriptor Index error
|
||||
if ($error[0] != "07009") {
|
||||
$success = false;
|
||||
}
|
||||
}
|
||||
|
||||
print "Done";
|
||||
// Close connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
if ($success) {
|
||||
print "Done";
|
||||
} else {
|
||||
var_dump($error);
|
||||
}
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
|
||||
--EXPECTREGEX--
|
||||
Array
|
||||
\(
|
||||
\[0\] => 21S01
|
||||
\[1\] => 213
|
||||
\[2\] => \[Microsoft\]\[ODBC Driver 1[1-9] for SQL Server\]\[SQL Server\]Column name or number of supplied values does not match table definition\.
|
||||
\)
|
||||
--EXPECT--
|
||||
Done
|
||||
|
|
|
|||
|
|
@ -1,60 +1,53 @@
|
|||
--TEST--
|
||||
Prepare, execute statement and fetch with pooling unset (default)
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Allow PHP types for numeric fields
|
||||
$connection_options['pdo'][PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE] = TRUE;
|
||||
try {
|
||||
// Allow PHP types for numeric fields
|
||||
$connection_options = array(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE => TRUE);
|
||||
|
||||
// Create a pool
|
||||
$conn0 = new PDO( "sqlsrv:server=$server;database=$databaseName;",
|
||||
$uid, $pwd, $connection_options['pdo']);
|
||||
$conn0 = null;
|
||||
// Create a pool
|
||||
$conn0 = connect('', $connection_options);
|
||||
unset($conn0);
|
||||
|
||||
// Connection can use an existing pool
|
||||
$conn = new PDO( "sqlsrv:server=$server;database=$databaseName;",
|
||||
$uid, $pwd, $connection_options['pdo']);
|
||||
// Connection can use an existing pool
|
||||
$conn = connect('', $connection_options);
|
||||
|
||||
// Create table
|
||||
$tableName = 'pdo_060_test';
|
||||
createTable($conn, $tableName, array("Столица" => "nvarchar(32)", "year" => "int"));
|
||||
|
||||
// Create table
|
||||
$tableName = 'pdo_060_test';
|
||||
$sql = "CREATE TABLE $tableName (Столица NVARCHAR(32), year INT)";
|
||||
$stmt = $conn->query($sql);
|
||||
// Insert data
|
||||
insertRow($conn, $tableName, array("Столица" => "Лондон", "year" => 2012), "prepareExecuteBind");
|
||||
|
||||
// Insert data
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute(array("Лондон",2012));
|
||||
// Get data
|
||||
$row = selectRow($conn, $tableName, "PDO::FETCH_ASSOC");
|
||||
var_dump($row);
|
||||
unset($conn);
|
||||
|
||||
// Get data
|
||||
$stmt = $conn->query("SELECT * FROM $tableName");
|
||||
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
var_dump($row);
|
||||
$conn = null;
|
||||
// Create a new pool
|
||||
$conn0 = connect();
|
||||
unset($conn0);
|
||||
|
||||
// Connection can use an existing pool
|
||||
$conn = connect();
|
||||
|
||||
// Create a new pool
|
||||
$conn0 = new PDO( "sqlsrv:server=$server;database=$databaseName;",
|
||||
$uid, $pwd);
|
||||
$conn0 = null;
|
||||
|
||||
// Connection can use an existing pool
|
||||
$conn = new PDO( "sqlsrv:server=$server;database=$databaseName;",
|
||||
$uid, $pwd);
|
||||
|
||||
// Get data
|
||||
$stmt = $conn->query("SELECT * FROM $tableName");
|
||||
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
var_dump($row);
|
||||
|
||||
|
||||
$conn->query("DROP TABLE $tableName");
|
||||
|
||||
// Close connection
|
||||
$stmt=null;
|
||||
$conn=null;
|
||||
print "Done"
|
||||
// Get data
|
||||
$row = selectRow($conn, $tableName, "PDO::FETCH_ASSOC");
|
||||
var_dump($row);
|
||||
|
||||
// Close connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
print "Done\n";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
array(2) {
|
||||
|
|
@ -69,4 +62,4 @@ array(2) {
|
|||
["year"]=>
|
||||
string(4) "2012"
|
||||
}
|
||||
Done
|
||||
Done
|
||||
|
|
@ -1,59 +1,53 @@
|
|||
--TEST--
|
||||
Prepare, execute statement and fetch with pooling enabled
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Allow PHP types for numeric fields
|
||||
$connection_options['pdo'][PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE] = TRUE;
|
||||
try {
|
||||
// Allow PHP types for numeric fields
|
||||
$connection_options = array(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE => TRUE);
|
||||
|
||||
// Create a pool
|
||||
$conn0 = new PDO( "sqlsrv:server=$server;database=$databaseName;ConnectionPooling=1;",
|
||||
$uid, $pwd, $connection_options['pdo']);
|
||||
$conn0 = null;
|
||||
// Create a pool
|
||||
$conn0 = connect('ConnectionPooling=1', $connection_options);
|
||||
unset($conn0);
|
||||
|
||||
// Connection can use an existing pool
|
||||
$conn = new PDO( "sqlsrv:server=$server;database=$databaseName;ConnectionPooling=1;",
|
||||
$uid, $pwd, $connection_options['pdo']);
|
||||
// Connection can use an existing pool
|
||||
$conn = connect('ConnectionPooling=1', $connection_options);
|
||||
|
||||
// Create table
|
||||
$tableName = 'pdo_061test';
|
||||
$sql = "CREATE TABLE $tableName (Столица NVARCHAR(32), year INT)";
|
||||
$stmt = $conn->query($sql);
|
||||
// Create table
|
||||
$tableName = 'pdo_061test';
|
||||
createTable($conn, $tableName, array("Столица" => "nvarchar(32)", "year" => "int"));
|
||||
|
||||
// Insert data
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute(array("Лондон",2012));
|
||||
// Insert data
|
||||
insertRow($conn, $tableName, array("Столица" => "Лондон", "year" => 2012), "prepareExecuteBind");
|
||||
|
||||
// Get data
|
||||
$stmt = $conn->query("SELECT * FROM $tableName");
|
||||
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
var_dump($row);
|
||||
$conn = null;
|
||||
// Get data
|
||||
$row = selectRow($conn, $tableName, "PDO::FETCH_ASSOC");
|
||||
var_dump($row);
|
||||
unset($conn);
|
||||
|
||||
// Create a new pool
|
||||
$conn0 = new PDO( "sqlsrv:server=$server;database=$databaseName;ConnectionPooling=1;",
|
||||
$uid, $pwd);
|
||||
$conn0 = null;
|
||||
|
||||
// Connection can use an existing pool
|
||||
$conn = new PDO( "sqlsrv:server=$server;database=$databaseName;ConnectionPooling=1;",
|
||||
$uid, $pwd);
|
||||
// Create a new pool
|
||||
$conn0 = connect('ConnectionPooling=1');
|
||||
unset($conn0);
|
||||
|
||||
// Connection can use an existing pool
|
||||
$conn = connect('ConnectionPooling=1');
|
||||
|
||||
// Get data
|
||||
$stmt = $conn->query("SELECT * FROM $tableName");
|
||||
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
var_dump($row);
|
||||
|
||||
$conn->query("DROP TABLE $tableName");
|
||||
|
||||
// Close connection
|
||||
$stmt=null;
|
||||
$conn=null;
|
||||
print "Done"
|
||||
// Get data
|
||||
$row = selectRow($conn, $tableName, "PDO::FETCH_ASSOC");
|
||||
var_dump($row);
|
||||
|
||||
// Close connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
print "Done\n";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
array(2) {
|
||||
|
|
@ -68,4 +62,4 @@ array(2) {
|
|||
["year"]=>
|
||||
string(4) "2012"
|
||||
}
|
||||
Done
|
||||
Done
|
||||
|
|
@ -1,60 +1,53 @@
|
|||
--TEST--
|
||||
Prepare, execute statement and fetch with pooling disabled
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Allow PHP types for numeric fields
|
||||
$connection_options['pdo'][PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE] = TRUE;
|
||||
try {
|
||||
// Allow PHP types for numeric fields
|
||||
$connection_options = array(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE => TRUE);
|
||||
|
||||
// Create a pool
|
||||
$conn0 = new PDO( "sqlsrv:server=$server;database=$databaseName;ConnectionPooling=0;",
|
||||
$uid, $pwd, $connection_options['pdo']);
|
||||
$conn0 = null;
|
||||
// Create a pool
|
||||
$conn0 = connect('ConnectionPooling=0', $connection_options);
|
||||
unset($conn0);
|
||||
|
||||
// Connection can use an existing pool
|
||||
$conn = new PDO( "sqlsrv:server=$server;database=$databaseName;ConnectionPooling=0;",
|
||||
$uid, $pwd, $connection_options['pdo']);
|
||||
// Connection can use an existing pool
|
||||
$conn = connect('ConnectionPooling=0', $connection_options);
|
||||
|
||||
// Create table
|
||||
$tableName = 'pdo_62test';
|
||||
$sql = "CREATE TABLE $tableName (Столица NVARCHAR(32), year INT)";
|
||||
$stmt = $conn->exec($sql);
|
||||
// Create table
|
||||
$tableName = 'pdo_62test';
|
||||
createTable($conn, $tableName, array("Столица" => "nvarchar(32)", "year" => "int"));
|
||||
|
||||
// Insert data
|
||||
$sql = "INSERT INTO $tableName VALUES (?,?)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute(array("Лондон",2012));
|
||||
// Insert data
|
||||
insertRow($conn, $tableName, array( "Столица" => "Лондон", "year" => 2012 ), "prepareExecuteBind");
|
||||
|
||||
// Get data
|
||||
$stmt = $conn->query("SELECT * FROM $tableName");
|
||||
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
var_dump($row);
|
||||
$conn = null;
|
||||
// Get data
|
||||
$row = selectRow($conn, $tableName, "PDO::FETCH_ASSOC");
|
||||
var_dump($row);
|
||||
unset($conn);
|
||||
|
||||
// Create a new pool
|
||||
$conn0 = new PDO( "sqlsrv:server=$server;database=$databaseName;ConnectionPooling=0;",
|
||||
$uid, $pwd);
|
||||
$conn0 = null;
|
||||
|
||||
// Connection can use an existing pool?
|
||||
$conn = new PDO( "sqlsrv:server=$server;database=$databaseName;ConnectionPooling=0;",
|
||||
$uid, $pwd);
|
||||
// Create a new pool
|
||||
$conn0 = connect('ConnectionPooling=0');
|
||||
unset($conn0);
|
||||
|
||||
// Connection can use an existing pool?
|
||||
$conn = connect('ConnectionPooling=0');
|
||||
|
||||
// Get data
|
||||
$stmt = $conn->query("SELECT * FROM $tableName");
|
||||
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
var_dump($row);
|
||||
|
||||
// Get data
|
||||
$row = selectRow($conn, $tableName, "PDO::FETCH_ASSOC");
|
||||
var_dump($row);
|
||||
|
||||
$conn->query("DROP TABLE $tableName");
|
||||
|
||||
// Close connection
|
||||
$stmt=null;
|
||||
$conn=null;
|
||||
print "Done"
|
||||
// Close connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
print "Done\n";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
array(2) {
|
||||
|
|
@ -69,4 +62,4 @@ array(2) {
|
|||
["year"]=>
|
||||
string(4) "2012"
|
||||
}
|
||||
Done
|
||||
Done
|
||||
|
|
@ -1,46 +1,45 @@
|
|||
--TEST--
|
||||
Exception is thrown if the unsupported attribute ATTR_PERSISTENT is put into the connection options
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
include 'MsSetup.inc';
|
||||
$dsn = "sqlsrv:Server = $server;database = $databaseName;";
|
||||
try{
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
// TODO: With and without column encryption in the connection string result in different behaviors
|
||||
// without Column Encryption, no error is raised if PREFETCH is set before ERRMODE
|
||||
// with Column Encyrption, error is raised even when PREFETCH is set before ERRMODE
|
||||
// require investigation for the difference in behaviors
|
||||
try {
|
||||
echo "Testing a connection with ATTR_PERSISTENT...\n";
|
||||
// setting PDO::ATTR_PERSISTENT in PDO constructor returns an exception
|
||||
$attr = array(PDO::ATTR_PERSISTENT => true);
|
||||
$conn = new PDO( $dsn, $uid, $pwd, $attr);
|
||||
|
||||
//free the connection
|
||||
$conn=null;
|
||||
}
|
||||
catch( PDOException $e ) {
|
||||
$dsn = getDSN($server, $databaseName);
|
||||
$attr = array(PDO::ATTR_PERSISTENT => true);
|
||||
$conn = new PDO($dsn, $uid, $pwd, $attr);
|
||||
//free the connection
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
echo "Exception from unsupported attribute (ATTR_PERSISTENT) is caught\n";
|
||||
}
|
||||
try{
|
||||
|
||||
require_once 'MsCommon.inc';
|
||||
|
||||
try {
|
||||
echo "\nTesting new connection after exception thrown in previous connection...\n";
|
||||
$tableName1 = GetTempTableName('tab1');
|
||||
$conn = new PDO( $dsn, $uid, $pwd );
|
||||
$sql = "CREATE TABLE $tableName1 (c1 int, c2 varchar(10))";
|
||||
$stmt = $conn->exec($sql);
|
||||
$ret = $conn->exec("INSERT INTO $tableName1 VALUES(1, 'column2')");
|
||||
$stmt = $conn->query("SELECT * FROM $tableName1");
|
||||
$result = $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
$tableName1 = getTableName('tab1');
|
||||
$conn = connect();
|
||||
createTable($conn, $tableName1, array("c1" => "int", "c2" => "varchar(10)"));
|
||||
insertRow($conn, $tableName1, array("c1" => 1, "c2" => "column2"), "exec");
|
||||
|
||||
$result = selectRow($conn, $tableName1, "PDO::FETCH_ASSOC");
|
||||
if ($result['c1'] == 1 && $result['c2'] == 'column2') {
|
||||
echo "Test successfully completed";
|
||||
echo "Test successfully completed\n";
|
||||
}
|
||||
//free the statement and connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
//free the statement and connection
|
||||
dropTable($conn, $tableName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e);
|
||||
}
|
||||
catch( PDOException $e ) {
|
||||
var_dump( $e);
|
||||
}
|
||||
?>
|
||||
?>
|
||||
--EXPECT--
|
||||
Testing a connection with ATTR_PERSISTENT...
|
||||
Exception from unsupported attribute (ATTR_PERSISTENT) is caught
|
||||
|
|
|
|||
|
|
@ -3,29 +3,36 @@ Test unsupported connection attribute ATTR_PREFETCH
|
|||
--DESCRIPTION--
|
||||
Exception is thrown for the unsupported connection attribute ATTR_PREFETCH only if it is set after PDO::ERRMODE_EXCEPTION is turned on
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
$dsn = "sqlsrv:Server = $server;database = $databaseName";
|
||||
try{
|
||||
try {
|
||||
echo "Testing a connection with ATTR_PREFETCH before ERRMODE_EXCEPTION...\n";
|
||||
$attr = array(PDO::ATTR_PREFETCH => true, PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION);
|
||||
$conn = new PDO( $dsn, $uid, $pwd, $attr);
|
||||
$dsn = "sqlsrv:Server = $server;database = $databaseName";
|
||||
if ($keystore != "none")
|
||||
$dsn .= "ColumnEncryption=Enabled;";
|
||||
if ($keystore == "ksp") {
|
||||
require_once("AE_Ksp.inc");
|
||||
$ksp_path = getKSPPath();
|
||||
$dsn .= "CEKeystoreProvider=$ksp_path;CEKeystoreName=$ksp_name;CEKeystoreEncryptKey=$encrypt_key;";
|
||||
}
|
||||
|
||||
$attr = array(PDO::ATTR_PREFETCH => true, PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION);
|
||||
$conn = new PDO($dsn, $uid, $pwd, $attr);
|
||||
echo "Error from supported attribute (ATTR_PREFETCH) is silented\n\n";
|
||||
$conn=null;
|
||||
unset($conn);
|
||||
|
||||
echo "Testing a connection with ATTR_PREFETCH after ERRMODE_EXCEPTION...\n";
|
||||
$attr = array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, PDO::ATTR_PREFETCH => true);
|
||||
$conn = new PDO( $dsn, $uid, $pwd, $attr);
|
||||
$conn = new PDO($dsn, $uid, $pwd, $attr);
|
||||
//free the connection
|
||||
$conn=null;
|
||||
}
|
||||
catch( PDOException $e ) {
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
echo "Exception from unsupported attribute (ATTR_PREFETCH) is caught\n";
|
||||
//exit;
|
||||
}
|
||||
?>
|
||||
|
||||
--EXPECT--
|
||||
Testing a connection with ATTR_PREFETCH before ERRMODE_EXCEPTION...
|
||||
Error from supported attribute (ATTR_PREFETCH) is silented
|
||||
|
|
|
|||
|
|
@ -1,31 +1,34 @@
|
|||
--TEST--
|
||||
GitHub issue #69 - fetching an empty nvarchar using client buffer
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
// Connect
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
|
||||
$sql = "EXEC dbo.sp_executesql
|
||||
N'DECLARE @x nvarchar(max)
|
||||
SET @x = '''' -- empty string
|
||||
SELECT @x AS [Empty_Nvarchar_Max]'";
|
||||
try {
|
||||
$conn = connect();
|
||||
|
||||
$sql = "EXEC dbo.sp_executesql
|
||||
N'DECLARE @x nvarchar(max)
|
||||
SET @x = '''' -- empty string
|
||||
SELECT @x AS [Empty_Nvarchar_Max]'";
|
||||
|
||||
$stmt = $conn->prepare($sql, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt = $conn->prepare($sql, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
|
||||
$return = $stmt->fetchAll( PDO::FETCH_ASSOC );
|
||||
print_r($return);
|
||||
$return = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
||||
print_r($return);
|
||||
|
||||
// Free the statement and connection resources.
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
// Free the statement and connection resources.
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
print "Done";
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
Array
|
||||
|
|
|
|||
|
|
@ -1,68 +1,74 @@
|
|||
--TEST--
|
||||
Test emulate prepare utf8 encoding set at the statement level
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$pdo_options = [];
|
||||
$pdo_options[PDO::ATTR_ERRMODE] = PDO::ERRMODE_EXCEPTION;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_ENCODING] = PDO::SQLSRV_ENCODING_UTF8;
|
||||
|
||||
$connection = new PDO("sqlsrv:server=$server;Database=$databaseName", $uid, $pwd, $pdo_options);
|
||||
|
||||
$pdo_options = array();
|
||||
$pdo_options[PDO::ATTR_EMULATE_PREPARES] = TRUE;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_DIRECT_QUERY] = TRUE;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_ENCODING] = PDO::SQLSRV_ENCODING_UTF8;
|
||||
$pdo_options[PDO::ATTR_CURSOR] = PDO::CURSOR_SCROLL;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE] = PDO::SQLSRV_CURSOR_BUFFERED;
|
||||
|
||||
// Drop
|
||||
try {
|
||||
$st = $connection->prepare("DROP TABLE TEST", $pdo_options);
|
||||
$st->execute();
|
||||
$pdo_options = [];
|
||||
$pdo_options[PDO::SQLSRV_ATTR_ENCODING] = PDO::SQLSRV_ENCODING_UTF8;
|
||||
|
||||
$connection = connect('', $pdo_options);
|
||||
|
||||
// Always Encrypted does not support using DIRECT_QUERY for binding parameters
|
||||
// see https://github.com/Microsoft/msphpsql/wiki/Features#aebindparam
|
||||
$pdo_options = [];
|
||||
if (!isColEncrypted()) {
|
||||
$pdo_options[PDO::SQLSRV_ATTR_DIRECT_QUERY] = true;
|
||||
}
|
||||
$pdo_options[PDO::ATTR_CURSOR] = PDO::CURSOR_SCROLL;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE] = PDO::SQLSRV_CURSOR_BUFFERED;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_ENCODING] = PDO::SQLSRV_ENCODING_UTF8;
|
||||
|
||||
// Create table
|
||||
$tbname = "TEST";
|
||||
createTable($connection, $tbname, array( new ColumnMeta("int", "id", "IDENTITY(1,1) NOT NULL"), "name" => "nvarchar(max)"));
|
||||
|
||||
$prefix = '가각';
|
||||
$name = '가각ácasa';
|
||||
$name2 = '가각sample2';
|
||||
|
||||
$pdo_options[PDO::ATTR_EMULATE_PREPARES] = false;
|
||||
$st = $connection->prepare("INSERT INTO $tbname (name) VALUES (:p0)", $pdo_options);
|
||||
$st->execute(['p0' => $name]);
|
||||
|
||||
// Always Encrypted does not support emulate prepare
|
||||
if (!isColEncrypted()) {
|
||||
$pdo_options[PDO::ATTR_EMULATE_PREPARES] = true;
|
||||
}
|
||||
$st = $connection->prepare("INSERT INTO $tbname (name) VALUES (:p0)", $pdo_options);
|
||||
$st->execute(['p0' => $name2]);
|
||||
|
||||
if (!isColEncrypted()) {
|
||||
$statement1 = $connection->prepare("SELECT * FROM $tbname WHERE NAME LIKE :p0", $pdo_options);
|
||||
$statement1->execute(['p0' => "$prefix%"]);
|
||||
$pdo_options[PDO::ATTR_EMULATE_PREPARES] = false;
|
||||
$statement2 = $connection->prepare("SELECT * FROM $tbname WHERE NAME LIKE :p0", $pdo_options);
|
||||
$statement2->execute(['p0' => "$prefix%"]);
|
||||
} else {
|
||||
$statement1 = $connection->prepare("SELECT * FROM $tbname", $pdo_options);
|
||||
$statement1->execute();
|
||||
$statement2 = $connection->prepare("SELECT * FROM $tbname", $pdo_options);
|
||||
$statement2->execute();
|
||||
}
|
||||
foreach ($statement1 as $row) {
|
||||
echo 'FOUND: ' . $row['name'] . "\n";
|
||||
}
|
||||
foreach ($statement2 as $row) {
|
||||
echo 'FOUND: ' . $row['name'] . "\n";
|
||||
}
|
||||
|
||||
dropTable($connection, $tbname);
|
||||
unset($stmt);
|
||||
unset($connection);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
catch(\Exception $e) {}
|
||||
|
||||
// Recreate
|
||||
$st = $connection->prepare("CREATE TABLE TEST([id] [int] IDENTITY(1,1) NOT NULL, [name] nvarchar(max))", $pdo_options);
|
||||
$st->execute();
|
||||
|
||||
$prefix = '가각';
|
||||
$name = '가각ácasa';
|
||||
$name2 = '가각sample2';
|
||||
|
||||
$pdo_options[PDO::ATTR_EMULATE_PREPARES] = FALSE;
|
||||
$st = $connection->prepare("INSERT INTO TEST(name) VALUES(:p0)", $pdo_options);
|
||||
$st->execute(['p0' => $name]);
|
||||
|
||||
$pdo_options[PDO::ATTR_EMULATE_PREPARES] = TRUE;
|
||||
$st = $connection->prepare("INSERT INTO TEST(name) VALUES(:p0)", $pdo_options);
|
||||
$st->execute(['p0' => $name2]);
|
||||
|
||||
$statement = $connection->prepare("SELECT * FROM TEST WHERE NAME LIKE :p0", $pdo_options);
|
||||
$statement->execute(['p0' => "$prefix%"]);
|
||||
foreach ($statement as $row) {
|
||||
echo "\n" . 'FOUND: ' . $row['name'];
|
||||
}
|
||||
|
||||
$pdo_options = array();
|
||||
$pdo_options[PDO::ATTR_EMULATE_PREPARES] = FALSE;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_DIRECT_QUERY] = TRUE;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_ENCODING] = PDO::SQLSRV_ENCODING_UTF8;
|
||||
$statement = $connection->prepare("SELECT * FROM TEST WHERE NAME LIKE :p0", $pdo_options);
|
||||
$statement->execute(['p0' => "$prefix%"]);
|
||||
foreach ($statement as $row) {
|
||||
echo "\n" . 'FOUND: ' . $row['name'];
|
||||
}
|
||||
$stmt = NULL;
|
||||
$connection = NULL;
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
FOUND: 가각ácasa
|
||||
FOUND: 가각sample2
|
||||
FOUND: 가각ácasa
|
||||
FOUND: 가각sample2
|
||||
FOUND: 가각sample2
|
||||
|
|
|
|||
|
|
@ -1,59 +1,9 @@
|
|||
--TEST--
|
||||
Github 138. Test for Unicode Column Metadata.
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
class MyStatement extends PDOStatement {
|
||||
public function BindValues(array &$values, array &$blobs, $placeholder_prefix, $columnInformation, &$max_placeholder = NULL, $blob_suffix = NULL) {
|
||||
if (empty($max_placeholder)) {
|
||||
$max_placeholder = 0;
|
||||
}
|
||||
foreach ($values as $field_name => &$field_value) {
|
||||
$placeholder = $placeholder_prefix . $max_placeholder++;
|
||||
$blob_key = $placeholder . $blob_suffix;
|
||||
if (isset($columnInformation['blobs'][$field_name])) {
|
||||
$blobs[$blob_key] = fopen('php://memory', 'a');
|
||||
fwrite($blobs[$blob_key], $field_value);
|
||||
rewind($blobs[$blob_key]);
|
||||
$this->bindParam($placeholder, $blobs[$blob_key], PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
|
||||
}
|
||||
else {
|
||||
// Even though not a blob, make sure we retain a copy of these values.
|
||||
$blobs[$blob_key] = $field_value;
|
||||
$this->bindParam($placeholder, $blobs[$blob_key], PDO::PARAM_STR);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param string $connection_id
|
||||
*
|
||||
* @return PDO
|
||||
*/
|
||||
function connection($connection_id) {
|
||||
include 'MsSetup.inc';
|
||||
$host = $server;
|
||||
$database = $databaseName;
|
||||
$username = $uid;
|
||||
$password = $pwd;
|
||||
|
||||
static $connections = array();
|
||||
if (!isset($connections[$connection_id])) {
|
||||
$connection_options['pdo'] = array();
|
||||
$connection_options['pdo'][PDO::ATTR_ERRMODE] = PDO::ERRMODE_EXCEPTION;
|
||||
|
||||
$cnn = new PDO("sqlsrv:server=$host;Database=$database", $username, $password, $connection_options['pdo']);
|
||||
$cnn->setAttribute(PDO::ATTR_STATEMENT_CLASS, [MyStatement::class]);
|
||||
$connections[$connection_id] = $cnn;
|
||||
}
|
||||
return $connections[$connection_id];
|
||||
}
|
||||
|
||||
/**
|
||||
* Summary of prepare
|
||||
*
|
||||
|
|
@ -63,117 +13,63 @@ function connection($connection_id) {
|
|||
*/
|
||||
function prepare($connection, $query) {
|
||||
$pdo_options = array();
|
||||
$pdo_options[PDO::ATTR_EMULATE_PREPARES] = TRUE;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_DIRECT_QUERY] = TRUE;
|
||||
// emulate and binding parameter with direct query are not support in Always Encrypted
|
||||
if ( !isColEncrypted() )
|
||||
{
|
||||
$pdo_options[PDO::ATTR_EMULATE_PREPARES] = TRUE;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_DIRECT_QUERY] = TRUE;
|
||||
}
|
||||
$pdo_options[PDO::ATTR_CURSOR] = PDO::CURSOR_SCROLL;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE] = PDO::SQLSRV_CURSOR_BUFFERED;
|
||||
return $connection->prepare($query, $pdo_options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Summary of execute
|
||||
*
|
||||
* @param PDO $connection
|
||||
* @param string $query
|
||||
*
|
||||
* @param PDOStatement;
|
||||
*/
|
||||
function execute($connection, $query, array $args = array()) {
|
||||
$st = prepare($connection, $query);
|
||||
foreach ($args as $key => $value) {
|
||||
if (is_numeric($value)) {
|
||||
$st->bindValue($key, $value, PDO::PARAM_INT);
|
||||
}
|
||||
else {
|
||||
$st->bindValue($key, $value, PDO::PARAM_STR);
|
||||
}
|
||||
}
|
||||
|
||||
$st->execute();
|
||||
|
||||
// Bind column types properly.
|
||||
$null = array();
|
||||
$st->columnNames = array();
|
||||
for ($i = 0; $i < $st->columnCount(); $i++) {
|
||||
$meta = $st->getColumnMeta($i);
|
||||
$st->columnNames[]= $meta['name'];
|
||||
$sqlsrv_type = $meta['sqlsrv:decl_type'];
|
||||
$parts = explode(' ', $sqlsrv_type);
|
||||
$type = reset($parts);
|
||||
switch($type) {
|
||||
case 'varbinary':
|
||||
$null[$i] = NULL;
|
||||
$st->bindColumn($i + 1, $null[$i], PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
|
||||
break;
|
||||
case 'int':
|
||||
case 'bit':
|
||||
case 'smallint':
|
||||
case 'tinyint':
|
||||
case 'bigint':
|
||||
$null[$i] = NULL;
|
||||
$st->bindColumn($i + 1, $null[$i], PDO::PARAM_INT);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return $st;
|
||||
}
|
||||
|
||||
|
||||
//*******************************************************
|
||||
// TEST BEGIN
|
||||
//*******************************************************
|
||||
|
||||
$connection = connection('default');
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Drop
|
||||
try {
|
||||
execute($connection, 'DROP TABLE [mytáble]');
|
||||
}
|
||||
catch(Exception $e) {}
|
||||
$connection = connect();
|
||||
|
||||
$tablescript = <<<EOF
|
||||
// Create Table
|
||||
$tbname = "mytáble";
|
||||
createTable( $connection, $tbname, array( new ColumnMeta( "nchar(10)", "id" ), new ColumnMeta( "nchar(10)", "väriable" ), new ColumnMeta( "nchar(10)", "tésting" )));
|
||||
|
||||
CREATE TABLE [dbo].[mytáble](
|
||||
[id] [nchar](10) NULL,
|
||||
[väriable] [nchar](10) NULL,
|
||||
[tésting] [nchar](10) NULL
|
||||
) ON [PRIMARY]
|
||||
|
||||
EOF;
|
||||
$query = "INSERT INTO $tbname (id, tésting, väriable) VALUES (:db_insert0, :db_insert1, :db_insert2)";
|
||||
|
||||
// Recreate
|
||||
execute($connection, $tablescript);
|
||||
/** @var MyStatement */
|
||||
$st = prepare($connection, $query);
|
||||
|
||||
$query = <<<EOF
|
||||
INSERT INTO [mytáble] (id, tésting, väriable) VALUES (:db_insert0, :db_insert1, :db_insert2)
|
||||
EOF;
|
||||
$st->bindValue(':db_insert0', 'a', PDO::PARAM_STR);
|
||||
$st->bindValue(':db_insert1', 'b', PDO::PARAM_STR);
|
||||
$st->bindValue(':db_insert2', 'c', PDO::PARAM_STR);
|
||||
|
||||
$blobs = [];
|
||||
$st->execute();
|
||||
|
||||
/** @var MyStatement */
|
||||
$st = prepare($connection, $query);
|
||||
$st = prepare($connection, "SELECT * FROM $tbname");
|
||||
|
||||
$st->bindValue(':db_insert0', 'a', PDO::PARAM_STR);
|
||||
$st->bindValue(':db_insert1', 'b', PDO::PARAM_STR);
|
||||
$st->bindValue(':db_insert2', 'c', PDO::PARAM_STR);
|
||||
$st->execute();
|
||||
|
||||
$st->execute();
|
||||
while ($row = $st->fetchAll()) {
|
||||
$row = reset($row);
|
||||
echo (isset($row['id']) ? "OK" : "FAIL") , "\n";
|
||||
echo (isset($row['tésting']) ? "OK" : "FAIL") , "\n";
|
||||
echo (isset($row['väriable']) ? "OK" : "FAIL") , "\n";
|
||||
}
|
||||
|
||||
$st = prepare($connection, 'SELECT * FROM [mytáble]');
|
||||
for ($i = 0; $i < $st->columnCount(); $i++) {
|
||||
$meta = $st->getColumnMeta($i);
|
||||
echo $meta['name'] , "\n";
|
||||
}
|
||||
|
||||
$st->execute();
|
||||
|
||||
while($row = $st->fetchAll()){
|
||||
$row = reset($row);
|
||||
echo (isset($row['id']) ? "OK" : "FAIL") , "\n";
|
||||
echo (isset($row['tésting']) ? "OK" : "FAIL") , "\n";
|
||||
echo (isset($row['väriable']) ? "OK" : "FAIL") , "\n";
|
||||
}
|
||||
|
||||
for ($i = 0; $i < $st->columnCount(); $i++) {
|
||||
$meta = $st->getColumnMeta($i);
|
||||
echo $meta['name'] , "\n";
|
||||
dropTable($connection, $tbname);
|
||||
unset($st);
|
||||
unset($connection);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
|
|
@ -1,66 +1,47 @@
|
|||
--TEST--
|
||||
Test emulate prepare with mix bound param encodings and positional placeholders (i.e., using '?' as placeholders)
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once( "MsCommon_mid-refactor.inc" );
|
||||
|
||||
$connection_options['pdo'] = array();
|
||||
$connection_options['pdo'][PDO::ATTR_ERRMODE] = PDO::ERRMODE_EXCEPTION;
|
||||
|
||||
$cnn = new PDO("sqlsrv:Server=$server;Database=$databaseName", $uid, $pwd, $connection_options['pdo']);
|
||||
|
||||
// Drop
|
||||
try {
|
||||
$cnn = connect();
|
||||
|
||||
$pdo_options = array();
|
||||
$pdo_options[PDO::ATTR_EMULATE_PREPARES] = TRUE;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_DIRECT_QUERY] = TRUE;
|
||||
if (!isColEncrypted()) {
|
||||
// Emulate prepare and direct query are not supported with Always Encrypted
|
||||
$pdo_options[PDO::ATTR_EMULATE_PREPARES] = TRUE;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_DIRECT_QUERY] = TRUE;
|
||||
}
|
||||
$pdo_options[PDO::ATTR_CURSOR] = PDO::CURSOR_SCROLL;
|
||||
$pdo_options[PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE] = PDO::SQLSRV_CURSOR_BUFFERED;
|
||||
$st = $cnn->prepare('DROP TABLE WATCHDOG', $pdo_options);
|
||||
|
||||
$st->execute();
|
||||
|
||||
$tbname = "watchdog";
|
||||
createTable( $cnn, $tbname, array( "system_encoding" => "nvarchar(128)", "utf8_encoding" => "nvarchar(128)", "binary_encoding" => "varbinary(max)"));
|
||||
|
||||
$system_param = 'system encoded string';
|
||||
$utf8_param = '가각ácasa';
|
||||
$binary_param = fopen('php://memory', 'a');
|
||||
fwrite($binary_param, 'asdgasdgasdgsadg');
|
||||
rewind($binary_param);
|
||||
|
||||
$inputs = array("system_encoding" => $system_param,
|
||||
"utf8_encoding" => new BindParamOp( 2, $utf8_param, "PDO::PARAM_STR", 0, "PDO::SQLSRV_ENCODING_UTF8" ),
|
||||
"binary_encoding" => new BindParamOp( 3, $binary_param, "PDO::PARAM_LOB", 0, "PDO::SQLSRV_ENCODING_BINARY" ));
|
||||
|
||||
insertRow($cnn, $tbname, $inputs, "prepareBindParam");
|
||||
|
||||
$data = selectAll($cnn, $tbname);
|
||||
var_dump($data);
|
||||
|
||||
dropTable($cnn, $tbname);
|
||||
unset($st);
|
||||
unset($cnn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
catch(\Exception $e) {}
|
||||
|
||||
$tablescript = <<<EOF
|
||||
CREATE TABLE [dbo].[watchdog](
|
||||
[system_encoding] [nvarchar](128),
|
||||
[utf8_encoding] [nvarchar](128),
|
||||
[binary_encoding] [varbinary](max))
|
||||
EOF;
|
||||
|
||||
// Recreate
|
||||
$st = $cnn->prepare($tablescript, $pdo_options);
|
||||
$st->execute();
|
||||
|
||||
$query = <<<EOF
|
||||
INSERT INTO [watchdog] ([system_encoding], [utf8_encoding], [binary_encoding]) VALUES
|
||||
(?, ?, ?)
|
||||
EOF;
|
||||
|
||||
/** @var MyStatement */
|
||||
$st = $cnn->prepare($query, $pdo_options);
|
||||
|
||||
$system_param = 'system encoded string';
|
||||
$utf8_param = '가각ácasa';
|
||||
$binary_param = fopen('php://memory', 'a');
|
||||
fwrite($binary_param, 'asdgasdgasdgsadg');
|
||||
rewind($binary_param);
|
||||
|
||||
$st->bindParam(1, $system_param, PDO::PARAM_STR);
|
||||
$st->bindParam(2, $utf8_param, PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_UTF8);
|
||||
$st->bindParam(3, $binary_param, PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
|
||||
|
||||
$st->execute();
|
||||
|
||||
$st = $cnn->query("SELECT * FROM [watchdog]");
|
||||
var_dump($st->fetchAll());
|
||||
|
||||
$st = NULL;
|
||||
$cnn = NULL;
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
array(1) {
|
||||
|
|
|
|||
|
|
@ -1,53 +1,56 @@
|
|||
--TEST--
|
||||
sqlsrv_has_rows() using a forward and scrollable cursor
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
require_once("MsSetup.inc");
|
||||
try {
|
||||
// Connect
|
||||
$conn = connect();
|
||||
|
||||
// Connect
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName" , $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
// Create 2 tables
|
||||
$tableName1 = 'pdo_228_1';
|
||||
$tableName2 = 'pdo_228_2';
|
||||
|
||||
// Create temporary table2
|
||||
$tableName1 = '#pdo_228_1';
|
||||
$tableName2 = '#pdo_228_2';
|
||||
createTable($conn,$tableName1, array("c1_int" => "int", "c2_varchar" => "varchar(1000)"));
|
||||
insertRow($conn, $tableName1, array("c1_int" => 990021574, "c2_varchar" => ">vh~Ö.bÐ*äß/ÄAabýZâOüzr£ðAß+|~|OU¢a|U<ßrv.uCB.ÐÜh_î+ãå@üðöã,U+ßvuU:/ý_Öãî/ð|bB|_Zbua©r++BA¢z£.üî¢öåäözÜ¢ßb</üöîã,ZbOhߢAåb*öî:r>:aöCrÄ~ýZ¢uªÐö.hhßð*zÜÜß*ãüåýãÄ+åýüüaߢÃÐBî@~AZöÃOßC@äoÃuCÜ,ÐÄa:îäÄÖý:h*ouªuåvUz_ArßAªãaãvÐåAUüAB:¢Äz|öub<üZvößüå:ãÄ@r/ZAÄðÄÄvzîv~C/£|ýýbüÖ~£|Öå<Üa~/v@åAz©¢£U_ßhbaÃß,zz<ã¢|<ä©>öAuövÖ>abu,zå,+ß/ü/ª_bbB:ÃC~£ü/O©O©ªAª_,|a¢~ýý/b>ßC@/böîöh>~£ð+Bßr©ÄÐÖßã:bA@:>B:UAbããîÜ~uÜ£îCöÖ£©_ÜßzÐ+ÖýZb,A:<<AA*¢ã@Uî:B<öBîÐ>z.ãîÄzC@©*ä|ã._ßZOäb¢Cßovå+uv.£B~~b£ª|ÖÄîßö>©Ãbb|©©ðA£åO~âãüîuvÄÜýUzîOÖ/oOßO*>ªßzêÖÐböÄåbîðîÐa~©ßîÄßУ<î>å<býUrAA©r£@üÄb_:ãZß_/ou@|ªåü~ACãUO<£îßÄîäbßöhßO©ZvßOBü:Zä<ĪobbO@ÃÐ_~î|a~ð©+,v+Ð/rÃzuöÖZÐOß/CCÖßý¢:<b£B,ÐߢoZbð~BüOö,Üö~ð:ß,CCî<Oä,Öãî£ÜCZ~/z~ý©vuzoöß/u©å|£ãÐv¢îhý:ÄoÐrz.ßbr_U*<hCîßÖ_+:hbü*að.Aö_Oª_öB>Bã_ý*ah¢rOĪ,ßo¢¢a|BÖäz</bUabÖðOA.Ðîý,Bhö*Cßuߣo,|ü_,ýÐu_b|ZÜh|<U@~übU¢Uð/o/Ð>U£.B£@Ü,ßAÃ>,ðßß+ßÜ©|Ðr©bCðТüãz>AßðåÃ>bÄåÄ|Z~äÃ/Cb*£bð_/Ða@~AÜãO+ý*CîîÃzÄöÃa©+@vuz>î>©.Cv>hÃý>©Bä,ö~@~@r,AðCu@Ü,@U*ÐvöÃêuã.Öa*uZªoZ/ðÖ©ßv_<ÖvåÜÐÜOÐoðßðÃUýZÐB:+ÄÃã£"));
|
||||
|
||||
$stmt = $conn->exec("CREATE TABLE $tableName1 ([c1_int] int, [c2_varchar] varchar(1000))");
|
||||
$query = "INSERT INTO $tableName1 (c1_int, c2_varchar) VALUES ((990021574), ('>vh~Ö.bÐ*äß/ÄAabýZâOüzr£ðAß+|~|OU¢a|U<ßrv.uCB.ÐÜh_î+ãå@üðöã,U+ßvuU:/ý_Öãî/ð|bB|_Zbua©r++BA¢z£.üî¢öåäözÜ¢ßb</üöîã,ZbOhߢAåb*öî:r>:aöCrÄ~ýZ¢uªÐö.hhßð*zÜÜß*ãüåýãÄ+åýüüaߢÃÐBî@~AZöÃOßC@äoÃuCÜ,ÐÄa:îäÄÖý:h*ouªuåvUz_ArßAªãaãvÐåAUüAB:¢Äz|öub<üZvößüå:ãÄ@r/ZAÄðÄÄvzîv~C/£|ýýbüÖ~£|Öå<Üa~/v@åAz©¢£U_ßhbaÃß,zz<ã¢|<ä©>öAuövÖ>abu,zå,+ß/ü/ª_bbB:ÃC~£ü/O©O©ªAª_,|a¢~ýý/b>ßC@/böîöh>~£ð+Bßr©ÄÐÖßã:bA@:>B:UAbããîÜ~uÜ£îCöÖ£©_ÜßzÐ+ÖýZb,A:<<AA*¢ã@Uî:B<öBîÐ>z.ãîÄzC@©*ä|ã._ßZOäb¢Cßovå+uv.£B~~b£ª|ÖÄîßö>©Ãbb|©©ðA£åO~âãüîuvÄÜýUzîOÖ/oOßO*>ªßzêÖÐböÄåbîðîÐa~©ßîÄßУ<î>å<býUrAA©r£@üÄb_:ãZß_/ou@|ªåü~ACãUO<£îßÄîäbßöhßO©ZvßOBü:Zä<ĪobbO@ÃÐ_~î|a~ð©+,v+Ð/rÃzuöÖZÐOß/CCÖßý¢:<b£B,ÐߢoZbð~BüOö,Üö~ð:ß,CCî<Oä,Öãî£ÜCZ~/z~ý©vuzoöß/u©å|£ãÐv¢îhý:ÄoÐrz.ßbr_U*<hCîßÖ_+:hbü*að.Aö_Oª_öB>Bã_ý*ah¢rOĪ,ßo¢¢a|BÖäz</bUabÖðOA.Ðîý,Bhö*Cßuߣo,|ü_,ýÐu_b|ZÜh|<U@~übU¢Uð/o/Ð>U£.B£@Ü,ßAÃ>,ðßß+ßÜ©|Ðr©bCðТüãz>AßðåÃ>bÄåÄ|Z~äÃ/Cb*£bð_/Ða@~AÜãO+ý*CîîÃzÄöÃa©+@vuz>î>©.Cv>hÃý>©Bä,ö~@~@r,AðCu@Ü,@U*ÐvöÃêuã.Öa*uZªoZ/ðÖ©ßv_<ÖvåÜÐÜOÐoðßðÃUýZÐB:+ÄÃã£'))";
|
||||
$stmt = $conn->query($query);
|
||||
createTable($conn,$tableName2, array("c1_int" => "int", "c2_varchar" => "varchar(max)"));
|
||||
insertRow($conn, $tableName2, array("c1_int" => 990021574, "c2_varchar" => ">vh~Ö.bÐ*äß/ÄAabýZâOüzr£ðAß+|~|OU¢a|U<ßrv.uCB.ÐÜh_î+ãå@üðöã,U+ßvuU:/ý_Öãî/ð|bB|_Zbua©r++BA¢z£.üî¢öåäözÜ¢ßb</üöîã,ZbOhߢAåb*öî:r>:aöCrÄ~ýZ¢uªÐö.hhßð*zÜÜß*ãüåýãÄ+åýüüaߢÃÐBî@~AZöÃOßC@äoÃuCÜ,ÐÄa:îäÄÖý:h*ouªuåvUz_ArßAªãaãvÐåAUüAB:¢Äz|öub<üZvößüå:ãÄ@r/ZAÄðÄÄvzîv~C/£|ýýbüÖ~£|Öå<Üa~/v@åAz©¢£U_ßhbaÃß,zz<ã¢|<ä©>öAuövÖ>abu,zå,+ß/ü/ª_bbB:ÃC~£ü/O©O©ªAª_,|a¢~ýý/b>ßC@/böîöh>~£ð+Bßr©ÄÐÖßã:bA@:>B:UAbããîÜ~uÜ£îCöÖ£©_ÜßzÐ+ÖýZb,A:<<AA*¢ã@Uî:B<öBîÐ>z.ãîÄzC@©*ä|ã._ßZOäb¢Cßovå+uv.£B~~b£ª|ÖÄîßö>©Ãbb|©©ðA£åO~âãüîuvÄÜýUzîOÖ/oOßO*>ªßzêÖÐböÄåbîðîÐa~©ßîÄßУ<î>å<býUrAA©r£@üÄb_:ãZß_/ou@|ªåü~ACãUO<£îßÄîäbßöhßO©ZvßOBü:Zä<ĪobbO@ÃÐ_~î|a~ð©+,v+Ð/rÃzuöÖZÐOß/CCÖßý¢:<b£B,ÐߢoZbð~BüOö,Üö~ð:ß,CCî<Oä,Öãî£ÜCZ~/z~ý©vuzoöß/u©å|£ãÐv¢îhý:ÄoÐrz.ßbr_U*<hCîßÖ_+:hbü*að.Aö_Oª_öB>Bã_ý*ah¢rOĪ,ßo¢¢a|BÖäz</bUabÖðOA.Ðîý,Bhö*Cßuߣo,|ü_,ýÐu_b|ZÜh|<U@~übU¢Uð/o/Ð>U£.B£@Ü,ßAÃ>,ðßß+ßÜ©|Ðr©bCðТüãz>AßðåÃ>bÄåÄ|Z~äÃ/Cb*£bð_/Ða@~AÜãO+ý*CîîÃzÄöÃa©+@vuz>î>©.Cv>hÃý>©Bä,ö~@~@r,AðCu@Ü,@U*ÐvöÃêuã.Öa*uZªoZ/ðÖ©ßv_<ÖvåÜÐÜOÐoðßðÃUýZÐB:+ÄÃã£"));
|
||||
|
||||
$stmt = $conn->exec("CREATE TABLE $tableName2 ([c1_int] int, [c2_varchar] varchar(max))");
|
||||
$query = "INSERT INTO $tableName2 (c1_int, c2_varchar) VALUES ((990021574), ('>vh~Ö.bÐ*äß/ÄAabýZâOüzr£ðAß+|~|OU¢a|U<ßrv.uCB.ÐÜh_î+ãå@üðöã,U+ßvuU:/ý_Öãî/ð|bB|_Zbua©r++BA¢z£.üî¢öåäözÜ¢ßb</üöîã,ZbOhߢAåb*öî:r>:aöCrÄ~ýZ¢uªÐö.hhßð*zÜÜß*ãüåýãÄ+åýüüaߢÃÐBî@~AZöÃOßC@äoÃuCÜ,ÐÄa:îäÄÖý:h*ouªuåvUz_ArßAªãaãvÐåAUüAB:¢Äz|öub<üZvößüå:ãÄ@r/ZAÄðÄÄvzîv~C/£|ýýbüÖ~£|Öå<Üa~/v@åAz©¢£U_ßhbaÃß,zz<ã¢|<ä©>öAuövÖ>abu,zå,+ß/ü/ª_bbB:ÃC~£ü/O©O©ªAª_,|a¢~ýý/b>ßC@/böîöh>~£ð+Bßr©ÄÐÖßã:bA@:>B:UAbããîÜ~uÜ£îCöÖ£©_ÜßzÐ+ÖýZb,A:<<AA*¢ã@Uî:B<öBîÐ>z.ãîÄzC@©*ä|ã._ßZOäb¢Cßovå+uv.£B~~b£ª|ÖÄîßö>©Ãbb|©©ðA£åO~âãüîuvÄÜýUzîOÖ/oOßO*>ªßzêÖÐböÄåbîðîÐa~©ßîÄßУ<î>å<býUrAA©r£@üÄb_:ãZß_/ou@|ªåü~ACãUO<£îßÄîäbßöhßO©ZvßOBü:Zä<ĪobbO@ÃÐ_~î|a~ð©+,v+Ð/rÃzuöÖZÐOß/CCÖßý¢:<b£B,ÐߢoZbð~BüOö,Üö~ð:ß,CCî<Oä,Öãî£ÜCZ~/z~ý©vuzoöß/u©å|£ãÐv¢îhý:ÄoÐrz.ßbr_U*<hCîßÖ_+:hbü*að.Aö_Oª_öB>Bã_ý*ah¢rOĪ,ßo¢¢a|BÖäz</bUabÖðOA.Ðîý,Bhö*Cßuߣo,|ü_,ýÐu_b|ZÜh|<U@~übU¢Uð/o/Ð>U£.B£@Ü,ßAÃ>,ðßß+ßÜ©|Ðr©bCðТüãz>AßðåÃ>bÄåÄ|Z~äÃ/Cb*£bð_/Ða@~AÜãO+ý*CîîÃzÄöÃa©+@vuz>î>©.Cv>hÃý>©Bä,ö~@~@r,AðCu@Ü,@U*ÐvöÃêuã.Öa*uZªoZ/ðÖ©ßv_<ÖvåÜÐÜOÐoðßðÃUýZÐB:+ÄÃã£'))";
|
||||
$stmt = $conn->query($query);
|
||||
$size = 2;
|
||||
$stmt = $conn->prepare("SELECT * FROM $tableName1", array(constant('PDO::ATTR_CURSOR') => PDO::CURSOR_SCROLL,PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED,PDO::SQLSRV_ATTR_CLIENT_BUFFER_MAX_KB_SIZE=> $size));
|
||||
$attr = $stmt->getAttribute(constant('PDO::SQLSRV_ATTR_CLIENT_BUFFER_MAX_KB_SIZE'));
|
||||
echo("Client Buffer Size in KB: $attr\n");
|
||||
$stmt->execute();
|
||||
$numRows = 0;
|
||||
while ($result = $stmt->fetch()) {
|
||||
$numRows++;
|
||||
}
|
||||
echo ("Number of rows: $numRows\n");
|
||||
|
||||
$size = 2;
|
||||
$stmt = $conn->prepare("SELECT * FROM $tableName1", array(constant('PDO::ATTR_CURSOR') => PDO::CURSOR_SCROLL,PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED,PDO::SQLSRV_ATTR_CLIENT_BUFFER_MAX_KB_SIZE=> $size));
|
||||
$attr = $stmt->getAttribute(constant('PDO::SQLSRV_ATTR_CLIENT_BUFFER_MAX_KB_SIZE'));
|
||||
echo("Client Buffer Size in KB: $attr\n");
|
||||
$stmt->execute();
|
||||
$numRows = 0;
|
||||
while ($result = $stmt->fetch())
|
||||
$numRows++;
|
||||
|
||||
echo ("Number of rows: $numRows\n");
|
||||
$size = 3;
|
||||
$stmt = $conn->prepare("SELECT * FROM $tableName2", array(constant('PDO::ATTR_CURSOR') => PDO::CURSOR_SCROLL,PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED,PDO::SQLSRV_ATTR_CLIENT_BUFFER_MAX_KB_SIZE=> $size));
|
||||
$attr = $stmt->getAttribute(constant('PDO::SQLSRV_ATTR_CLIENT_BUFFER_MAX_KB_SIZE'));
|
||||
echo("Client Buffer Size in KB: $attr\n");
|
||||
$stmt->execute();
|
||||
$numRows = 0;
|
||||
while ($result = $stmt->fetch()) {
|
||||
$numRows++;
|
||||
}
|
||||
|
||||
echo ("Number of rows: $numRows\n");
|
||||
|
||||
$size = 3;
|
||||
$stmt = $conn->prepare("SELECT * FROM $tableName2", array(constant('PDO::ATTR_CURSOR') => PDO::CURSOR_SCROLL,PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED,PDO::SQLSRV_ATTR_CLIENT_BUFFER_MAX_KB_SIZE=> $size));
|
||||
$attr = $stmt->getAttribute(constant('PDO::SQLSRV_ATTR_CLIENT_BUFFER_MAX_KB_SIZE'));
|
||||
echo("Client Buffer Size in KB: $attr\n");
|
||||
$stmt->execute();
|
||||
$numRows = 0;
|
||||
while ($result = $stmt->fetch())
|
||||
$numRows++;
|
||||
|
||||
echo ("Number of rows: $numRows\n");
|
||||
|
||||
$stmt=null;
|
||||
$conn=null;
|
||||
print "Done"
|
||||
dropTable($conn, $tableName1);
|
||||
dropTable($conn, $tableName2);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
print "Done";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
|
||||
--EXPECT--
|
||||
|
|
|
|||
|
|
@ -1,26 +1,26 @@
|
|||
--TEST--
|
||||
Test closeCursor with a stmt before/after execute and fetch.
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
try
|
||||
{
|
||||
// Connect
|
||||
$conn = new PDO("sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$conn = connect();
|
||||
|
||||
$sql = "select 123 as 'IntCol'";
|
||||
// prepare a stmt but don't execute, then closeCursor.
|
||||
$stmt = $conn->prepare("select 123 as 'IntCol'");
|
||||
$stmt = $conn->prepare($sql);
|
||||
$ret = $stmt->closeCursor();
|
||||
var_dump($ret);
|
||||
$ret = $stmt->closeCursor();
|
||||
var_dump($ret);
|
||||
|
||||
// prepare a stmt and execute, then closeCursor.
|
||||
$stmt = $conn->prepare("select 123 as 'IntCol'");
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute();
|
||||
$ret = $stmt->closeCursor();
|
||||
var_dump($ret);
|
||||
|
|
@ -30,7 +30,7 @@ try
|
|||
|
||||
// use two stmt, execute, and fetch, then closeCursor.
|
||||
// use one with client side buffering.
|
||||
$stmt1 = $conn->query("select 123 as 'IntCol'");
|
||||
$stmt1 = $conn->query($sql);
|
||||
$stmt2 = $conn->prepare("select 'abc' as 'Charcol'", array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$result = $stmt1->fetch(PDO::FETCH_NUM);
|
||||
print_r($result[0]);
|
||||
|
|
@ -44,14 +44,12 @@ try
|
|||
$ret = $stmt2->closeCursor();
|
||||
var_dump($ret);
|
||||
|
||||
$stmt1 = null;
|
||||
$stmt2 = null;
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
|
||||
unset($stmt1);
|
||||
unset($stmt2);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
}
|
||||
|
||||
catch( PDOException $e ) {
|
||||
catch(PDOException $e) {
|
||||
var_dump($e);
|
||||
exit;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,90 +4,96 @@ Test fetch from binary, varbinary, varbinary(max), image columns, without settin
|
|||
Verifies GitHub issue 270 is fixed, users could not retrieve the data as inserted in binary columns without setting the binary encoding either on stmt or using bindCoulmn encoding.
|
||||
This test verifies that the data inserted in binary columns can be retrieved using fetch, fetchColumn, fetchObject, and fetchAll functions.
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$tableName = 'test_binary'.rand();
|
||||
$columns = array( 'col1', 'col2', 'col3', 'col4');
|
||||
$columns = array('col1', 'col2', 'col3');
|
||||
|
||||
// Connect
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd );
|
||||
try {
|
||||
// Connect
|
||||
$conn = connect();
|
||||
|
||||
$sql = "CREATE TABLE $tableName ( $columns[0] binary(50), $columns[1] VARBINARY(50), $columns[2] VARBINARY(MAX), $columns[3] image)";
|
||||
$conn->exec($sql);
|
||||
$colmeta_arr = array($columns[0] => "binary(50)", $columns[1] => "varbinary(50)", $columns[2] => "varbinary(max)");
|
||||
$icon = base64_decode("This is some text to test retrieving from binary type columns");
|
||||
$inputs = array($columns[0] => new BindParamOp(1, $icon, "PDO::PARAM_LOB", null, "PDO::SQLSRV_ENCODING_BINARY"),
|
||||
$columns[1] => new BindParamOp(2, $icon, "PDO::PARAM_LOB", null, "PDO::SQLSRV_ENCODING_BINARY"),
|
||||
$columns[2] => new BindParamOp(3, $icon, "PDO::PARAM_LOB", null, "PDO::SQLSRV_ENCODING_BINARY"));
|
||||
|
||||
$icon = base64_decode("This is some text to test retrieving from binary type columns");
|
||||
|
||||
// Insert data using bind parameters
|
||||
$sql = "INSERT INTO $tableName($columns[0], $columns[1], $columns[2], $columns[3]) VALUES(?, ?, ?, ?)";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->bindParam(1, $icon, PDO::PARAM_LOB, null, PDO::SQLSRV_ENCODING_BINARY);
|
||||
$stmt->bindParam(2, $icon, PDO::PARAM_LOB, null, PDO::SQLSRV_ENCODING_BINARY);
|
||||
$stmt->bindParam(3, $icon, PDO::PARAM_LOB, null, PDO::SQLSRV_ENCODING_BINARY);
|
||||
$stmt->bindParam(4, $icon, PDO::PARAM_LOB, null, PDO::SQLSRV_ENCODING_BINARY);
|
||||
$stmt->execute();
|
||||
|
||||
// loop through each column in the table
|
||||
foreach ($columns as $col){
|
||||
test_fetch($conn, $tableName, $col, $icon);
|
||||
}
|
||||
// DROP table
|
||||
$conn->query("DROP TABLE $tableName") ?: die();
|
||||
|
||||
//free statement and connection
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
|
||||
print_r("Test finished successfully");
|
||||
|
||||
//calls various fetch methods
|
||||
function test_fetch($conn, $tableName, $columnName, $input){
|
||||
if (!isColEncrypted()) {
|
||||
// image is not supported for encryption
|
||||
array_push($columns, 'col4');
|
||||
$colmeta_arr += array($columns[3] => "image");
|
||||
$inputs += array( $columns[3] => new BindParamOp(4, $icon, "PDO::PARAM_LOB", null, "PDO::SQLSRV_ENCODING_BINARY"));
|
||||
}
|
||||
|
||||
createTable($conn, $tableName, $colmeta_arr);
|
||||
|
||||
// Insert data using bind parameters
|
||||
insertRow($conn, $tableName, $inputs, "prepareBindParam");
|
||||
|
||||
// loop through each column in the table
|
||||
foreach ($columns as $col) {
|
||||
testFetch($conn, $tableName, $col, $icon);
|
||||
}
|
||||
// DROP table
|
||||
dropTable($conn, $tableName);
|
||||
|
||||
//free statement and connection
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
print_r("Test finished successfully\n");
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
|
||||
//calls various fetch methods
|
||||
function testFetch($conn, $tableName, $columnName, $input)
|
||||
{
|
||||
$len = strlen($input);
|
||||
$result = "";
|
||||
$sql = "SELECT $columnName from $tableName";
|
||||
|
||||
$stmt = $conn->query($sql);
|
||||
$stmt = $conn->query($sql);
|
||||
$stmt->bindColumn(1, $result, PDO::PARAM_LOB);
|
||||
$stmt->fetch(PDO::FETCH_BOUND);
|
||||
//binary is fixed size, to evaluate output, compare it using strncmp
|
||||
if( strncmp($result, $input, $len) !== 0){
|
||||
if (strncmp($result, $input, $len) !== 0) {
|
||||
print_r("\nRetrieving using bindColumn failed");
|
||||
}
|
||||
|
||||
$result = "";
|
||||
$stmt = $conn->query($sql);
|
||||
$stmt->bindColumn(1, $result, PDO::PARAM_LOB, 0 , PDO::SQLSRV_ENCODING_BINARY);
|
||||
$stmt = $conn->query($sql);
|
||||
$stmt->bindColumn(1, $result, PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
|
||||
$stmt->fetch(PDO::FETCH_BOUND);
|
||||
if( strncmp($result, $input, $len) !== 0){
|
||||
if (strncmp($result, $input, $len) !== 0) {
|
||||
print_r("\nRetrieving using bindColumn with encoding set failed");
|
||||
}
|
||||
|
||||
$result = "";
|
||||
$stmt = $conn->query($sql);
|
||||
$stmt = $conn->query($sql);
|
||||
$result = $stmt->fetchColumn();
|
||||
if( strncmp($result, $input, $len) !== 0){
|
||||
if (strncmp($result, $input, $len) !== 0) {
|
||||
print_r("\nRetrieving using fetchColumn failed");
|
||||
}
|
||||
|
||||
$result = "";
|
||||
$stmt = $conn->query($sql);
|
||||
$stmt = $conn->query($sql);
|
||||
$result = $stmt->fetchObject();
|
||||
if( strncmp($result->$columnName, $input, $len) !== 0){
|
||||
if (strncmp($result->$columnName, $input, $len) !== 0) {
|
||||
print_r("\nRetrieving using fetchObject failed");
|
||||
}
|
||||
|
||||
$result = "";
|
||||
$stmt = $conn->query($sql);
|
||||
$result = $stmt->fetchAll( PDO::FETCH_COLUMN );
|
||||
if( strncmp($result[0], $input, $len) !== 0){
|
||||
$stmt = $conn->query($sql);
|
||||
$result = $stmt->fetchAll(PDO::FETCH_COLUMN);
|
||||
if (strncmp($result[0], $input, $len) !== 0) {
|
||||
print_r("\nRetrieving using fetchAll failed");
|
||||
}
|
||||
unset($stmt);
|
||||
}
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
Test finished successfully
|
||||
|
|
|
|||
|
|
@ -1,61 +1,75 @@
|
|||
--TEST--
|
||||
Provide name in lastInsertId to retrieve the last sequence number
|
||||
--SKIPIF--
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsCommon.inc");
|
||||
require_once("MsSetup.inc");
|
||||
<?php
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
try{
|
||||
function getNextSeq($conn, $sequenceName)
|
||||
{
|
||||
$sql = "SELECT NEXT VALUE FOR $sequenceName";
|
||||
$stmt = $conn->query($sql);
|
||||
return $stmt->fetchColumn();
|
||||
}
|
||||
|
||||
try {
|
||||
$database = "tempdb";
|
||||
$conn = new PDO("sqlsrv:Server=$server;Database=$databaseName", $uid, $pwd);
|
||||
|
||||
$conn = connect();
|
||||
|
||||
// sequence is only supported in SQL server 2012 and up (or version 11 and up)
|
||||
// Output Done once the server version is found to be < 11
|
||||
$version_arr = explode(".", $conn->getAttribute(PDO::ATTR_SERVER_VERSION));
|
||||
if ($version_arr[0] < 11) {
|
||||
echo "Done\n";
|
||||
}
|
||||
else {
|
||||
$tableName1 = GetTempTableName('tab1', false);
|
||||
$tableName2 = GetTempTableName('tab2', false);
|
||||
} else {
|
||||
$tableName1 = getTableName('tab1');
|
||||
$tableName2 = getTableName('tab2');
|
||||
$sequenceName = 'sequence1';
|
||||
|
||||
$stmt = $conn->query("IF OBJECT_ID('$sequenceName', 'SO') IS NOT NULL DROP SEQUENCE $sequenceName");
|
||||
$sql = "CREATE TABLE $tableName1 (seqnum INTEGER NOT NULL PRIMARY KEY, SomeNumber INT)";
|
||||
$stmt = $conn->query($sql);
|
||||
$sql = "CREATE TABLE $tableName2 (ID INT IDENTITY(1,2), SomeValue char(10))";
|
||||
$stmt = $conn->query($sql);
|
||||
|
||||
|
||||
createTable($conn, $tableName1, array( new ColumnMeta("int", "seqnum", "NOT NULL PRIMARY KEY"), "SomeNumer" => "int"));
|
||||
createTable($conn, $tableName2, array( new ColumnMeta("int", "ID", "IDENTITY(1,2)"), "SomeValue" => "char(10)"));
|
||||
$conn->exec("IF OBJECT_ID('$sequenceName', 'SO') IS NOT NULL DROP SEQUENCE $sequenceName");
|
||||
$sql = "CREATE SEQUENCE $sequenceName AS INTEGER START WITH 1 INCREMENT BY 1 MINVALUE 1 MAXVALUE 100 CYCLE";
|
||||
$stmt = $conn->query($sql);
|
||||
|
||||
$ret = $conn->exec("INSERT INTO $tableName1 VALUES( NEXT VALUE FOR $sequenceName, 20 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName1 VALUES( NEXT VALUE FOR $sequenceName, 40 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName1 VALUES( NEXT VALUE FOR $sequenceName, 60 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName2 VALUES( '20' )");
|
||||
$conn->exec($sql);
|
||||
|
||||
if (!isColEncrypted()) {
|
||||
$conn->exec("INSERT INTO $tableName1 VALUES( NEXT VALUE FOR $sequenceName, 20 )");
|
||||
$conn->exec("INSERT INTO $tableName1 VALUES( NEXT VALUE FOR $sequenceName, 40 )");
|
||||
$conn->exec("INSERT INTO $tableName1 VALUES( NEXT VALUE FOR $sequenceName, 60 )");
|
||||
} else {
|
||||
// if column seqnum is encrypted, need to get "NEXT VALUE FOR $sequenceName" separately first and then bind param
|
||||
$sql = "INSERT INTO $tableName1 VALUES( ?, ? )";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$nextSeq = getNextSeq($conn, $sequenceName);
|
||||
$stmt->execute(array($nextSeq, 20));
|
||||
$nextSeq = getNextSeq($conn, $sequenceName);
|
||||
$stmt->execute(array($nextSeq, 40));
|
||||
$nextSeq = getNextSeq($conn, $sequenceName);
|
||||
$stmt->execute(array($nextSeq, 60));
|
||||
}
|
||||
insertRow($conn, $tableName2, array("SomeValue" => "20"));
|
||||
|
||||
// return the last sequence number is sequence name is provided
|
||||
$lastSeq = $conn->lastInsertId($sequenceName);
|
||||
// defaults to $tableName2 -- because it returns the last inserted id value
|
||||
// defaults to $tableName2 -- because it returns the last inserted row id value
|
||||
$lastRow = $conn->lastInsertId();
|
||||
|
||||
|
||||
if ($lastSeq == 3 && $lastRow == 1) {
|
||||
echo "Done\n";
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
echo "sequence value or identity does not match as expected\n";
|
||||
}
|
||||
$stmt = $conn->query("DROP TABLE $tableName1");
|
||||
$stmt = $conn->query("DROP TABLE $tableName2");
|
||||
$stmt = $conn->query("DROP SEQUENCE $sequenceName");
|
||||
$stmt = null;
|
||||
dropTable($conn, $tableName1);
|
||||
dropTable($conn, $tableName2);
|
||||
$conn->exec("DROP SEQUENCE $sequenceName");
|
||||
unset($stmt);
|
||||
}
|
||||
$conn = null;
|
||||
}
|
||||
catch (Exception $e){
|
||||
unset($conn);
|
||||
} catch (Exception $e) {
|
||||
echo "Exception $e\n";
|
||||
}
|
||||
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
Done
|
||||
Done
|
||||
|
|
|
|||
|
|
@ -1,64 +1,85 @@
|
|||
--TEST--
|
||||
LastInsertId returns the last sequences operating on the same table
|
||||
--SKIPIF--
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsCommon.inc");
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
function getNextSeq($conn, $sequenceName)
|
||||
{
|
||||
$sql = "SELECT NEXT VALUE FOR $sequenceName";
|
||||
$stmt = $conn->query($sql);
|
||||
return $stmt->fetchColumn();
|
||||
}
|
||||
|
||||
try {
|
||||
$conn = connect();
|
||||
|
||||
try{
|
||||
$database = "tempdb";
|
||||
$conn = new PDO("sqlsrv:Server=$server;Database=$databaseName", $uid, $pwd);
|
||||
|
||||
// sequence is only supported in SQL server 2012 and up (or version 11 and up)
|
||||
// Output Done once the server version is found to be < 11
|
||||
$version_arr = explode(".", $conn->getAttribute(PDO::ATTR_SERVER_VERSION));
|
||||
if ($version_arr[0] < 11) {
|
||||
echo "Done\n";
|
||||
}
|
||||
else {
|
||||
$tableName = GetTempTableName('tab', false);
|
||||
} else {
|
||||
$tableName = getTableName('tab');
|
||||
$sequence1 = 'sequence1';
|
||||
$sequence2 = 'sequenceNeg1';
|
||||
$stmt = $conn->query("IF OBJECT_ID('$sequence1', 'SO') IS NOT NULL DROP SEQUENCE $sequence1");
|
||||
$stmt = $conn->query("IF OBJECT_ID('$sequence2', 'SO') IS NOT NULL DROP SEQUENCE $sequence2");
|
||||
$sql = "CREATE TABLE $tableName (ID INT IDENTITY(1,1), SeqNumInc INTEGER NOT NULL PRIMARY KEY, SomeNumber INT)";
|
||||
$stmt = $conn->query($sql);
|
||||
createTable($conn, $tableName, array( new ColumnMeta("int", "ID", "IDENTITY(1,1)"), new ColumnMeta("int", "SeqNumInc", "NOT NULL PRIMARY KEY"), "SomeNumber" => "int"));
|
||||
$conn->exec("IF OBJECT_ID('$sequence1', 'SO') IS NOT NULL DROP SEQUENCE $sequence1");
|
||||
$conn->exec("IF OBJECT_ID('$sequence2', 'SO') IS NOT NULL DROP SEQUENCE $sequence2");
|
||||
$sql = "CREATE SEQUENCE $sequence1 AS INTEGER START WITH 1 INCREMENT BY 1 MINVALUE 1 MAXVALUE 100";
|
||||
$stmt = $conn->query($sql);
|
||||
|
||||
$stmt = $conn->exec($sql);
|
||||
$sql = "CREATE SEQUENCE $sequence2 AS INTEGER START WITH 200 INCREMENT BY -1 MINVALUE 101 MAXVALUE 200";
|
||||
$stmt = $conn->query($sql);
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence1, 20 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence2, 180 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence1, 40 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence2, 160 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence1, 60 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence2, 140 )");
|
||||
$stmt = $conn->exec($sql);
|
||||
|
||||
if (!isColEncrypted()) {
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence1, 20 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence2, 180 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence1, 40 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence2, 160 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence1, 60 )");
|
||||
$ret = $conn->exec("INSERT INTO $tableName VALUES( NEXT VALUE FOR $sequence2, 140 )");
|
||||
} else {
|
||||
// if column seqnum is encrypted, need to get "NEXT VALUE FOR $sequenceName" separately first and then bind param
|
||||
$sql = "INSERT INTO $tableName VALUES( ?, ? )";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$nextSeq1 = getNextSeq($conn, $sequence1);
|
||||
$stmt->execute(array( $nextSeq1, 20 ));
|
||||
$nextSeq2 = getNextSeq($conn, $sequence2);
|
||||
$stmt->execute(array( $nextSeq2, 180 ));
|
||||
$nextSeq1 = getNextSeq($conn, $sequence1);
|
||||
$stmt->execute(array( $nextSeq1, 40 ));
|
||||
$nextSeq2 = getNextSeq($conn, $sequence2);
|
||||
$stmt->execute(array( $nextSeq2, 160 ));
|
||||
$nextSeq1 = getNextSeq($conn, $sequence1);
|
||||
$stmt->execute(array( $nextSeq1, 60 ));
|
||||
$nextSeq2 = getNextSeq($conn, $sequence2);
|
||||
$stmt->execute(array( $nextSeq2, 140 ));
|
||||
}
|
||||
// return the last sequence number of 'sequence1'
|
||||
$lastSeq1 = $conn->lastInsertId($sequence1);
|
||||
|
||||
|
||||
// return the last sequence number of 'sequenceNeg1'
|
||||
$lastSeq2 = $conn->lastInsertId($sequence2);
|
||||
|
||||
|
||||
// providing a table name in lastInsertId should return an empty string
|
||||
$lastSeq3 = $conn->lastInsertId($tableName);
|
||||
|
||||
|
||||
if ($lastSeq1 == 3 && $lastSeq2 == 198 && $lastSeq3 == "") {
|
||||
echo "Done\n";
|
||||
}
|
||||
|
||||
$stmt = $conn->query("DROP TABLE $tableName");
|
||||
$stmt = $conn->query("DROP SEQUENCE $sequence1");
|
||||
$stmt = $conn->query("DROP SEQUENCE $sequence2");
|
||||
$stmt = null;
|
||||
dropTable($conn, $tableName);
|
||||
$stmt = $conn->exec("DROP SEQUENCE $sequence1");
|
||||
$stmt = $conn->exec("DROP SEQUENCE $sequence2");
|
||||
unset($stmt);
|
||||
}
|
||||
$conn = null;
|
||||
}
|
||||
catch (Exception $e){
|
||||
unset($conn);
|
||||
} catch (Exception $e) {
|
||||
echo "Exception $e\n";
|
||||
}
|
||||
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
Done
|
||||
Done
|
||||
|
|
|
|||
|
|
@ -1,46 +1,49 @@
|
|||
--TEST--
|
||||
GitHub issue #308 - empty string set to output parameter on stored procedure
|
||||
GitHub issue #308 - empty string set to output parameter on stored procedure
|
||||
--DESCRIPTION--
|
||||
Verifies GitHub issue 308 is fixed, empty string returned as output parameter will remain an empty string.
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsCommon.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// Connect
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO("sqlsrv:server=$server;database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
try {
|
||||
// Connect
|
||||
$conn = connect();
|
||||
|
||||
$procName = GetTempProcName();
|
||||
$procName = getProcName();
|
||||
|
||||
$sql = "CREATE PROCEDURE $procName @TEST VARCHAR(200)='' OUTPUT
|
||||
AS BEGIN
|
||||
SET NOCOUNT ON;
|
||||
SET @TEST='';
|
||||
SELECT HELLO_WORLD_COLUMN='THIS IS A COLUMN IN A SINGLE DATASET';
|
||||
END";
|
||||
$stmt = $conn->exec($sql);
|
||||
$sql = "CREATE PROCEDURE $procName @TEST VARCHAR(200)='' OUTPUT
|
||||
AS BEGIN
|
||||
SET NOCOUNT ON;
|
||||
SET @TEST='';
|
||||
SELECT HELLO_WORLD_COLUMN='THIS IS A COLUMN IN A SINGLE DATASET';
|
||||
END";
|
||||
$stmt = $conn->exec($sql);
|
||||
|
||||
$sql = "EXEC $procName @Test = :Test";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$out = '';
|
||||
$stmt->bindParam(':Test', $out, PDO::PARAM_STR | PDO::PARAM_INPUT_OUTPUT, 200);
|
||||
$stmt->execute();
|
||||
$sql = "EXEC $procName @Test = :Test";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$out = '';
|
||||
$stmt->bindParam(':Test', $out, PDO::PARAM_STR | PDO::PARAM_INPUT_OUTPUT, 200);
|
||||
$stmt->execute();
|
||||
|
||||
$result = $stmt->fetchAll();
|
||||
$stmt->closeCursor();
|
||||
$result = $stmt->fetchAll();
|
||||
$stmt->closeCursor();
|
||||
|
||||
echo "OUT value: ";
|
||||
var_dump($out);
|
||||
echo "OUT value: ";
|
||||
var_dump($out);
|
||||
|
||||
// Free the statement and connection resources.
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
// Free the statement and connection resources.
|
||||
dropProc($conn, $procName);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
print "Done";
|
||||
?>
|
||||
print "Done\n";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
OUT value: string(0) ""
|
||||
Done
|
||||
Done
|
||||
|
|
|
|||
|
|
@ -3,55 +3,58 @@ GitHub issue #336 - PDO::exec should not return an error with query returning SQ
|
|||
--DESCRIPTION--
|
||||
Verifies GitHub issue 336 is fixed, PDO::exec on query returning SQL_NO_DATA will not give an error
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
// Connect
|
||||
require_once("MsSetup.inc");
|
||||
// Connect
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$conn = new PDO("sqlsrv:server=$server;database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
try {
|
||||
$conn = connect();
|
||||
|
||||
$sql = "DELETE FROM foo_table WHERE id = 42";
|
||||
$sqlWithParameter = "DELETE FROM foo_table WHERE id = :id";
|
||||
$sqlParameter = 42;
|
||||
$tbname = "foo_table";
|
||||
createTable($conn, $tbname, array(new ColumnMeta("bigint", "id", "PRIMARY KEY NOT NULL IDENTITY"), new ColumnMeta("int", "intField", "NOT NULL")));
|
||||
insertRow($conn, $tbname, array("intField" => 3), "exec");
|
||||
|
||||
$Statement = $conn->exec("IF OBJECT_ID('foo_table', 'U') IS NOT NULL DROP TABLE foo_table");
|
||||
$Statement = $conn->exec("CREATE TABLE foo_table (id BIGINT PRIMARY KEY NOT NULL IDENTITY, intField INT NOT NULL)");
|
||||
$Statement = $conn->exec("INSERT INTO foo_table (intField) VALUES(3)");
|
||||
//test prepare, not args
|
||||
$sql = "DELETE FROM foo_table WHERE id = 42";
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute();
|
||||
if ($conn->errorCode() == "00000") {
|
||||
echo "prepare OK\n";
|
||||
} else {
|
||||
echo "unexpected error at prepare";
|
||||
}
|
||||
|
||||
//test prepare, not args
|
||||
$stmt = $conn->prepare($sql);
|
||||
$stmt->execute();
|
||||
if ($conn->errorCode() == "00000")
|
||||
echo "prepare OK\n";
|
||||
else
|
||||
echo "unexpected error at prepare";
|
||||
//test prepare, with args
|
||||
$sqlWithParameter = "DELETE FROM foo_table WHERE id = :id";
|
||||
$sqlParameter = 42;
|
||||
$stmt = $conn->prepare($sqlWithParameter);
|
||||
$stmt->execute(array(':id' => $sqlParameter));
|
||||
if ($conn->errorCode() == "00000") {
|
||||
echo "prepare with args OK\n";
|
||||
} else {
|
||||
echo "unexpected error at prepare with args";
|
||||
}
|
||||
|
||||
//test prepare, with args
|
||||
$stmt = $conn->prepare($sqlWithParameter);
|
||||
$stmt->execute(array(':id' => $sqlParameter));
|
||||
if ($conn->errorCode() == "00000")
|
||||
echo "prepare with args OK\n";
|
||||
else
|
||||
echo "unexpected error at prepare with args";
|
||||
|
||||
//test direct exec
|
||||
$stmt = $conn->exec($sql);
|
||||
$err = $conn->errorCode();
|
||||
if ($stmt == 0 && $err == "00000")
|
||||
echo "direct exec OK\n";
|
||||
else
|
||||
if ($stmt != 0)
|
||||
//test direct exec
|
||||
$numrow = $conn->exec($sql);
|
||||
$err = $conn->errorCode();
|
||||
if ($numrow == 0 && $err == "00000") {
|
||||
echo "direct exec OK\n";
|
||||
} elseif ($numrow != 0) {
|
||||
echo "unexpected row returned at direct exec\n";
|
||||
if ($err != "00000")
|
||||
}
|
||||
if ($err != "00000") {
|
||||
echo "unexpected error at direct exec";
|
||||
}
|
||||
|
||||
$Statement = $conn->exec("IF OBJECT_ID('foo_table', 'U') IS NOT NULL DROP TABLE foo_table");
|
||||
|
||||
$stmt = NULL;
|
||||
$Statement = NULL;
|
||||
$conn = NULL;
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
|
|
|
|||
|
|
@ -3,57 +3,65 @@ This test verifies that GitHub issue #378 is fixed in pdo_sqlsrv.
|
|||
--DESCRIPTION--
|
||||
GitHub issue #378 - output parameters appends garbage info when variable is initialized with different data type
|
||||
steps to reproduce the issue:
|
||||
1- create a store procedure with print and output parameter
|
||||
2- initialize output parameters to a different data type other than the type declared in sp.
|
||||
1 - create a store procedure with print and output parameter
|
||||
2 - initialize output parameters to a different data type other than the type declared in sp.
|
||||
3 - call sp.
|
||||
--SKIPIF--
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$conn = new PDO( "sqlsrv:Server=$server; Database = $databaseName", $uid, $pwd);
|
||||
if (!$conn) {
|
||||
print_r($conn->errorInfo());
|
||||
try {
|
||||
$conn = connect();
|
||||
if (!$conn) {
|
||||
print_r($conn->errorInfo());
|
||||
}
|
||||
|
||||
//----------------Main---------------------------
|
||||
$procName = getProcName();
|
||||
createSP($conn, $procName);
|
||||
executeSP($conn, $procName);
|
||||
executeSP($conn, $procName);
|
||||
dropProc($conn, $procName);
|
||||
echo "Done\n";
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
|
||||
//----------------Main---------------------------
|
||||
$procName = GetTempProcName();
|
||||
createSP($conn, $procName);
|
||||
executeSP($conn, $procName);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
executeSP($conn, $procName);
|
||||
echo "Done";
|
||||
|
||||
//-------------------functions-------------------
|
||||
function createSP($conn, $procName){
|
||||
|
||||
$sp_sql="create proc $procName @p1 integer, @p2 integer, @p3 integer output
|
||||
as
|
||||
begin
|
||||
select @p3 = @p1 + @p2
|
||||
print @p3
|
||||
end
|
||||
";
|
||||
$stmt = $conn->exec($sp_sql);
|
||||
if ($stmt === false) { print("Failed to create stored procedure"); }
|
||||
function createSP($conn, $procName)
|
||||
{
|
||||
$sp_sql="create proc $procName @p1 integer, @p2 integer, @p3 integer output
|
||||
as
|
||||
begin
|
||||
select @p3 = @p1 + @p2
|
||||
print @p3
|
||||
end";
|
||||
$stmt = $conn->exec($sp_sql);
|
||||
if ($stmt === false) {
|
||||
print("Failed to create stored procedure");
|
||||
}
|
||||
}
|
||||
|
||||
function executeSP($conn, $procName){
|
||||
$expected = 3;
|
||||
$stmt = $conn->prepare("{call $procName( ?, ?, ? )}");
|
||||
$stmt->bindParam(1, $v1);
|
||||
$stmt->bindParam(2, $v2);
|
||||
$stmt->bindParam(3, $v3, PDO::PARAM_INT, 10);
|
||||
$v1 = 1;
|
||||
$v2 = 2;
|
||||
$v3 = 'str';
|
||||
$stmt->execute();
|
||||
if (!$stmt) {
|
||||
print_r($stmt->errorInfo());
|
||||
}
|
||||
if ( $v3 != $expected ) {
|
||||
print("The expected value is $expected, actual value is $v3\n");
|
||||
}
|
||||
function executeSP($conn, $procName)
|
||||
{
|
||||
$expected = 3;
|
||||
$stmt = $conn->prepare("{call $procName( ?, ?, ? )}");
|
||||
$stmt->bindParam(1, $v1);
|
||||
$stmt->bindParam(2, $v2);
|
||||
$stmt->bindParam(3, $v3, PDO::PARAM_INT, 10);
|
||||
$v1 = 1;
|
||||
$v2 = 2;
|
||||
$v3 = 'str';
|
||||
$stmt->execute();
|
||||
if (!$stmt) {
|
||||
print_r($stmt->errorInfo());
|
||||
}
|
||||
if ($v3 != $expected) {
|
||||
print("The expected value is $expected, actual value is $v3\n");
|
||||
}
|
||||
unset($stmt);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
|
|
|
|||
24
test/functional/pdo_sqlsrv/pdo_538_quote_nul.phpt
Normal file
24
test/functional/pdo_sqlsrv/pdo_538_quote_nul.phpt
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
--TEST--
|
||||
Test the PDO::quote() method with a string containing '\0' character
|
||||
--SKIPIF--
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
try {
|
||||
$connection = connect();
|
||||
|
||||
$str = "XX\0XX";
|
||||
|
||||
print("Original: " . str_replace("\0", "{NUL}", $str) . "\n");
|
||||
$str = $connection->quote($str);
|
||||
print("Quoted: " . str_replace("\0", "{NUL}", $str) . "\n");
|
||||
} catch (PDOException $e) {
|
||||
die("Connection error: " . $e->getMessage());
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
Original: XX{NUL}XX
|
||||
Quoted: 'XX{NUL}XX'
|
||||
|
|
@ -1,5 +1,6 @@
|
|||
--TEST--
|
||||
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'); ?>
|
||||
|
|
@ -73,4 +74,4 @@ c_rand: 23:59:59.9999999
|
|||
Testing datetimeoffset:
|
||||
****Encrypted default type is compatible with encrypted datetimeoffset****
|
||||
c_det: 0001-01-01 00:00:00.0000000 -14:00
|
||||
c_rand: 9999-12-31 23:59:59.9999999 +14:00
|
||||
c_rand: 9999-12-31 23:59:59.9999999 +14:00
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
--TEST--
|
||||
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'); ?>
|
||||
|
|
@ -82,4 +83,4 @@ Testing smallmoney:
|
|||
Test successfully done.
|
||||
|
||||
Testing money:
|
||||
Test successfully done.
|
||||
Test successfully done.
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
--TEST--
|
||||
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'); ?>
|
||||
|
|
@ -88,4 +89,4 @@ c_rand: 9223372036.8547993
|
|||
Testing real:
|
||||
****Encrypted default type is compatible with encrypted real****
|
||||
c_det: -2147.4829
|
||||
c_rand: 2147.4829
|
||||
c_rand: 2147.4829
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
--TEST--
|
||||
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'); ?>
|
||||
|
|
@ -150,4 +151,4 @@ c_det: 0001-01-01 00:00:00.0000000 -14:00
|
|||
c_rand: 9999-12-31 23:59:59.9999999 +14:00
|
||||
****PDO param type PDO::PARAM_LOB is compatible with encrypted datetimeoffset****
|
||||
c_det: 0001-01-01 00:00:00.0000000 -14:00
|
||||
c_rand: 9999-12-31 23:59:59.9999999 +14:00
|
||||
c_rand: 9999-12-31 23:59:59.9999999 +14:00
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
--TEST--
|
||||
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'); ?>
|
||||
|
|
@ -89,4 +90,4 @@ Testing smallmoney:
|
|||
Test successfully done.
|
||||
|
||||
Testing money:
|
||||
Test successfully done.
|
||||
Test successfully done.
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
--TEST--
|
||||
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'); ?>
|
||||
|
|
@ -184,4 +185,4 @@ c_det: -2147.4829
|
|||
c_rand: 2147.4829
|
||||
****PDO param type PDO::PARAM_LOB is compatible with encrypted real****
|
||||
c_det: -2147.4829
|
||||
c_rand: 2147.4829
|
||||
c_rand: 2147.4829
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
--TEST--
|
||||
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'); ?>
|
||||
|
|
@ -117,4 +118,4 @@ c_det: When prefixing a string constant with the letter N, the implicit conversi
|
|||
c_rand: Otherwise, the implicit conversion will result in a Unicode large-value (max).
|
||||
****PDO param type PDO::PARAM_LOB is compatible with encrypted nvarchar(max)****
|
||||
c_det: 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).
|
||||
c_rand: Otherwise, the implicit conversion will result in a Unicode large-value (max).
|
||||
c_rand: Otherwise, the implicit conversion will result in a Unicode large-value (max).
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
--TEST--
|
||||
Test for inserting encrypted data and retrieving both encrypted and decrypted data
|
||||
--DESCRIPTION--
|
||||
Retrieving SQL query contains encrypted filter
|
||||
--SKIPIF--
|
||||
<?php require('skipif_versions_old.inc'); ?>
|
||||
|
|
@ -79,4 +80,4 @@ LastName: Abel
|
|||
BirthDate: 1996-10-19
|
||||
|
||||
Checking ciphertext data:
|
||||
Done
|
||||
Done
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
--TEST--
|
||||
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'); ?>
|
||||
|
|
@ -63,4 +64,4 @@ c_rand: th Un
|
|||
Testing nvarchar(max):
|
||||
****Encrypted default type is compatible with encrypted nvarchar(max)****
|
||||
c_det: 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).
|
||||
c_rand: Otherwise, the implicit conversion will result in a Unicode large-value (max).
|
||||
c_rand: Otherwise, the implicit conversion will result in a Unicode large-value (max).
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
--TEST--
|
||||
Test the Authentication keyword and three options: SqlPassword, ActiveDirectoryIntegrated, and ActiveDirectoryPassword.
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif.inc');
|
||||
require('skipif_version_less_than_2k16.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
|
|
|
|||
82
test/functional/pdo_sqlsrv/pdo_bigint_outparam.phpt
Normal file
82
test/functional/pdo_sqlsrv/pdo_bigint_outparam.phpt
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
--TEST--
|
||||
Test for binding bigint output and inout parameters
|
||||
--SKIPIF--
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$conn = connect();
|
||||
|
||||
// Create the table
|
||||
$tbname = "bigint_table";
|
||||
createTable($conn, $tbname, array("c1_bigint" => "bigint"));
|
||||
|
||||
// Create a Stored Procedure
|
||||
$spname = "selectBigint";
|
||||
$spSql = "CREATE PROCEDURE $spname (@c1_bigint bigint OUTPUT) AS
|
||||
SELECT @c1_bigint = c1_bigint FROM $tbname";
|
||||
$conn->query($spSql);
|
||||
|
||||
// Insert a large bigint
|
||||
insertRow($conn, $tbname, array("c1_bigint" => 922337203685479936));
|
||||
|
||||
// Call stored procedure with output
|
||||
$outSql = "{CALL $spname (?)}";
|
||||
$bigintOut = 0;
|
||||
$stmt = $conn->prepare($outSql);
|
||||
$stmt->bindParam(1, $bigintOut, PDO::PARAM_INT, PDO::SQLSRV_PARAM_OUT_DEFAULT_SIZE);
|
||||
$stmt->execute();
|
||||
printf("Large bigint output:\n" );
|
||||
var_dump($bigintOut);
|
||||
printf("\n");
|
||||
|
||||
// Call stored procedure with inout
|
||||
$bigintOut = 0;
|
||||
$stmt = $conn->prepare($outSql);
|
||||
$stmt->bindParam(1, $bigintOut, PDO::PARAM_INT | PDO::PARAM_INPUT_OUTPUT, PDO::SQLSRV_PARAM_OUT_DEFAULT_SIZE);
|
||||
$stmt->execute();
|
||||
printf("Large bigint inout:\n" );
|
||||
var_dump($bigintOut);
|
||||
printf("\n");
|
||||
|
||||
$conn->exec("TRUNCATE TABLE $tbname");
|
||||
|
||||
// Insert a random small value truncated from the bigint input
|
||||
insertRow($conn, $tbname, array("c1_bigint" => 922337203));
|
||||
|
||||
// Call stored procedure with output
|
||||
$bigintOut = 0;
|
||||
$stmt = $conn->prepare($outSql);
|
||||
$stmt->bindParam(1, $bigintOut, PDO::PARAM_INT, PDO::SQLSRV_PARAM_OUT_DEFAULT_SIZE);
|
||||
$stmt->execute();
|
||||
printf("Small bigint output:\n" );
|
||||
var_dump($bigintOut);
|
||||
printf("\n");
|
||||
|
||||
// Call stored procedure with inout
|
||||
$bigintOut = 0;
|
||||
$stmt = $conn->prepare($outSql);
|
||||
$stmt->bindParam(1, $bigintOut, PDO::PARAM_INT | PDO::PARAM_INPUT_OUTPUT, PDO::SQLSRV_PARAM_OUT_DEFAULT_SIZE);
|
||||
$stmt->execute();
|
||||
printf("Small bigint inout:\n" );
|
||||
var_dump($bigintOut);
|
||||
printf("\n");
|
||||
|
||||
dropProc($conn, $spname);
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
?>
|
||||
--EXPECT--
|
||||
Large bigint output:
|
||||
string(18) "922337203685479936"
|
||||
|
||||
Large bigint inout:
|
||||
string(18) "922337203685479936"
|
||||
|
||||
Small bigint output:
|
||||
int(922337203)
|
||||
|
||||
Small bigint inout:
|
||||
int(922337203)
|
||||
|
|
@ -1,48 +1,41 @@
|
|||
--TEST--
|
||||
bind inout param with PDO::SQLSRV_ENCODING_BINARY
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require('MsSetup.inc');
|
||||
$pdo = new PDO("sqlsrv:Server=$server ; Database = $databaseName ", $uid, $pwd);
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$sql = "DROP TABLE my_table";
|
||||
$stmt = $pdo->query($sql);
|
||||
$stmt = null;
|
||||
try {
|
||||
$pdo = connect();
|
||||
|
||||
$sql = "CREATE TABLE my_table (value varchar(20), name varchar(20))";
|
||||
$stmt = $pdo->query($sql);
|
||||
$stmt = null;
|
||||
$tbname = "my_table";
|
||||
createTable($pdo, $tbname, array("value" => "varchar(20)", "name" => "varchar(20)"));
|
||||
insertRow($pdo, $tbname, array( "value" => "Initial string", "name" => "name" ));
|
||||
|
||||
$sql = "INSERT INTO my_table (value, name) VALUES ('Initial string', 'name')";
|
||||
$stmt = $pdo->query($sql);
|
||||
$stmt = null;
|
||||
$value = 'Some string value.';
|
||||
$name = 'name';
|
||||
|
||||
$value = 'Some string value.';
|
||||
$name = 'name';
|
||||
$sql = "UPDATE my_table SET value = :value WHERE name = :name";
|
||||
$stmt = $pdo->prepare($sql);
|
||||
$stmt->bindParam(':value', $value, PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
|
||||
$stmt->bindParam(':name', $name);
|
||||
$stmt->execute();
|
||||
|
||||
$sql = "UPDATE my_table SET value = :value WHERE name = :name";
|
||||
$result = selectRow($pdo, $tbname, "PDO::FETCH_ASSOC");
|
||||
print_r($result);
|
||||
|
||||
$stmt = $pdo->prepare($sql);
|
||||
|
||||
$stmt->bindParam(':value', $value, PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
|
||||
$stmt->bindParam(':name', $name);
|
||||
|
||||
$stmt->execute();
|
||||
$stmt = null;
|
||||
|
||||
$sql = "SELECT * FROM my_table";
|
||||
$stmt = $pdo->query($sql);
|
||||
$result = $stmt->fetch(PDO::FETCH_ASSOC);
|
||||
print_r($result);
|
||||
|
||||
$stmt->closeCursor();
|
||||
$pdo = null;
|
||||
$stmt->closeCursor();
|
||||
dropTable($pdo, $tbname);
|
||||
unset($stmt);
|
||||
unset($pdo);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
Array
|
||||
(
|
||||
[value] => Some string value.
|
||||
[name] => name
|
||||
)
|
||||
)
|
||||
|
|
|
|||
82
test/functional/pdo_sqlsrv/pdo_bool_outparam.phpt
Normal file
82
test/functional/pdo_sqlsrv/pdo_bool_outparam.phpt
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
--TEST--
|
||||
Test for binding boolean output and inout parameters
|
||||
--SKIPIF--
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$conn = connect();
|
||||
|
||||
// Create the table
|
||||
$tbname = "bool_table";
|
||||
createTable($conn, $tbname, array("c1_bool" => "int"));
|
||||
|
||||
// Create a Stored Procedure
|
||||
$spname = "selectBool";
|
||||
$spSql = "CREATE PROCEDURE $spname (@c1_bool int OUTPUT) AS
|
||||
SELECT @c1_bool = c1_bool FROM $tbname";
|
||||
$conn->query($spSql);
|
||||
|
||||
// Insert 1
|
||||
insertRow($conn, $tbname, array("c1_bool" => 1));
|
||||
|
||||
// Call stored procedure with output
|
||||
$outSql = "{CALL $spname (?)}";
|
||||
$boolOut = false;
|
||||
$stmt = $conn->prepare($outSql);
|
||||
$stmt->bindParam(1, $boolOut, PDO::PARAM_INT, PDO::SQLSRV_PARAM_OUT_DEFAULT_SIZE);
|
||||
$stmt->execute();
|
||||
printf("True bool output:\n" );
|
||||
var_dump($boolOut);
|
||||
printf("\n");
|
||||
|
||||
// Call stored procedure with inout
|
||||
$boolOut = false;
|
||||
$stmt = $conn->prepare($outSql);
|
||||
$stmt->bindParam(1, $boolOut, PDO::PARAM_INT | PDO::PARAM_INPUT_OUTPUT, PDO::SQLSRV_PARAM_OUT_DEFAULT_SIZE);
|
||||
$stmt->execute();
|
||||
printf("True bool inout:\n" );
|
||||
var_dump($boolOut);
|
||||
printf("\n");
|
||||
|
||||
$conn->exec("TRUNCATE TABLE $tbname");
|
||||
|
||||
// Insert 0
|
||||
insertRow($conn, $tbname, array("c1_bool" => 0));
|
||||
|
||||
// Call stored procedure with output
|
||||
$boolOut = true;
|
||||
$stmt = $conn->prepare($outSql);
|
||||
$stmt->bindParam(1, $boolOut, PDO::PARAM_INT, PDO::SQLSRV_PARAM_OUT_DEFAULT_SIZE);
|
||||
$stmt->execute();
|
||||
printf("True bool output:\n" );
|
||||
var_dump($boolOut);
|
||||
printf("\n");
|
||||
|
||||
// Call stored procedure with inout
|
||||
$boolOut = true;
|
||||
$stmt = $conn->prepare($outSql);
|
||||
$stmt->bindParam(1, $boolOut, PDO::PARAM_INT | PDO::PARAM_INPUT_OUTPUT, PDO::SQLSRV_PARAM_OUT_DEFAULT_SIZE);
|
||||
$stmt->execute();
|
||||
printf("True bool inout:\n" );
|
||||
var_dump($boolOut);
|
||||
printf("\n");
|
||||
|
||||
dropProc($conn, $spname);
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
?>
|
||||
--EXPECT--
|
||||
True bool output:
|
||||
int(1)
|
||||
|
||||
True bool inout:
|
||||
int(1)
|
||||
|
||||
True bool output:
|
||||
int(0)
|
||||
|
||||
True bool inout:
|
||||
int(0)
|
||||
158
test/functional/pdo_sqlsrv/pdo_connect_driver.phpt
Normal file
158
test/functional/pdo_sqlsrv/pdo_connect_driver.phpt
Normal file
|
|
@ -0,0 +1,158 @@
|
|||
--TEST--
|
||||
Test new connection keyword Driver with valid and invalid values
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once('MsSetup.inc');
|
||||
|
||||
try {
|
||||
$conn = new PDO("sqlsrv:server = $server", $uid, $pwd);
|
||||
$msodbcsqlVer = $conn->getAttribute(PDO::ATTR_CLIENT_VERSION)['DriverVer'];
|
||||
$msodbcsqlMaj = explode(".", $msodbcsqlVer)[0];
|
||||
} catch(PDOException $e) {
|
||||
echo "Failed to connect\n";
|
||||
print_r($e->getMessage());
|
||||
echo "\n";
|
||||
}
|
||||
|
||||
$conn = null;
|
||||
|
||||
// start test
|
||||
testValidValues();
|
||||
testInvalidValues();
|
||||
testEncryptedWithODBC();
|
||||
testWrongODBC();
|
||||
echo "Done";
|
||||
// end test
|
||||
|
||||
///////////////////////////
|
||||
function connectVerifyOutput($connectionOptions, $expected = '')
|
||||
{
|
||||
global $server, $uid, $pwd;
|
||||
|
||||
try {
|
||||
$conn = new PDO("sqlsrv:server = $server ; $connectionOptions", $uid, $pwd);
|
||||
} catch(PDOException $e) {
|
||||
if (strpos($e->getMessage(), $expected) === false) {
|
||||
print_r($e->getMessage());
|
||||
echo "\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function testValidValues()
|
||||
{
|
||||
global $msodbcsqlMaj;
|
||||
|
||||
$value = "";
|
||||
// The major version number of ODBC 11 can be 11 or 12
|
||||
// Test with {}
|
||||
switch ($msodbcsqlMaj) {
|
||||
case 17:
|
||||
$value = "{ODBC Driver 17 for SQL Server}";
|
||||
break;
|
||||
case 13:
|
||||
$value = "{ODBC Driver 13 for SQL Server}";
|
||||
break;
|
||||
case 12:
|
||||
case 11:
|
||||
$value = "{ODBC Driver 11 for SQL Server}";
|
||||
break;
|
||||
default:
|
||||
$value = "invalid value";
|
||||
}
|
||||
$connectionOptions = "Driver = $value";
|
||||
connectVerifyOutput($connectionOptions);
|
||||
|
||||
// Test without {}
|
||||
switch ($msodbcsqlMaj) {
|
||||
case 17:
|
||||
$value = "ODBC Driver 17 for SQL Server";
|
||||
break;
|
||||
case 13:
|
||||
$value = "ODBC Driver 13 for SQL Server";
|
||||
break;
|
||||
case 12:
|
||||
case 11:
|
||||
$value = "ODBC Driver 11 for SQL Server";
|
||||
break;
|
||||
default:
|
||||
$value = "invalid value";
|
||||
}
|
||||
|
||||
$connectionOptions = "Driver = $value";
|
||||
connectVerifyOutput($connectionOptions);
|
||||
}
|
||||
|
||||
function testInvalidValues()
|
||||
{
|
||||
$values = array("{SQL Server Native Client 11.0}",
|
||||
"SQL Server Native Client 11.0",
|
||||
"ODBC Driver 00 for SQL Server",
|
||||
123,
|
||||
false);
|
||||
|
||||
foreach ($values as $value) {
|
||||
$connectionOptions = "Driver = $value";
|
||||
$expected = "Invalid value $value was specified for Driver option.";
|
||||
connectVerifyOutput($connectionOptions, $expected);
|
||||
}
|
||||
}
|
||||
|
||||
function testEncryptedWithODBC()
|
||||
{
|
||||
global $msodbcsqlMaj, $server, $uid, $pwd;
|
||||
|
||||
$value = "ODBC Driver 13 for SQL Server";
|
||||
$connectionOptions = "Driver = $value; ColumnEncryption = Enabled;";
|
||||
$expected = "The Always Encrypted feature requires Microsoft ODBC Driver 17 for SQL Server.";
|
||||
|
||||
connectVerifyOutput($connectionOptions, $expected);
|
||||
|
||||
// TODO: the following block will change once ODBC 17 is officially released
|
||||
$value = "ODBC Driver 17 for SQL Server";
|
||||
$connectionOptions = "Driver = $value; ColumnEncryption = Enabled;";
|
||||
|
||||
$success = "Successfully connected with column encryption.";
|
||||
$expected = "The specified ODBC Driver is not found.";
|
||||
$message = $success;
|
||||
try {
|
||||
$conn = new PDO("sqlsrv:server = $server ; $connectionOptions", $uid, $pwd);
|
||||
} catch(PDOException $e) {
|
||||
$message = $e->getMessage();
|
||||
}
|
||||
|
||||
if ($msodbcsqlMaj == 17) {
|
||||
// this indicates that OCBC 17 is the only available driver
|
||||
if (strcmp($message, $success)) {
|
||||
print_r($message);
|
||||
}
|
||||
} else {
|
||||
// OCBC 17 might or might not exist
|
||||
if (strcmp($message, $success)) {
|
||||
if (strpos($message, $expected) === false) {
|
||||
print_r($message);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function testWrongODBC()
|
||||
{
|
||||
global $msodbcsqlMaj;
|
||||
|
||||
// TODO: this will change once ODBC 17 is officially released
|
||||
$value = "ODBC Driver 17 for SQL Server";
|
||||
if ($msodbcsqlMaj == 17 || $msodbcsqlMaj < 13) {
|
||||
$value = "ODBC Driver 13 for SQL Server";
|
||||
}
|
||||
$connectionOptions = "Driver = $value;";
|
||||
$expected = "The specified ODBC Driver is not found.";
|
||||
|
||||
connectVerifyOutput($connectionOptions, $expected);
|
||||
}
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
Done
|
||||
|
|
@ -1,75 +1,49 @@
|
|||
--TEST--
|
||||
testing the quote method with different inputs and then test with a empty query
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
include 'MsCommon.inc';
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
try {
|
||||
$conn = connect("", array(), PDO::ERRMODE_SILENT);
|
||||
|
||||
function Quote()
|
||||
{
|
||||
require("MsSetup.inc");
|
||||
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
|
||||
$output1 = $conn->quote("1'2'3'4'5'6'7'8", PDO::PARAM_INT);
|
||||
var_dump($output1);
|
||||
|
||||
|
||||
$output2 = $conn->quote("{ABCD}'{EFGH}", PDO::PARAM_STR);
|
||||
var_dump($output2);
|
||||
|
||||
$output3 = $conn->quote("<XmlTestData><Letters>The quick brown fox jumps over the lazy dog</Letters><Digits>0123456789</Digits></XmlTestData>");
|
||||
var_dump($output3);
|
||||
|
||||
$output3 = $conn->quote("<XmlTestData><Letters>The quick brown fox jumps over the lazy dog</Letters><Digits>0123456789</Digits></XmlTestData>");
|
||||
var_dump($output3);
|
||||
|
||||
$stmt = $conn->query("");
|
||||
if ($stmt != false)
|
||||
{
|
||||
if ($stmt != false) {
|
||||
echo("Empty query was expected to fail!\n");
|
||||
}
|
||||
|
||||
}
|
||||
unset($stmt);
|
||||
|
||||
$stmt1 = $conn->prepare($output2);
|
||||
$result = $stmt1->execute();
|
||||
if ($result != false)
|
||||
{
|
||||
if ($result != false) {
|
||||
echo("This query was expected to fail!\n");
|
||||
}
|
||||
$stmt1 = null;
|
||||
|
||||
unset($stmt1);
|
||||
|
||||
$stmt2 = $conn->query($output3);
|
||||
if ($stmt2 != false)
|
||||
{
|
||||
if ($stmt2 != false) {
|
||||
echo("This query was expected to fail!\n");
|
||||
}
|
||||
|
||||
$conn = null;
|
||||
}
|
||||
|
||||
function Repro()
|
||||
{
|
||||
StartTest("pdo_connection_quote");
|
||||
echo "\nStarting test...\n";
|
||||
try
|
||||
{
|
||||
Quote();
|
||||
}
|
||||
catch (Exception $e)
|
||||
{
|
||||
echo $e->getMessage();
|
||||
}
|
||||
echo "\nDone\n";
|
||||
EndTest("pdo_connection_quote");
|
||||
unset($stmt2);
|
||||
|
||||
unset($conn);
|
||||
} catch (Exception $e) {
|
||||
echo $e->getMessage();
|
||||
}
|
||||
|
||||
Repro();
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
|
||||
Starting test...
|
||||
string(24) "'1''2''3''4''5''6''7''8'"
|
||||
string(16) "'{ABCD}''{EFGH}'"
|
||||
string(118) "'<XmlTestData><Letters>The quick brown fox jumps over the lazy dog</Letters><Digits>0123456789</Digits></XmlTestData>'"
|
||||
|
||||
Done
|
||||
Test "pdo_connection_quote" completed successfully.
|
||||
|
|
|
|||
|
|
@ -7,7 +7,8 @@ killing the connection and then not freeing it. The latter case is the only one
|
|||
that should fail. Finally, execute two queries in two threads on a recovered
|
||||
non-MARS connection. This should fail too.
|
||||
--SKIPIF--
|
||||
<?php require('skipif_protocol_not_tcp.inc'); ?>
|
||||
<?php require('skipif_protocol_not_tcp.inc');
|
||||
require('skipif_version_less_than_2k14.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
// There is a lot of repeated code here that could be refactored with helper methods,
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
--TEST--
|
||||
Test the connection resiliency keywords ConnectRetryCount and ConnectRetryInterval and their ranges of acceptable values
|
||||
--SKIPIF--
|
||||
<?php require('skipif_unix.inc'); ?>
|
||||
<?php require('skipif_unix.inc');
|
||||
require('skipif_version_less_than_2k14.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once( "MsSetup.inc" );
|
||||
|
|
|
|||
|
|
@ -5,7 +5,8 @@ Prepare a statement, break the connection, and execute the statement. Then
|
|||
test transactions by breaking the connection before beginning a transaction
|
||||
and in the middle of the transaction. The latter case should fail.
|
||||
--SKIPIF--
|
||||
<?php require('skipif_protocol_not_tcp.inc'); ?>
|
||||
<?php require('skipif_protocol_not_tcp.inc');
|
||||
require('skipif_version_less_than_2k14.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once( "break_pdo.php" );
|
||||
|
|
|
|||
|
|
@ -4,7 +4,8 @@ Test connection resiliency timeouts
|
|||
1. Connect with ConnectRetryCount equal to 0.
|
||||
2. Reconnect with the default value of ConnectRetryCount(1).
|
||||
--SKIPIF--
|
||||
<?php require('skipif_protocol_not_tcp.inc'); ?>
|
||||
<?php require('skipif_protocol_not_tcp.inc');
|
||||
require('skipif_version_less_than_2k14.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once( "break_pdo.php" );
|
||||
|
|
|
|||
|
|
@ -1,34 +1,28 @@
|
|||
--TEST--
|
||||
Test PDO::__Construct by passing connection options and 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
|
||||
{
|
||||
$attr = array(
|
||||
PDO::SQLSRV_ATTR_ENCODING => 3,
|
||||
PDO::ATTR_CASE => 2,
|
||||
PDO::ATTR_PREFETCH => false,
|
||||
PDO::ATTR_TIMEOUT => 35,
|
||||
PDO::ATTR_ERRMODE => 2,
|
||||
PDO::ATTR_STRINGIFY_FETCHES => true,
|
||||
PDO::SQLSRV_ATTR_DIRECT_QUERY => true,
|
||||
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
|
||||
PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
|
||||
PDO::SQLSRV_ATTR_CLIENT_BUFFER_MAX_KB_SIZE => 5120,
|
||||
PDO::SQLSRV_ATTR_DIRECT_QUERY => true
|
||||
);
|
||||
|
||||
$dsn = "sqlsrv:Server = $server;" .
|
||||
"ConnectionPooling = false;" .
|
||||
try {
|
||||
$attr = array( PDO::SQLSRV_ATTR_ENCODING => 3,
|
||||
PDO::ATTR_CASE => 2,
|
||||
PDO::ATTR_PREFETCH => false,
|
||||
PDO::ATTR_TIMEOUT => 35,
|
||||
PDO::ATTR_ERRMODE => 2,
|
||||
PDO::ATTR_STRINGIFY_FETCHES => true,
|
||||
PDO::SQLSRV_ATTR_DIRECT_QUERY => true,
|
||||
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
|
||||
PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
|
||||
PDO::SQLSRV_ATTR_CLIENT_BUFFER_MAX_KB_SIZE => 5120,
|
||||
PDO::SQLSRV_ATTR_DIRECT_QUERY => true );
|
||||
|
||||
$dsn = "ConnectionPooling = false;" .
|
||||
"APP = whatever;" .
|
||||
"LoginTimeout = 1;" .
|
||||
"ApplicationIntent = ReadOnly;" .
|
||||
"Database = $databaseName;" .
|
||||
"Encrypt = false;" .
|
||||
"Failover_Partner = whatever;" .
|
||||
"MultipleActiveResultSets = true;" .
|
||||
|
|
@ -38,18 +32,13 @@ try
|
|||
"TraceOn = true;" .
|
||||
"TransactionIsolation = " . PDO::SQLSRV_TXN_READ_UNCOMMITTED . ";" .
|
||||
"TrustServerCertificate = false;" .
|
||||
"WSID = whatever;"
|
||||
;
|
||||
$conn = new PDO( $dsn, $uid, $pwd, $attr);
|
||||
|
||||
echo "Test Successful";
|
||||
}
|
||||
catch( PDOException $e ) {
|
||||
var_dump( $e );
|
||||
"WSID = whatever;";
|
||||
$conn = connect($dsn, $attr);
|
||||
echo "Test Successful\n";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e);
|
||||
exit;
|
||||
}
|
||||
?>
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
|
||||
Test Successful
|
||||
|
|
|
|||
|
|
@ -1,38 +1,32 @@
|
|||
--TEST--
|
||||
Test PDO::__Construct connection option TransactionIsolation
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
function Connect($value) {
|
||||
require("MsSetup.inc");
|
||||
$dsn = "sqlsrv:Server = $server;" .
|
||||
"database = $databaseName;" .
|
||||
"TransactionIsolation = $value";
|
||||
$conn = new PDO( $dsn, $uid, $pwd );
|
||||
$conn = NULL;
|
||||
echo "Test Successful\n";
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
function connectTransaction($value)
|
||||
{
|
||||
$conn = connect("TransactionIsolation = $value");
|
||||
if (is_object($conn) && get_class($conn) == "PDO") {
|
||||
echo "Test Successful\n";
|
||||
}
|
||||
unset($conn);
|
||||
}
|
||||
|
||||
// TEST BEGIN
|
||||
try {
|
||||
Connect("READ_UNCOMMITTED");
|
||||
Connect("READ_COMMITTED");
|
||||
Connect("REPEATABLE_READ");
|
||||
Connect("SNAPSHOT");
|
||||
Connect("SERIALIZABLE");
|
||||
Connect("INVALID_KEY");
|
||||
|
||||
echo "Test Successful";
|
||||
connectTransaction("READ_UNCOMMITTED");
|
||||
connectTransaction("READ_COMMITTED");
|
||||
connectTransaction("REPEATABLE_READ");
|
||||
connectTransaction("SNAPSHOT");
|
||||
connectTransaction("SERIALIZABLE");
|
||||
connectTransaction("INVALID_KEY");
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
catch( PDOException $e ) {
|
||||
var_dump( $e->errorInfo );
|
||||
exit;
|
||||
}
|
||||
?>
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
|
||||
Test Successful
|
||||
Test Successful
|
||||
Test Successful
|
||||
|
|
@ -45,4 +39,4 @@ array(3) {
|
|||
int(-63)
|
||||
[2]=>
|
||||
string(88) "An invalid value was specified for the keyword 'TransactionIsolation' in the DSN string."
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,52 +1,43 @@
|
|||
--TEST--
|
||||
Test PDO::__Construct by passing different 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
|
||||
{
|
||||
$attr = array( PDO::SQLSRV_ATTR_ENCODING => 3,
|
||||
try {
|
||||
$attr = array( PDO::SQLSRV_ATTR_ENCODING => 3,
|
||||
PDO::ATTR_CASE => 2,
|
||||
PDO::ATTR_PREFETCH => false,
|
||||
PDO::ATTR_TIMEOUT => 35,
|
||||
PDO::ATTR_TIMEOUT => 35,
|
||||
PDO::ATTR_STRINGIFY_FETCHES => true,
|
||||
PDO::SQLSRV_ATTR_DIRECT_QUERY => true,
|
||||
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
|
||||
PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
|
||||
PDO::SQLSRV_ATTR_CLIENT_BUFFER_MAX_KB_SIZE => 10240,
|
||||
PDO::SQLSRV_ATTR_DIRECT_QUERY => true
|
||||
);
|
||||
|
||||
$dsn = "sqlsrv:Server = $server; database = $databaseName";
|
||||
|
||||
$conn = new PDO( $dsn, $uid, $pwd, $attr);
|
||||
|
||||
PDO::SQLSRV_ATTR_DIRECT_QUERY => true );
|
||||
|
||||
$conn = connect("", $attr);
|
||||
|
||||
$stmt = $conn->prepare("SELECT 1");
|
||||
$stmt->execute();
|
||||
|
||||
// fetch result, which should be stringified since ATTR_STRINGIFY_FETCHES is on
|
||||
var_dump(($stmt->fetch(PDO::FETCH_ASSOC)));
|
||||
|
||||
$stmt = NULL;
|
||||
$conn = NULL;
|
||||
|
||||
|
||||
echo "Test Successful";
|
||||
}
|
||||
catch( PDOException $e ) {
|
||||
var_dump( $e );
|
||||
// fetch result, which should be stringified since ATTR_STRINGIFY_FETCHES is on
|
||||
var_dump($stmt->fetch(PDO::FETCH_ASSOC));
|
||||
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
|
||||
echo "Test Successful\n";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e);
|
||||
exit;
|
||||
}
|
||||
?>
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
|
||||
array(1) {
|
||||
[""]=>
|
||||
string(1) "1"
|
||||
}
|
||||
Test Successful
|
||||
Test Successful
|
||||
|
|
|
|||
|
|
@ -1,20 +1,16 @@
|
|||
--TEST--
|
||||
Test PDO::__Construct by passing connection options
|
||||
--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;" .
|
||||
"ConnectionPooling = false;" .
|
||||
try {
|
||||
$dsn = "ConnectionPooling = false;" .
|
||||
"APP = whatever;" .
|
||||
"LoginTimeout = 1;" .
|
||||
"ApplicationIntent = ReadOnly;" .
|
||||
"database = $databaseName;" .
|
||||
"Encrypt = false;" .
|
||||
"Failover_Partner = whatever;" .
|
||||
"MultipleActiveResultSets = true;" .
|
||||
|
|
@ -23,18 +19,14 @@ try
|
|||
"TraceFile = whatever;" .
|
||||
"TraceOn = true;" .
|
||||
"TrustServerCertificate = false;" .
|
||||
"WSID = whatever;"
|
||||
;
|
||||
$conn = new PDO( $dsn, $uid, $pwd);
|
||||
|
||||
echo "Test Successful";
|
||||
}
|
||||
catch( PDOException $e ) {
|
||||
var_dump( $e );
|
||||
"WSID = whatever;";
|
||||
$conn = connect($dsn);
|
||||
unset($conn);
|
||||
echo "Test Successful\n";
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e);
|
||||
exit;
|
||||
}
|
||||
?>
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
|
||||
Test Successful
|
||||
Test Successful
|
||||
|
|
|
|||
100
test/functional/pdo_sqlsrv/pdo_empty_result_error.phpt
Normal file
100
test/functional/pdo_sqlsrv/pdo_empty_result_error.phpt
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
--TEST--
|
||||
Error messages from null result sets
|
||||
--DESCRIPTION--
|
||||
Test that calling nextRowset() on an empty result set produces the correct error message. Fix for Github 507.
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon.inc");
|
||||
|
||||
$conn = new PDO( "sqlsrv:Server = $server; Database = $databaseName; ", $uid, $pwd );
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
|
||||
DropTable($conn, 'TestEmptySetTable');
|
||||
$stmt = $conn->query("CREATE TABLE TestEmptySetTable ([c1] nvarchar(10),[c2] nvarchar(10))");
|
||||
$stmt = $conn->query("INSERT INTO TestEmptySetTable (c1, c2) VALUES ('a', 'b')");
|
||||
|
||||
// Create a procedure that can return a result set or can return nothing
|
||||
DropProc($conn, 'TestEmptySetProc');
|
||||
$stmt = $conn->query("CREATE PROCEDURE TestEmptySetProc @a nvarchar(10), @b nvarchar(10)
|
||||
AS SET NOCOUNT ON
|
||||
BEGIN
|
||||
IF @b='b'
|
||||
BEGIN
|
||||
SELECT 'a' as testValue
|
||||
END
|
||||
ELSE
|
||||
BEGIN
|
||||
UPDATE TestEmptySetTable SET c2 = 'c' WHERE c1 = @a
|
||||
END
|
||||
END");
|
||||
|
||||
// errors out when reaching the second nextRowset() call
|
||||
// returned error indicates there are no more results
|
||||
echo "Return a nonempty result set:\n";
|
||||
try
|
||||
{
|
||||
$stmt = $conn->query("TestEmptySetProc @a='a', @b='b'");
|
||||
$result = $stmt->fetchAll();
|
||||
print_r($result);
|
||||
$stmt->nextRowset();
|
||||
$result = $stmt->fetchAll();
|
||||
print_r($result);
|
||||
$stmt->nextRowset();
|
||||
}
|
||||
catch(Exception $e)
|
||||
{
|
||||
echo $e->getMessage()."\n";
|
||||
}
|
||||
|
||||
// errors out indicating the result set contains no fields
|
||||
echo "Return an empty result set, call nextRowset on it before fetching anything:\n";
|
||||
try
|
||||
{
|
||||
$stmt = $conn->query("TestEmptySetProc @a='a', @b='c'");
|
||||
$stmt->nextRowset();
|
||||
}
|
||||
catch(Exception $e)
|
||||
{
|
||||
echo $e->getMessage()."\n";
|
||||
}
|
||||
|
||||
// errors out indicating the result set contains no fields
|
||||
echo "Return an empty result set, call fetch on it:\n";
|
||||
try
|
||||
{
|
||||
$stmt = $conn->query("TestEmptySetProc @a='a', @b='c'");
|
||||
$result = $stmt->fetchAll();
|
||||
print_r($result);
|
||||
}
|
||||
catch(Exception $e)
|
||||
{
|
||||
echo $e->getMessage()."\n";
|
||||
}
|
||||
|
||||
$stmt = $conn->query("DROP TABLE TestEmptySetTable");
|
||||
$stmt = $conn->query("DROP PROCEDURE TestEmptySetProc");
|
||||
|
||||
$conn = null;
|
||||
?>
|
||||
--EXPECT--
|
||||
Return a nonempty result set:
|
||||
Array
|
||||
(
|
||||
[0] => Array
|
||||
(
|
||||
[testValue] => a
|
||||
[0] => a
|
||||
)
|
||||
|
||||
)
|
||||
Array
|
||||
(
|
||||
)
|
||||
SQLSTATE[IMSSP]: There are no more results returned by the query.
|
||||
Return an empty result set, call nextRowset on it before fetching anything:
|
||||
SQLSTATE[IMSSP]: The active result for the query contains no fields.
|
||||
Return an empty result set, call fetch on it:
|
||||
SQLSTATE[IMSSP]: The active result for the query contains no fields.
|
||||
|
|
@ -1,39 +1,36 @@
|
|||
--TEST--
|
||||
Test different error modes. The queries will try to do a select on a table that does not exist on database.
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
require_once 'MsCommon.inc';
|
||||
|
||||
|
||||
function testException(){
|
||||
function testException()
|
||||
{
|
||||
$db = connect();
|
||||
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
|
||||
$sql = "SELECT * FROM temp_table";
|
||||
try{
|
||||
try {
|
||||
$q = $db->query($sql);
|
||||
} catch ( Exception $e ){
|
||||
} catch (Exception $e) {
|
||||
echo 'Caught exception: ', $e->getMessage();
|
||||
}
|
||||
}
|
||||
|
||||
function testWarning(){
|
||||
$db = connect();
|
||||
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
|
||||
function testWarning()
|
||||
{
|
||||
$db = connect("", array(), PDO::ERRMODE_WARNING);
|
||||
$sql = "SELECT * FROM temp_table";
|
||||
$q = $db->query($sql);
|
||||
}
|
||||
|
||||
function testSilent(){
|
||||
$db = connect();
|
||||
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
|
||||
function testSilent()
|
||||
{
|
||||
$db = connect("", array(), PDO::ERRMODE_SILENT);
|
||||
$sql = "SELECT * FROM temp_table";
|
||||
$q = $db->query($sql);
|
||||
}
|
||||
|
||||
|
||||
testException();
|
||||
testWarning();
|
||||
testSilent();
|
||||
|
|
|
|||
|
|
@ -1,108 +1,88 @@
|
|||
--TEST--
|
||||
Test errorInfo when prepare with and without emulate prepare
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
require_once 'MsSetup.inc';
|
||||
try {
|
||||
// connection with and without column encryption returns different warning since column encryption cannot use emulate prepare
|
||||
// turn ERRMODE to silent to compare the errorCode in the test
|
||||
$conn = connect("", array(), PDO::ERRMODE_SILENT);
|
||||
|
||||
$conn = new PDO("sqlsrv:server=$server;Database=$databaseName", $uid, $pwd, array(PDO::ATTR_ERRMODE => PDO::ERRMODE_WARNING));
|
||||
//drop, create and insert
|
||||
$tbname = "test_table";
|
||||
createTable($conn, $tbname, array("c1" => "int", "c2" => "int"));
|
||||
|
||||
//drop, create and insert
|
||||
$conn->query("IF OBJECT_ID('dbo.test_table', 'U') IS NOT NULL DROP TABLE dbo.test_table");
|
||||
$conn->query("CREATE TABLE [dbo].[test_table](c1 int, c2 int)");
|
||||
$conn->query("INSERT INTO [dbo].[test_table] VALUES (1, 10)");
|
||||
$conn->query("INSERT INTO [dbo].[test_table] VALUES (2, 20)");
|
||||
insertRow($conn, $tbname, array( "c1" => 1, "c2" => 10 ));
|
||||
insertRow($conn, $tbname, array( "c1" => 2, "c2" => 20 ));
|
||||
|
||||
echo "\n****testing with emulate prepare****\n";
|
||||
$stmt = $conn->prepare("SELECT c2 FROM test_table WHERE c1= :int", array(PDO::ATTR_EMULATE_PREPARES => true));
|
||||
echo "\n****testing with emulate prepare****\n";
|
||||
// Do not support emulate prepare with Always Encrypted
|
||||
if (!isColEncrypted()) {
|
||||
$stmt = $conn->prepare("SELECT c2 FROM $tbname WHERE c1= :int", array(PDO::ATTR_EMULATE_PREPARES => true));
|
||||
} else {
|
||||
$stmt = $conn->prepare("SELECT c2 FROM $tbname WHERE c1= :int");
|
||||
}
|
||||
|
||||
$int_col = 1;
|
||||
//bind param with the wrong parameter name to test for errorInfo
|
||||
$stmt->bindParam(':in', $int_col);
|
||||
$int_col = 1;
|
||||
//bind param with the wrong parameter name to test for errorInfo
|
||||
$stmt->bindParam(':in', $int_col);
|
||||
$stmt->execute();
|
||||
|
||||
$stmt->execute();
|
||||
$stmt_error = $stmt->errorInfo();
|
||||
if (!isColEncrypted()) {
|
||||
if ($stmt_error[0] != "HY093") {
|
||||
echo "SQLSTATE should be HY093 when Emulate Prepare is true.\n";
|
||||
print_r($stmt_error);
|
||||
}
|
||||
} else {
|
||||
if ($stmt_error[0] != "07002") {
|
||||
echo "SQLSTATE should be 07002 for syntax error in a parameterized query.\n";
|
||||
print_r($stmt_error);
|
||||
}
|
||||
}
|
||||
|
||||
echo "Statement error info:\n";
|
||||
print_r($stmt->errorInfo());
|
||||
$conn_error = $conn->errorInfo();
|
||||
if ($conn_error[0] != "00000") {
|
||||
echo "Connection error SQLSTATE should be 00000.\n";
|
||||
print_r($conn_error);
|
||||
}
|
||||
|
||||
if ($stmt->errorInfo()[1] == NULL && $stmt->errorInfo()[2] == NULL) {
|
||||
echo "stmt native code and native message are NULL.\n";
|
||||
echo "\n****testing without emulate prepare****\n";
|
||||
$stmt2 = $conn->prepare("SELECT c2 FROM $tbname WHERE c1= :int", array(PDO::ATTR_EMULATE_PREPARES => false));
|
||||
|
||||
$int_col = 2;
|
||||
//bind param with the wrong parameter name to test for errorInfo
|
||||
$stmt2->bindParam(':it', $int_col);
|
||||
$stmt2->execute();
|
||||
|
||||
$stmt_error = $stmt2->errorInfo();
|
||||
if ($stmt_error[0] != "07002") {
|
||||
echo "SQLSTATE should be 07002 for syntax error in a parameterized query.\n";
|
||||
print_r($stmt_error);
|
||||
}
|
||||
|
||||
$conn_error = $conn->errorInfo();
|
||||
if ($conn_error[0] != "00000") {
|
||||
echo "Connection error SQLSTATE should be 00000.\n";
|
||||
print_r($conn_error);
|
||||
}
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($stmt2);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
else {
|
||||
echo "stmt native code and native message should be NULL.\n";
|
||||
}
|
||||
|
||||
echo "Connection error info:\n";
|
||||
print_r($conn->errorInfo());
|
||||
|
||||
if ($conn->errorInfo()[1] == NULL && $conn->errorInfo()[2] == NULL) {
|
||||
echo "conn native code and native message are NULL.\n";
|
||||
}
|
||||
else {
|
||||
echo "conn native code and native message shoud be NULL.\n";
|
||||
}
|
||||
|
||||
echo "\n****testing without emulate prepare****\n";
|
||||
$stmt2 = $conn->prepare("SELECT c2 FROM test_table WHERE c1= :int", array(PDO::ATTR_EMULATE_PREPARES => false));
|
||||
|
||||
$int_col = 2;
|
||||
//bind param with the wrong parameter name to test for errorInfo
|
||||
$stmt2->bindParam(':it', $int_col);
|
||||
|
||||
$stmt2->execute();
|
||||
|
||||
echo "Statement error info:\n";
|
||||
print_r($stmt2->errorInfo());
|
||||
|
||||
echo "Connection error info:\n";
|
||||
print_r($conn->errorInfo());
|
||||
|
||||
$conn->query("IF OBJECT_ID('dbo.test_table', 'U') IS NOT NULL DROP TABLE dbo.test_table");
|
||||
$stmt = NULL;
|
||||
$stmt2 = NULL;
|
||||
$conn = NULL;
|
||||
?>
|
||||
--EXPECTREGEX--
|
||||
\*\*\*\*testing with emulate prepare\*\*\*\*
|
||||
|
||||
Warning: PDOStatement::execute\(\): SQLSTATE\[HY093\]: Invalid parameter number: parameter was not defined in .+(\/|\\)pdo_errorinfo_emulateprepare\.php on line [0-9]+
|
||||
|
||||
Warning: PDOStatement::execute\(\): SQLSTATE\[HY093\]: Invalid parameter number in .+(\/|\\)pdo_errorinfo_emulateprepare\.php on line [0-9]+
|
||||
Statement error info:
|
||||
Array
|
||||
\(
|
||||
\[0\] => HY093
|
||||
\[1\] =>
|
||||
\[2\] =>
|
||||
\)
|
||||
stmt native code and native message are NULL\.
|
||||
Connection error info:
|
||||
Array
|
||||
\(
|
||||
\[0\] => 00000
|
||||
\[1\] =>
|
||||
\[2\] =>
|
||||
\)
|
||||
conn native code and native message are NULL\.
|
||||
Warning: PDOStatement::(bindParam|execute)\(\): SQLSTATE\[HY093\]: Invalid parameter number: parameter was not defined in .+(\/|\\)pdo_errorinfo_emulateprepare\.php on line [0-9]+
|
||||
|
||||
\*\*\*\*testing without emulate prepare\*\*\*\*
|
||||
|
||||
Warning: PDOStatement::bindParam\(\): SQLSTATE\[HY093\]: Invalid parameter number: parameter was not defined in .+(\/|\\)pdo_errorinfo_emulateprepare\.php on line [0-9]+
|
||||
|
||||
Warning: PDOStatement::execute\(\): SQLSTATE\[07002\]: COUNT field incorrect: 0 \[Microsoft\]\[ODBC Driver 1[1-9] for SQL Server\]COUNT field incorrect or syntax error in .+(\/|\\)pdo_errorinfo_emulateprepare\.php on line [0-9]+
|
||||
Statement error info:
|
||||
Array
|
||||
\(
|
||||
\[0\] => 07002
|
||||
\[1\] => 0
|
||||
\[2\] => \[Microsoft\]\[ODBC Driver 1[1-9] for SQL Server\]COUNT field incorrect or syntax error
|
||||
\)
|
||||
Connection error info:
|
||||
Array
|
||||
\(
|
||||
\[0\] => 00000
|
||||
\[1\] =>
|
||||
\[2\] =>
|
||||
\)
|
||||
|
|
@ -1,47 +1,58 @@
|
|||
--TEST--
|
||||
Test the PDO::exec() method.
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once 'MsCommon.inc';
|
||||
|
||||
try
|
||||
{
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
try {
|
||||
$db = connect();
|
||||
|
||||
$sql = "CREATE TABLE #tmp_table(id INT NOT NULL PRIMARY KEY, val VARCHAR(10))";
|
||||
$numRows = $db->exec($sql);
|
||||
if($numRows === false)
|
||||
{
|
||||
die("Create table failed\n");
|
||||
|
||||
$tbname = "tmp_table";
|
||||
$numRows = createTable($db, $tbname, array( new ColumnMeta("int", "id", "NOT NULL PRIMARY KEY"), "val" => "varchar(10)"));
|
||||
var_dump($numRows);
|
||||
|
||||
if (!isColEncrypted()) {
|
||||
$sql = "INSERT INTO $tbname VALUES(1, 'A')";
|
||||
$numRows = $db->exec($sql);
|
||||
var_dump($numRows);
|
||||
|
||||
$sql = "INSERT INTO $tbname VALUES(2, 'B')";
|
||||
$numRows = $db->exec($sql);
|
||||
var_dump($numRows);
|
||||
|
||||
$numRows = $db->exec("UPDATE $tbname SET val = 'X' WHERE id > 0");
|
||||
var_dump($numRows);
|
||||
} else {
|
||||
// cannot use exec for insertion and update with Always Encrypted
|
||||
$stmt = insertRow($db, $tbname, array( "id" => 1, "val" => "A" ));
|
||||
$numRows = $stmt->rowCount();
|
||||
var_dump($numRows);
|
||||
|
||||
$stmt = insertRow($db, $tbname, array( "id" => 2, "val" => "B" ));
|
||||
$numRows = $stmt->rowCount();
|
||||
var_dump($numRows);
|
||||
|
||||
// greater or less than operator is not support for encrypted columns
|
||||
$sql = "UPDATE $tbname SET val = ?";
|
||||
$stmt = $db->prepare($sql);
|
||||
$stmt->execute(array( "X" ));
|
||||
$numRows = $stmt->rowCount();
|
||||
var_dump($numRows);
|
||||
}
|
||||
|
||||
$numRows = $db->exec("DELETE FROM $tbname");
|
||||
var_dump($numRows);
|
||||
|
||||
$sql = "INSERT INTO #tmp_table VALUES(1, 'A')";
|
||||
$numRows = $db->exec($sql);
|
||||
var_dump($numRows);
|
||||
|
||||
$sql = "INSERT INTO #tmp_table VALUES(2, 'B')";
|
||||
$numRows = $db->exec($sql);
|
||||
var_dump($numRows);
|
||||
|
||||
$numRows = $db->exec("UPDATE #tmp_table SET val = 'X' WHERE id > 0");
|
||||
var_dump($numRows);
|
||||
|
||||
$numRows = $db->exec("DELETE FROM #tmp_table");
|
||||
var_dump($numRows);
|
||||
|
||||
}
|
||||
|
||||
catch( PDOException $e ) {
|
||||
var_dump( $e );
|
||||
dropTable($db, $tbname);
|
||||
unset($stmt);
|
||||
unset($db);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e);
|
||||
exit;
|
||||
}
|
||||
|
||||
|
||||
?>
|
||||
?>
|
||||
--EXPECT--
|
||||
int(0)
|
||||
int(1)
|
||||
|
|
|
|||
|
|
@ -1,29 +1,31 @@
|
|||
--TEST--
|
||||
direct execution of an invalid query
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
// set ERRMODE to silent to return in errorCode in the test
|
||||
$conn = connect("", array(), PDO::ERRMODE_SILENT);
|
||||
|
||||
$tbname = "table1";
|
||||
dropTable($conn, $tbname);
|
||||
|
||||
$conn = new PDO( "sqlsrv:Server=$server; database = $databaseName ", $uid, $pwd);
|
||||
|
||||
$conn->exec("IF OBJECT_ID('table1', 'U') IS NOT NULL DROP TABLE table1");
|
||||
|
||||
// execute a query with typo (spelling error in CREATE)
|
||||
$conn->exec("CRETE TABLE table1(id INT NOT NULL PRIMARY KEY, val VARCHAR(10)) ");
|
||||
print_r( $conn->errorCode() );
|
||||
$conn->exec("CRETE TABLE $tbname (id INT NOT NULL PRIMARY KEY, val VARCHAR(10)) ");
|
||||
print_r($conn->errorCode());
|
||||
echo "\n";
|
||||
|
||||
|
||||
// execute a properly formatted query
|
||||
$conn->exec("CREATE TABLE table1(id INT NOT NULL PRIMARY KEY, val VARCHAR(10)) ");
|
||||
print_r( $conn->errorCode() );
|
||||
$conn->exec("CREATE TABLE $tbname (id INT NOT NULL PRIMARY KEY, val VARCHAR(10)) ");
|
||||
print_r($conn->errorCode());
|
||||
echo "\n";
|
||||
|
||||
|
||||
// drop table1 and free connections
|
||||
$conn->exec("DROP TABLE table1");
|
||||
$conn = NULL;
|
||||
dropTable($conn, $tbname);
|
||||
unset($conn);
|
||||
?>
|
||||
--EXPECT--
|
||||
42000
|
||||
00000
|
||||
00000
|
||||
|
|
|
|||
|
|
@ -1,98 +1,94 @@
|
|||
--TEST--
|
||||
Test transactions commit, rollback and aborting in between
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
include 'MsCommon.inc';
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
function ComplexTransaction($conn, $tableName)
|
||||
function complexTransaction($conn, $tableName)
|
||||
{
|
||||
$stmt = $conn->query("CREATE TABLE $tableName ([c1_int] int, [c2_real] real)");
|
||||
$stmt = null;
|
||||
createTable($conn, $tableName, array("c1_int" => "int", "c2_real" => "real"));
|
||||
|
||||
$stmtSelect = $conn->prepare("SELECT * FROM $tableName");
|
||||
$stmtDelete = $conn->prepare("DELETE TOP(3) FROM $tableName");
|
||||
|
||||
|
||||
// insert ten rows
|
||||
$numRows = 10;
|
||||
InsertData($conn, $tableName, $numRows);
|
||||
FetchData($stmtSelect, $tableName, $numRows);
|
||||
|
||||
insertData($conn, $tableName, $numRows);
|
||||
fetchData($stmtSelect, $tableName, $numRows);
|
||||
|
||||
$conn->beginTransaction();
|
||||
$stmtDelete->execute();
|
||||
$stmtDelete->execute();
|
||||
$rowsAffected = $stmtDelete->rowCount();
|
||||
$conn->commit();
|
||||
echo "Committed deleting 3 rows\n";
|
||||
|
||||
|
||||
$numRows = $numRows - $rowsAffected;
|
||||
FetchData($stmtSelect, $tableName, $numRows);
|
||||
|
||||
$conn->beginTransaction();
|
||||
$stmtDelete->execute();
|
||||
$conn->rollback();
|
||||
echo "Rolled back\n";
|
||||
|
||||
FetchData($stmtSelect, $tableName, $numRows);
|
||||
fetchData($stmtSelect, $tableName, $numRows);
|
||||
|
||||
$conn->beginTransaction();
|
||||
$stmtDelete->execute();
|
||||
$stmtDelete->execute();
|
||||
$conn->rollback();
|
||||
echo "Rolled back\n";
|
||||
|
||||
fetchData($stmtSelect, $tableName, $numRows);
|
||||
|
||||
$conn->beginTransaction();
|
||||
$stmtDelete->execute();
|
||||
$rowsAffected = $stmtDelete->rowCount();
|
||||
$conn->commit();
|
||||
echo "Committed deleting 3 rows\n";
|
||||
|
||||
|
||||
$numRows = $numRows - $rowsAffected;
|
||||
FetchData($stmtSelect, $tableName, $numRows);
|
||||
|
||||
fetchData($stmtSelect, $tableName, $numRows);
|
||||
|
||||
$conn->beginTransaction();
|
||||
$stmtDelete->execute();
|
||||
$stmtDelete->execute();
|
||||
$conn->rollback();
|
||||
echo "Rolled back\n";
|
||||
|
||||
FetchData($stmtSelect, $tableName, $numRows);
|
||||
|
||||
fetchData($stmtSelect, $tableName, $numRows);
|
||||
|
||||
$conn->beginTransaction();
|
||||
$stmtDelete->execute();
|
||||
$stmtDelete->execute();
|
||||
|
||||
echo "Deletion aborted\n";
|
||||
echo "Deletion aborted\n";
|
||||
|
||||
return $numRows;
|
||||
return $numRows;
|
||||
}
|
||||
|
||||
function InsertData($conn, $tableName, $count)
|
||||
function insertData($conn, $tableName, $count)
|
||||
{
|
||||
$stmt = $conn->prepare("INSERT INTO $tableName (c1_int, c2_real) VALUES (?, ?)");
|
||||
|
||||
for ($i = 0; $i < $count; $i++)
|
||||
{
|
||||
for ($i = 0; $i < $count; $i++) {
|
||||
$v1 = $i + 1;
|
||||
$v2 = $v1 * 1.5;
|
||||
|
||||
$stmt->bindValue(1, $v1);
|
||||
$stmt->bindValue(2, $v2);
|
||||
$stmt->execute();
|
||||
$stmt->execute();
|
||||
}
|
||||
}
|
||||
|
||||
function FetchData($stmt, $tableName, $numRows, $fetchMode = false)
|
||||
function fetchData($stmt, $tableName, $numRows, $fetchMode = false)
|
||||
{
|
||||
$numFetched = 0;
|
||||
$stmt->execute();
|
||||
if ($fetchMode)
|
||||
{
|
||||
$stmt->setFetchMode(PDO::FETCH_LAZY);
|
||||
while ($result = $stmt->fetch())
|
||||
$numFetched++;
|
||||
}
|
||||
else
|
||||
{
|
||||
while ($result = $stmt->fetch(PDO::FETCH_LAZY))
|
||||
$stmt->execute();
|
||||
if ($fetchMode) {
|
||||
$stmt->setFetchMode(PDO::FETCH_LAZY);
|
||||
while ($result = $stmt->fetch()) {
|
||||
$numFetched++;
|
||||
}
|
||||
} else {
|
||||
while ($result = $stmt->fetch(PDO::FETCH_LAZY)) {
|
||||
$numFetched++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
echo "Number of rows fetched: $numFetched\n";
|
||||
if ($numFetched != $numRows)
|
||||
{
|
||||
if ($numFetched != $numRows) {
|
||||
echo "Expected $numRows rows.\n";
|
||||
}
|
||||
}
|
||||
|
|
@ -101,50 +97,34 @@ function FetchData($stmt, $tableName, $numRows, $fetchMode = false)
|
|||
// RunTest
|
||||
//
|
||||
//--------------------------------------------------------------------
|
||||
function RunTest()
|
||||
{
|
||||
StartTest("pdo_fetch_complex_transactions");
|
||||
echo "\nTest begins...\n";
|
||||
try
|
||||
{
|
||||
include("MsSetup.inc");
|
||||
|
||||
// Connect
|
||||
$conn = new PDO( "sqlsrv:server=$server;database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
|
||||
$conn2 = new PDO( "sqlsrv:server=$server;database=$databaseName", $uid, $pwd);
|
||||
$conn2->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
|
||||
$tableName = GetTempTableName('testTransaction', false);
|
||||
echo "Test begins...\n";
|
||||
try {
|
||||
// Connect
|
||||
$conn = connect();
|
||||
$conn2 = connect();
|
||||
|
||||
// ComplexTransaction() returns number of rows left in $tableName
|
||||
$numRows = ComplexTransaction($conn, $tableName);
|
||||
// disconnect first connection, transaction aborted
|
||||
$conn = null;
|
||||
$tableName = getTableName('testTransaction');
|
||||
|
||||
// select table using the second connection
|
||||
$stmt = $conn2->prepare("SELECT * FROM $tableName");
|
||||
FetchData($stmt, $tableName, $numRows, true);
|
||||
// complexTransaction() returns number of rows left in $tableName
|
||||
$numRows = complexTransaction($conn, $tableName);
|
||||
// disconnect first connection, transaction aborted
|
||||
unset($conn);
|
||||
|
||||
// drop test table
|
||||
$conn2->query("DROP TABLE $tableName");
|
||||
$conn2 = null;
|
||||
}
|
||||
catch (Exception $e)
|
||||
{
|
||||
echo $e->getMessage();
|
||||
}
|
||||
echo "\nDone\n";
|
||||
EndTest("pdo_fetch_complex_transactions");
|
||||
// select table using the second connection
|
||||
$stmt = $conn2->prepare("SELECT * FROM $tableName");
|
||||
fetchData($stmt, $tableName, $numRows, true);
|
||||
|
||||
// drop test table
|
||||
dropTable($conn2, $tableName);
|
||||
unset($conn);
|
||||
} catch (Exception $e) {
|
||||
echo $e->getMessage();
|
||||
}
|
||||
|
||||
RunTest();
|
||||
|
||||
echo "Done\n";
|
||||
?>
|
||||
--EXPECT--
|
||||
|
||||
Test begins...
|
||||
Test begins...
|
||||
Number of rows fetched: 10
|
||||
Committed deleting 3 rows
|
||||
Number of rows fetched: 7
|
||||
|
|
@ -156,6 +136,4 @@ Rolled back
|
|||
Number of rows fetched: 4
|
||||
Deletion aborted
|
||||
Number of rows fetched: 4
|
||||
|
||||
Done
|
||||
Test "pdo_fetch_complex_transactions" completed successfully.
|
||||
|
|
@ -1,83 +1,88 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a varbinary column
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$sample = 'asdgasdgasdgsadg';
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist varbinary(max))';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindParam(':p0', $sample, PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
|
||||
$stmt->execute();
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = 'asdgasdgasdgsadg';
|
||||
|
||||
$query = 'SELECT TOP 1 * FROM #TESTTABLE';
|
||||
$tbname = "TESTTABLE";
|
||||
createTable($conn, $tbname, array("c1" => "varbinary(max)"));
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindParam(':p0', $sample, PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
|
||||
$stmt->execute();
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$query = "SELECT TOP 1 * FROM $tbname";
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -1,83 +1,88 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a varchar column
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$sample = "eight";
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist varchar(10))';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_STR);
|
||||
$stmt->execute();
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = "eight";
|
||||
|
||||
$query = 'SELECT TOP 1 * FROM #TESTTABLE';
|
||||
$tbname = "TESTTABLE";
|
||||
createTable($conn, $tbname, array("c1" => "varchar(10)"));
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_STR);
|
||||
$stmt->execute();
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$query = "SELECT TOP 1 * FROM $tbname";
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -1,83 +1,88 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a datetime column
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$sample = '2012-06-18 10:34:09';
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist datetime)';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindParam(':p0', $sample, PDO::PARAM_LOB);
|
||||
$stmt->execute();
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = '2012-06-18 10:34:09';
|
||||
|
||||
$query = 'SELECT TOP 1 * FROM #TESTTABLE';
|
||||
$tbname = "TESTTABLE";
|
||||
createTable($conn, $tbname, array("c1" => "datetime"));
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindParam(':p0', $sample, PDO::PARAM_LOB);
|
||||
$stmt->execute();
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$query = "SELECT TOP 1 * FROM $tbname";
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -1,83 +1,88 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a decimal column
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$sample = 1234567890.1234;
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist decimal(16, 6))';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = 1234567890.1234;
|
||||
|
||||
$query = 'SELECT TOP 1 * FROM #TESTTABLE';
|
||||
$tbname = "TESTTABLE";
|
||||
createTable($conn, $tbname, array("c1" => "decimal(16,6)"));
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$query = "SELECT TOP 1 * FROM $tbname";
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -1,91 +1,96 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a decimal column with the column bound and specified to pdo type int
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$sample = 1234567890.1234;
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist decimal(18, 8))';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = 1234567890.1234;
|
||||
|
||||
$query = 'SELECT exist FROM #TESTTABLE';
|
||||
$tbname = "TESTTABLE";
|
||||
createTable($conn, $tbname, array("c1" => "decimal(18,8)"));
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch( PDO::FETCH_BOUND );
|
||||
var_dump ($decimal_col);
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($decimal_col);
|
||||
$query = "SELECT c1 FROM $tbname";
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($decimal_col);
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($decimal_col);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($decimal_col);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($decimal_col);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($decimal_col);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($decimal_col);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($decimal_col);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($decimal_col);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($decimal_col);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($decimal_col);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($decimal_col);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($decimal_col);
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($decimal_col);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $decimal_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($decimal_col);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -1,103 +1,108 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a float column
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
function FlatsAreEqual($a, $b, $epsilon = 3.9265E-6)
|
||||
{
|
||||
return (abs($a - $b) < $epsilon);
|
||||
return (abs($a - $b) < $epsilon);
|
||||
}
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$sample = 1234567890.1234;
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist float(53))';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = 1234567890.1234;
|
||||
|
||||
$query = 'SELECT TOP 1 * FROM #TESTTABLE';
|
||||
$tbname = "TESTTABLE";
|
||||
createTable($conn, $tbname, array("c1" => "float(53)"));
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
print "no buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
$query = "SELECT TOP 1 * FROM $tbname";
|
||||
|
||||
print "no buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
|
||||
print "no buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
print "no buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "buffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
print "no buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
|
||||
print "buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
print "no buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
|
||||
print "buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
//prepare with client buffered cursor
|
||||
print "buffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
|
||||
print "buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
print "buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
|
||||
print "buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
$ok = FlatsAreEqual($sample, $value) ? 'TRUE' : 'FALSE';
|
||||
print "\nFetched value = Input? $ok\n\n";
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -1,95 +1,100 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a float column with the column bound and specified to type LOB
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
function FlatsAreEqual($a, $b, $epsilon = 3.9265E-6)
|
||||
{
|
||||
return (abs($a - $b) < $epsilon);
|
||||
return (abs($a - $b) < $epsilon);
|
||||
}
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$sample = 1234567890.1234;
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist float(53))';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = 1234567890.1234;
|
||||
|
||||
$query = 'SELECT exist FROM #TESTTABLE';
|
||||
$tbname = "TESTTABLE";
|
||||
createTable($conn, $tbname, array("exist" => "float(53)"));
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump ($float_col);
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump ($float_col);
|
||||
$query = "SELECT exist FROM $tbname";
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump ($float_col);
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump($float_col);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump ($float_col);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump($float_col);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump ($float_col);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump($float_col);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump ($float_col);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump($float_col);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump ($float_col);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump($float_col);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump ($float_col);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump($float_col);
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump($float_col);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $float_col, PDO::PARAM_LOB);
|
||||
$value = $stmt->fetch();
|
||||
var_dump($float_col);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -1,83 +1,88 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a int column
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$sample = 1234567890;
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist int)';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = 1234567890;
|
||||
|
||||
$query = 'SELECT TOP 1 * FROM #TESTTABLE';
|
||||
$tbname = "TESTTABLE";
|
||||
createTable($conn, $tbname, array("c1" => "int"));
|
||||
|
||||
//prepare with no buffered cursor
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
$query = "SELECT TOP 1 * FROM $tbname";
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -1,92 +1,96 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a int column with the column bound and specified as pdo type int
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$sample = 1234567890;
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = 1234567890;
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist int)';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
$tbname = "TESTTABLE";
|
||||
createTable($conn, $tbname, array("c1" => "int"));
|
||||
|
||||
$query = 'SELECT exist FROM #TESTTABLE';
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
//prepare with no buffered cursor
|
||||
$query = "SELECT c1 FROM $tbname";
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch( PDO::FETCH_BOUND );
|
||||
var_dump ($int_col);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($int_col);
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch( PDO::FETCH_BOUND );
|
||||
var_dump ($int_col);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($int_col);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch( PDO::FETCH_BOUND );
|
||||
var_dump ($int_col);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($int_col);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch( PDO::FETCH_BOUND );
|
||||
var_dump ($int_col);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($int_col);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch( PDO::FETCH_BOUND );
|
||||
var_dump ($int_col);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($int_col);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch( PDO::FETCH_BOUND );
|
||||
var_dump ($int_col);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($int_col);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch( PDO::FETCH_BOUND );
|
||||
var_dump ($int_col);
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($int_col);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch( PDO::FETCH_BOUND );
|
||||
var_dump ($int_col);
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $int_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($int_col);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -1,83 +1,93 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a money column
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$sample = 1234567890.1234;
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist money)';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = 1234567890.1234;
|
||||
|
||||
$query = 'SELECT TOP 1 * FROM #TESTTABLE';
|
||||
$tbname = "TESTTABLE";
|
||||
if (!isColEncrypted()) {
|
||||
createTable($conn, $tbname, array("c1" => "money"));
|
||||
} else {
|
||||
// inserting money types is not supported for Always Encrypted; use decimal(19,4) instead
|
||||
createTable($conn, $tbname, array("c1" => "decimal(19,4)"));
|
||||
}
|
||||
|
||||
//prepare with no buffered cursor
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
$query = "SELECT TOP 1 * FROM $tbname";
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -1,93 +1,101 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a money column with the column bound and specified as pdo type int
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$sample = 1234567890.1234;
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = 1234567890.1234;
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist money)';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
$tbname = "TESTTABLE";
|
||||
if (!isColEncrypted()) {
|
||||
createTable($conn, $tbname, array("c1" => "money"));
|
||||
} else {
|
||||
// inserting money types is not supported for Always Encrypted; use decimal(19,4) instead
|
||||
createTable($conn, $tbname, array("c1" => "decimal(19,4)"));
|
||||
}
|
||||
|
||||
$query = 'SELECT exist FROM #TESTTABLE';
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
//prepare with no buffered cursor
|
||||
$query = "SELECT c1 FROM $tbname";
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($money_col);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($money_col);
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($money_col);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($money_col);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($money_col);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($money_col);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($money_col);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($money_col);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($money_col);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($money_col);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($money_col);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($money_col);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($money_col);
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($money_col);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('exist', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump ($money_col);
|
||||
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$stmt->bindColumn('c1', $money_col, PDO::PARAM_INT);
|
||||
$value = $stmt->fetch(PDO::FETCH_BOUND);
|
||||
var_dump($money_col);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -3,94 +3,111 @@ prepare with cursor buffered and fetch from numeric columns.
|
|||
--DESCRIPTION--
|
||||
Uses buffered cursor to fetch from float, int, and decimal columns that have positive, negative and zero value.
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$sample = 1234567890.1234;
|
||||
$sample1 = -1234567890.1234;
|
||||
$sample2 = 1;
|
||||
$sample3 = -1;
|
||||
$sample4 = 0.5;
|
||||
$sample5 = -0.55;
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = 1234567890.1234;
|
||||
$sample1 = -1234567890.1234;
|
||||
$sample2 = 1;
|
||||
$sample3 = -1;
|
||||
$sample4 = 0.5;
|
||||
$sample5 = -0.55;
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (a float(53), neg_a float(53), b int, neg_b int, c decimal(16, 6), neg_c decimal(16, 6), zero int, zerof float(53), zerod decimal(16,6))';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0, :p1, :p2, :p3, :p4, :p5, 0, 0, 0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p1', $sample1, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p2', $sample2, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p3', $sample3, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p4', $sample4, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p5', $sample5, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
$tbname = "TESTTABLE";
|
||||
createTable($conn, $tbname, array("a" => "float(53)", "neg_a" => "float(53)",
|
||||
"b" => "int", "neg_b" => "int",
|
||||
"c" => "decimal(16,6)", "neg_c" => "decimal(16,6)",
|
||||
"zero" => "int", "zerof" => "float(53)", "zerod" => "decimal(16,6)"));
|
||||
|
||||
$query = 'SELECT TOP 1 * FROM #TESTTABLE';
|
||||
if (!isColEncrypted()) {
|
||||
$query = "INSERT INTO $tbname VALUES(:p0, :p1, :p2, :p3, :p4, :p5, 0, 0, 0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
} else {
|
||||
// Encrypted columns require all inputs to be bound
|
||||
$query = "INSERT INTO $tbname VALUES(:p0, :p1, :p2, :p3, :p4, :p5, :p6, :p7, :p8)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$zero = 0;
|
||||
$stmt->bindValue(':p6', $zero, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p7', $zero, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p8', $zero, PDO::PARAM_INT);
|
||||
}
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p1', $sample1, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p2', $sample2, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p3', $sample3, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p4', $sample4, PDO::PARAM_INT);
|
||||
$stmt->bindValue(':p5', $sample5, PDO::PARAM_INT);
|
||||
$stmt->execute();
|
||||
|
||||
//prepare with no buffered cursor
|
||||
$query = "SELECT TOP 1 * FROM $tbname";
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump ($value);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump($value);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump ($value);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump ($value);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump ($value);
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump ($value);
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetch(PDO::FETCH_NUM);
|
||||
var_dump($value);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
@ -268,4 +285,3 @@ array(9) {
|
|||
[8]=>
|
||||
string(7) ".000000"
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,139 +1,138 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch various columns with the column bound and specified to pdo type int
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
function test()
|
||||
{
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
try {
|
||||
$conn = connect();
|
||||
$decimal = -2345209.3103;
|
||||
$numeric = 987234.9919;
|
||||
$salary = "3456789.15";
|
||||
$debt = "98765.99";
|
||||
|
||||
$decimal = -2345209.3103;
|
||||
$numeric = 987234.9919;
|
||||
$salary = "3456789.15";
|
||||
$debt = "98765.99";
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE ([c_decimal] decimal(28,4), [c_numeric] numeric(32,4), [c_varchar] varchar(20), [c_nvarchar] nvarchar(20))';
|
||||
$tbname = "TESTTABLE";
|
||||
createTable($conn, $tbname, array("c_decimal" => "decimal(28,4)", "c_numeric" => "numeric(32,4)",
|
||||
"c_varchar" => "varchar(20)", "c_nvarchar" => "nvarchar(20)"));
|
||||
|
||||
$stmt = $conn->exec($query);
|
||||
$query = "INSERT INTO $tbname VALUES(:p0, :p1, :p2, :p3)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $decimal);
|
||||
$stmt->bindValue(':p1', $numeric);
|
||||
$stmt->bindValue(':p2', $salary);
|
||||
$stmt->bindValue(':p3', $debt);
|
||||
$stmt->execute();
|
||||
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0, :p1, :p2, :p3)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $decimal);
|
||||
$stmt->bindValue(':p1', $numeric);
|
||||
$stmt->bindValue(':p2', $salary);
|
||||
$stmt->bindValue(':p3', $debt);
|
||||
$stmt->execute();
|
||||
$decimal2 = $decimal * 2;
|
||||
$numeric2 = $numeric * 2;
|
||||
$salary2 = $salary * 2;
|
||||
$debt2 = $debt * 2;
|
||||
|
||||
$decimal2 = $decimal * 2;
|
||||
$numeric2 = $numeric * 2;
|
||||
$salary2 = $salary * 2;
|
||||
$debt2 = $debt * 2;
|
||||
$stmt->bindValue(':p0', $decimal2);
|
||||
$stmt->bindValue(':p1', $numeric2);
|
||||
$stmt->bindValue(':p2', $salary2);
|
||||
$stmt->bindValue(':p3', $debt2);
|
||||
$stmt->execute();
|
||||
|
||||
$stmt->bindValue(':p0', $decimal2);
|
||||
$stmt->bindValue(':p1', $numeric2);
|
||||
$stmt->bindValue(':p2', $salary2);
|
||||
$stmt->bindValue(':p3', $debt2);
|
||||
$stmt->execute();
|
||||
$decimal3 = $decimal * 3;
|
||||
$numeric3 = $numeric * 3;
|
||||
$salary3 = $salary * 3;
|
||||
$debt3 = $debt * 3;
|
||||
|
||||
$decimal3 = $decimal * 3;
|
||||
$numeric3 = $numeric * 3;
|
||||
$salary3 = $salary * 3;
|
||||
$debt3 = $debt * 3;
|
||||
$stmt->bindValue(':p0', $decimal3);
|
||||
$stmt->bindValue(':p1', $numeric3);
|
||||
$stmt->bindValue(':p2', $salary3);
|
||||
$stmt->bindValue(':p3', $debt3);
|
||||
$stmt->execute();
|
||||
|
||||
$stmt->bindValue(':p0', $decimal3);
|
||||
$stmt->bindValue(':p1', $numeric3);
|
||||
$stmt->bindValue(':p2', $salary3);
|
||||
$stmt->bindValue(':p3', $debt3);
|
||||
$stmt->execute();
|
||||
unset($stmt);
|
||||
|
||||
$stmt = null;
|
||||
echo("Input values:\n\torginal:$decimal\t$numeric\t$salary\t$debt\n\tdoubles:$decimal2\t$numeric2\t$salary2\t$debt2\n\ttriples:$decimal3\t$numeric3\t$salary3\t$debt3\n");
|
||||
|
||||
echo ("Input values:\n\torginal:$decimal\t$numeric\t$salary\t$debt\n\tdoubles:$decimal2\t$numeric2\t$salary2\t$debt2\n\ttriples:$decimal3\t$numeric3\t$salary3\t$debt3\n");
|
||||
|
||||
$query = 'SELECT * FROM #TESTTABLE';
|
||||
$query = "SELECT * FROM $tbname";
|
||||
|
||||
// prepare with no buffered cursor
|
||||
echo "\n\nComparing results (stringify off, fetch_numeric on):\n";
|
||||
// no buffered cursor, stringify off, fetch_numeric on
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt1 = $conn->prepare($query);
|
||||
$stmt1->execute();
|
||||
// prepare with no buffered cursor
|
||||
echo "\n\nComparing results (stringify off, fetch_numeric on):\n";
|
||||
// no buffered cursor, stringify off, fetch_numeric on
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt1 = $conn->prepare($query);
|
||||
$stmt1->execute();
|
||||
|
||||
// buffered cursor, stringify off, fetch_numeric on
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt2 = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt2->execute();
|
||||
|
||||
compareResults($stmt1, $stmt2);
|
||||
|
||||
$stmt1 = null;
|
||||
$stmt2 = null;
|
||||
|
||||
echo "\n\nComparing results (stringify off, fetch_numeric off):\n";
|
||||
// no buffered cursor, stringify off, fetch_numeric off
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt1 = $conn->prepare($query);
|
||||
$stmt1->execute();
|
||||
|
||||
// buffered cursor, stringify off, fetch_numeric off
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt2 = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt2->execute();
|
||||
|
||||
compareResults($stmt1, $stmt2);
|
||||
|
||||
$stmt1 = null;
|
||||
$stmt2 = null;
|
||||
// buffered cursor, stringify off, fetch_numeric on
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt2 = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt2->execute();
|
||||
|
||||
$conn = null;
|
||||
compareResults($stmt1, $stmt2);
|
||||
|
||||
unset($stmt1);
|
||||
unset($stmt2);
|
||||
|
||||
echo "\n\nComparing results (stringify off, fetch_numeric off):\n";
|
||||
// no buffered cursor, stringify off, fetch_numeric off
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt1 = $conn->prepare($query);
|
||||
$stmt1->execute();
|
||||
|
||||
// buffered cursor, stringify off, fetch_numeric off
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt2 = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt2->execute();
|
||||
|
||||
compareResults($stmt1, $stmt2);
|
||||
|
||||
unset($stmt1);
|
||||
unset($stmt1);
|
||||
|
||||
DropTable($conn, $tbname);
|
||||
unset($conn);
|
||||
} catch (Exception $e) {
|
||||
echo $e->getMessage();
|
||||
}
|
||||
|
||||
function compareResults($stmt1, $stmt2)
|
||||
{
|
||||
$stmt1->bindColumn('c_decimal', $decimal_col1, PDO::PARAM_INT);
|
||||
$stmt1->bindColumn('c_numeric', $numeric_col1, PDO::PARAM_INT);
|
||||
$stmt1->bindColumn('c_varchar', $salary_col1, PDO::PARAM_INT);
|
||||
$stmt1->bindColumn('c_nvarchar', $debt_col1, PDO::PARAM_INT);
|
||||
$stmt1->bindColumn('c_decimal', $decimal_col1, PDO::PARAM_INT);
|
||||
$stmt1->bindColumn('c_numeric', $numeric_col1, PDO::PARAM_INT);
|
||||
$stmt1->bindColumn('c_varchar', $salary_col1, PDO::PARAM_INT);
|
||||
$stmt1->bindColumn('c_nvarchar', $debt_col1, PDO::PARAM_INT);
|
||||
|
||||
$stmt2->bindColumn('c_decimal', $decimal_col2, PDO::PARAM_INT);
|
||||
$stmt2->bindColumn('c_numeric', $numeric_col2, PDO::PARAM_INT);
|
||||
$stmt2->bindColumn('c_varchar', $salary_col2, PDO::PARAM_INT);
|
||||
$stmt2->bindColumn('c_nvarchar', $debt_col2, PDO::PARAM_INT);
|
||||
|
||||
$numRows = 3;
|
||||
for ($i = 1; $i <= $numRows; $i++)
|
||||
{
|
||||
echo "\nreading row " . $i . "\n";
|
||||
|
||||
$value1 = $stmt1->fetch( PDO::FETCH_BOUND );
|
||||
$value2 = $stmt2->fetch( PDO::FETCH_BOUND );
|
||||
$stmt2->bindColumn('c_decimal', $decimal_col2, PDO::PARAM_INT);
|
||||
$stmt2->bindColumn('c_numeric', $numeric_col2, PDO::PARAM_INT);
|
||||
$stmt2->bindColumn('c_varchar', $salary_col2, PDO::PARAM_INT);
|
||||
$stmt2->bindColumn('c_nvarchar', $debt_col2, PDO::PARAM_INT);
|
||||
|
||||
compareData($decimal_col1, $decimal_col2);
|
||||
compareData($numeric_col1, $numeric_col2);
|
||||
compareData($salary_col1, $salary_col2);
|
||||
compareData($debt_col1, $debt_col2);
|
||||
}
|
||||
$numRows = 3;
|
||||
for ($i = 1; $i <= $numRows; $i++) {
|
||||
echo "\nreading row " . $i . "\n";
|
||||
|
||||
$value1 = $stmt1->fetch(PDO::FETCH_BOUND);
|
||||
$value2 = $stmt2->fetch(PDO::FETCH_BOUND);
|
||||
|
||||
compareData($decimal_col1, $decimal_col2);
|
||||
compareData($numeric_col1, $numeric_col2);
|
||||
compareData($salary_col1, $salary_col2);
|
||||
compareData($debt_col1, $debt_col2);
|
||||
}
|
||||
}
|
||||
|
||||
function compareData($data1, $data2)
|
||||
{
|
||||
if ($data1 != $data2)
|
||||
echo "Not matched!\n";
|
||||
else
|
||||
echo "Matched!\n";
|
||||
if ($data1 != $data2) {
|
||||
echo "Not matched!\n";
|
||||
} else {
|
||||
echo "Matched!\n";
|
||||
}
|
||||
|
||||
echo ("\tExpected: "); var_dump ($data1);
|
||||
echo ("\tActual: "); var_dump ($data2);
|
||||
echo("\tExpected: ");
|
||||
var_dump($data1);
|
||||
echo("\tActual: ");
|
||||
var_dump($data2);
|
||||
}
|
||||
|
||||
test();
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
Input values:
|
||||
|
|
|
|||
|
|
@ -1,83 +1,88 @@
|
|||
--TEST--
|
||||
prepare with cursor buffered and fetch a nvarchar column
|
||||
--SKIPIF--
|
||||
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
$conn = new PDO( "sqlsrv:server=$server; database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
$sample = "가각";
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$query = 'CREATE TABLE #TESTTABLE (exist nvarchar(10))';
|
||||
$stmt = $conn->exec($query);
|
||||
$query = 'INSERT INTO #TESTTABLE VALUES(:p0)';
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_STR);
|
||||
$stmt->execute();
|
||||
try {
|
||||
$conn = connect();
|
||||
$sample = "가각";
|
||||
|
||||
$query = 'SELECT TOP 1 * FROM #TESTTABLE';
|
||||
$tbname = "TERSTTABLE";
|
||||
createTable($conn, $tbname, array("c1" => "nvarchar(10)"));
|
||||
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$query = "INSERT INTO $tbname VALUES(:p0)";
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->bindValue(':p0', $sample, PDO::PARAM_STR);
|
||||
$stmt->execute();
|
||||
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
$query = "SELECT TOP 1 * FROM $tbname";
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with no buffered cursor
|
||||
print "no buffered cursor, stringify off, fetch_numeric off\n"; //stringify and fetch_numeric is off by default
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nno buffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query);
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
//prepare with client buffered cursor
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute( PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump ($value);
|
||||
print "\nbuffered cursor, stringify off, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
$stmt = null;
|
||||
$conn = null;
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric on\n";
|
||||
$conn->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
print "\nbuffered cursor, stringify on, fetch_numeric off\n";
|
||||
$conn->setAttribute(PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE, false);
|
||||
$stmt = $conn->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
$stmt->execute();
|
||||
$value = $stmt->fetchColumn();
|
||||
var_dump($value);
|
||||
|
||||
dropTable($conn, $tbname);
|
||||
unset($stmt);
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECT--
|
||||
no buffered cursor, stringify off, fetch_numeric off
|
||||
|
|
|
|||
|
|
@ -1,141 +1,160 @@
|
|||
--TEST--
|
||||
Test with cursor scroll and select different rows in some random order
|
||||
Test with cursor scroll and select different rows in some random order
|
||||
--SKIPIF--
|
||||
<?php require('skipif.inc'); ?>
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
include 'MsCommon.inc';
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
function Cursor_ForwardOnly($conn, $tableName)
|
||||
function cursorForwardOnly($conn, $tableName)
|
||||
{
|
||||
$stmt = $conn->exec("CREATE TABLE $tableName ([c1_int] int, [c2_tinyint] tinyint, [c3_smallint] smallint, [c4_bigint] bigint, [c5_bit] bit)");
|
||||
createTable($conn, $tableName, array("c1_int" => "int", "c2_tinyint" => "tinyint", "c3_smallint" => "smallint", "c4_bigint" => "bigint", "c5_bit" => "bit"));
|
||||
|
||||
// insert data
|
||||
$numRows = InsertData($conn, $tableName);
|
||||
|
||||
// select table
|
||||
$stmt = $conn->prepare("SELECT * FROM $tableName ORDER BY c1_int", array(constant('PDO::ATTR_CURSOR') => PDO::CURSOR_FWDONLY));
|
||||
$numRows = insertData($conn, $tableName);
|
||||
|
||||
// select table
|
||||
if (!isColEncrypted()) {
|
||||
$stmt = $conn->prepare("SELECT * FROM $tableName ORDER BY c1_int", array( constant('PDO::ATTR_CURSOR') => PDO::CURSOR_FWDONLY ));
|
||||
} else {
|
||||
// ORDER BY is not supported for encrypted columns
|
||||
$stmt = $conn->prepare("SELECT * FROM $tableName", array( constant('PDO::ATTR_CURSOR') => PDO::CURSOR_FWDONLY ));
|
||||
}
|
||||
$stmt->execute();
|
||||
|
||||
$numRowsFetched = 0;
|
||||
while ($row = $stmt->fetch(PDO::FETCH_NUM))
|
||||
{
|
||||
while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
|
||||
echo "$row[0]\n";
|
||||
$numRowsFetched++;
|
||||
}
|
||||
|
||||
if ($numRowsFetched != $numRows)
|
||||
|
||||
if ($numRowsFetched != $numRows) {
|
||||
echo "Number of rows fetched $numRowsFetched is wrong! Expected $numRows\n";
|
||||
}
|
||||
|
||||
unset($stmt);
|
||||
}
|
||||
|
||||
function Cursor_Scroll_FetchRows($conn, $tableName)
|
||||
function cursorScrollFetchRows($conn, $tableName)
|
||||
{
|
||||
$stmt = $conn->prepare("SELECT * FROM $tableName ORDER BY c1_int", array(constant('PDO::ATTR_CURSOR') => PDO::CURSOR_SCROLL));
|
||||
if (!isColEncrypted()) {
|
||||
$stmt = $conn->prepare("SELECT * FROM $tableName ORDER BY c1_int", array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL));
|
||||
} else {
|
||||
// ORDER BY is not supported for encrypted columns
|
||||
// scrollable cursor is not supported for encrypted tablee; use client side buffered cursor
|
||||
$stmt = $conn->prepare("SELECT * FROM $tableName", array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL, PDO::SQLSRV_ATTR_CURSOR_SCROLL_TYPE => PDO::SQLSRV_CURSOR_BUFFERED));
|
||||
}
|
||||
$stmt->execute();
|
||||
|
||||
GetFirstRow($stmt);
|
||||
GetNextRow($stmt);
|
||||
GetLastRow($stmt);
|
||||
GetPriorRow($stmt);
|
||||
GetAbsoluteRow($stmt, 7);
|
||||
GetAbsoluteRow($stmt, 2);
|
||||
GetRelativeRow($stmt, 3);
|
||||
GetPriorRow($stmt);
|
||||
GetRelativeRow($stmt, -4);
|
||||
GetAbsoluteRow($stmt, 0);
|
||||
GetNextRow($stmt);
|
||||
GetRelativeRow($stmt, 5);
|
||||
GetAbsoluteRow($stmt, -1);
|
||||
GetNextRow($stmt);
|
||||
GetLastRow($stmt);
|
||||
GetRelativeRow($stmt, 1);
|
||||
|
||||
getFirstRow($stmt);
|
||||
getNextRow($stmt);
|
||||
getLastRow($stmt);
|
||||
getPriorRow($stmt);
|
||||
getAbsoluteRow($stmt, 7);
|
||||
getAbsoluteRow($stmt, 2);
|
||||
getRelativeRow($stmt, 3);
|
||||
getPriorRow($stmt);
|
||||
getRelativeRow($stmt, -4);
|
||||
getAbsoluteRow($stmt, 0);
|
||||
getNextRow($stmt);
|
||||
getRelativeRow($stmt, 5);
|
||||
getAbsoluteRow($stmt, -1);
|
||||
getNextRow($stmt);
|
||||
getLastRow($stmt);
|
||||
getRelativeRow($stmt, 1);
|
||||
|
||||
unset($stmt);
|
||||
}
|
||||
|
||||
function InsertData($conn, $tableName)
|
||||
function insertData($conn, $tableName)
|
||||
{
|
||||
$numRows = 0;
|
||||
$count = $conn->exec("INSERT INTO $tableName (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_bit) VALUES ((1), (0), (null), (9223372036854775807), (0))");
|
||||
$numRows += $count;
|
||||
$count = $conn->exec("INSERT INTO $tableName (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_bit) VALUES ((2), (null), (-32768), (9223372036854775807), (0))");
|
||||
$numRows += $count;
|
||||
$count = $conn->exec("INSERT INTO $tableName (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_bit) VALUES ((3), (255), (-32768), (1035941737), (0))");
|
||||
$numRows += $count;
|
||||
$count = $conn->exec("INSERT INTO $tableName (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_bit) VALUES ((4), (null), (4762), (804325764), (0))");
|
||||
$numRows += $count;
|
||||
$count = $conn->exec("INSERT INTO $tableName (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_bit) VALUES ((5), (57), (32767), (-9223372036854775808), (0))");
|
||||
$numRows += $count;
|
||||
$count = $conn->exec("INSERT INTO $tableName (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_bit) VALUES ((6), (201), (-32768), (450619355), (0))");
|
||||
$numRows += $count;
|
||||
$count = $conn->exec("INSERT INTO $tableName (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_bit) VALUES ((7), (244), (-21244), (981345728), (0))");
|
||||
$numRows += $count;
|
||||
$count = $conn->exec("INSERT INTO $tableName (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_bit) VALUES ((8), (143), (0), (-1330405117), (0))");
|
||||
$numRows += $count;
|
||||
$count = $conn->exec("INSERT INTO $tableName (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_bit) VALUES ((9), (null), (null), (209123628), (0))");
|
||||
$numRows += $count;
|
||||
$count = $conn->exec("INSERT INTO $tableName (c1_int, c2_tinyint, c3_smallint, c4_bigint, c5_bit) VALUES ((10), (147), (21133), (-1), (0))");
|
||||
$numRows += $count;
|
||||
|
||||
|
||||
insertRow($conn, $tableName, array("c1_int" => 1, "c2_tinyint" => 0, "c3_smallint" => null, "c4_bigint" => 922337203685477, "c5_bit" => 0));
|
||||
$numRows++;
|
||||
|
||||
insertRow($conn, $tableName, array("c1_int" => 2, "c2_tinyint" => null, "c3_smallint" => -32768, "c4_bigint" => 922337203685477, "c5_bit" => 0));
|
||||
$numRows++;
|
||||
|
||||
insertRow($conn, $tableName, array("c1_int" => 3, "c2_tinyint" => 255, "c3_smallint" => -32768, "c4_bigint" => 1035941737, "c5_bit" => 0));
|
||||
$numRows++;
|
||||
|
||||
insertRow($conn, $tableName, array("c1_int" => 4, "c2_tinyint" => null, "c3_smallint" => 4762, "c4_bigint" => 804325764, "c5_bit" => 0));
|
||||
$numRows++;
|
||||
|
||||
insertRow($conn, $tableName, array("c1_int" => 5, "c2_tinyint" => 57, "c3_smallint" => 32767, "c4_bigint" => -922337203685477, "c5_bit" => 0));
|
||||
$numRows++;
|
||||
|
||||
insertRow($conn, $tableName, array("c1_int" => 6, "c2_tinyint" => 201, "c3_smallint" => -32768, "c4_bigint" => 450619355, "c5_bit" => 0));
|
||||
$numRows++;
|
||||
|
||||
insertRow($conn, $tableName, array("c1_int" => 7, "c2_tinyint" => 244, "c3_smallint" => -21244, "c4_bigint" => 981345728, "c5_bit" => 0));
|
||||
$numRows++;
|
||||
|
||||
insertRow($conn, $tableName, array("c1_int" => 8, "c2_tinyint" => 143, "c3_smallint" => 0, "c4_bigint" => -1330405117, "c5_bit" => 0));
|
||||
$numRows++;
|
||||
|
||||
insertRow($conn, $tableName, array("c1_int" => 9, "c2_tinyint" => null, "c3_smallint" => null, "c4_bigint" => 209123628, "c5_bit" => 0));
|
||||
$numRows++;
|
||||
|
||||
insertRow($conn, $tableName, array("c1_int" => 10, "c2_tinyint" => 147, "c3_smallint" => 21133, "c4_bigint" => -1, "c5_bit" => 0));
|
||||
$numRows++;
|
||||
|
||||
return $numRows;
|
||||
}
|
||||
|
||||
function GetFirstRow($stmt)
|
||||
function getFirstRow($stmt)
|
||||
{
|
||||
echo "\nfirst row: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_FIRST, 0);
|
||||
echo "first row: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_FIRST, 0);
|
||||
if ($row)
|
||||
{
|
||||
echo "$row[0]\n";
|
||||
}
|
||||
echo "$row[0]";
|
||||
echo "\n";
|
||||
}
|
||||
|
||||
function GetNextRow($stmt)
|
||||
function getNextRow($stmt)
|
||||
{
|
||||
echo "\nnext row: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_NEXT, 0);
|
||||
echo "next row: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_NEXT, 0);
|
||||
if ($row)
|
||||
{
|
||||
echo "$row[0]\n";
|
||||
}
|
||||
echo "$row[0]";
|
||||
echo "\n";
|
||||
}
|
||||
|
||||
function GetPriorRow($stmt)
|
||||
function getPriorRow($stmt)
|
||||
{
|
||||
echo "\nprior row: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_PRIOR, 0);
|
||||
echo "prior row: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_PRIOR, 0);
|
||||
if ($row)
|
||||
{
|
||||
echo "$row[0]\n";
|
||||
}
|
||||
echo "$row[0]";
|
||||
echo "\n";
|
||||
}
|
||||
|
||||
function GetLastRow($stmt)
|
||||
function getLastRow($stmt)
|
||||
{
|
||||
echo "\nlast row: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_LAST, 0);
|
||||
echo "last row: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_LAST, 0);
|
||||
if ($row)
|
||||
{
|
||||
echo "$row[0]\n";
|
||||
}
|
||||
echo "$row[0]";
|
||||
echo "\n";
|
||||
}
|
||||
|
||||
function GetRelativeRow($stmt, $offset)
|
||||
function getRelativeRow($stmt, $offset)
|
||||
{
|
||||
echo "\nrow $offset from the current row: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_REL, $offset);
|
||||
echo "row $offset from the current row: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_REL, $offset);
|
||||
if ($row)
|
||||
{
|
||||
echo "$row[0]\n";
|
||||
}
|
||||
echo "$row[0]";
|
||||
echo "\n";
|
||||
}
|
||||
|
||||
function GetAbsoluteRow($stmt, $offset)
|
||||
function getAbsoluteRow($stmt, $offset)
|
||||
{
|
||||
echo "\nabsolute row with offset $offset: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_ABS, $offset);
|
||||
echo "absolute row with offset $offset: ";
|
||||
$row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_ABS, $offset);
|
||||
if ($row)
|
||||
{
|
||||
echo "$row[0]\n";
|
||||
}
|
||||
echo "$row[0]";
|
||||
echo "\n";
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -143,39 +162,25 @@ function GetAbsoluteRow($stmt, $offset)
|
|||
// RunTest
|
||||
//
|
||||
//--------------------------------------------------------------------
|
||||
function RunTest()
|
||||
{
|
||||
StartTest("pdo_fetch_cursor_scroll_random");
|
||||
echo "\nTest begins...\n";
|
||||
try
|
||||
{
|
||||
include("MsSetup.inc");
|
||||
|
||||
// Connect
|
||||
$conn = new PDO( "sqlsrv:server=$server;database=$databaseName", $uid, $pwd);
|
||||
$conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
|
||||
|
||||
$tableName = GetTempTableName();
|
||||
|
||||
Cursor_ForwardOnly($conn, $tableName);
|
||||
Cursor_Scroll_FetchRows($conn, $tableName);
|
||||
echo "Test begins...\n";
|
||||
try {
|
||||
// Connect
|
||||
$conn = connect();
|
||||
$tableName = getTableName();
|
||||
|
||||
$conn = null;
|
||||
}
|
||||
catch (Exception $e)
|
||||
{
|
||||
echo $e->getMessage();
|
||||
}
|
||||
echo "\nDone\n";
|
||||
EndTest("pdo_fetch_cursor_scroll_random");
|
||||
cursorForwardOnly($conn, $tableName);
|
||||
cursorScrollFetchRows($conn, $tableName);
|
||||
|
||||
dropTable($conn, $tableName);
|
||||
unset($conn);
|
||||
} catch (Exception $e) {
|
||||
echo $e->getMessage();
|
||||
}
|
||||
|
||||
RunTest();
|
||||
|
||||
echo "Done\n";
|
||||
?>
|
||||
--EXPECT--
|
||||
|
||||
Test begins...
|
||||
Test begins...
|
||||
1
|
||||
2
|
||||
3
|
||||
|
|
@ -186,36 +191,20 @@ Test begins...
|
|||
8
|
||||
9
|
||||
10
|
||||
|
||||
first row: 1
|
||||
|
||||
next row: 2
|
||||
|
||||
last row: 10
|
||||
|
||||
prior row: 9
|
||||
|
||||
absolute row with offset 7: 8
|
||||
|
||||
absolute row with offset 2: 3
|
||||
|
||||
row 3 from the current row: 6
|
||||
|
||||
prior row: 5
|
||||
|
||||
row -4 from the current row: 1
|
||||
|
||||
absolute row with offset 0: 1
|
||||
|
||||
next row: 2
|
||||
|
||||
row 5 from the current row: 7
|
||||
|
||||
absolute row with offset -1:
|
||||
next row: 1
|
||||
|
||||
last row: 10
|
||||
|
||||
row 1 from the current row:
|
||||
Done
|
||||
Test "pdo_fetch_cursor_scroll_random" completed successfully.
|
||||
|
|
@ -1,16 +1,21 @@
|
|||
--TEST--
|
||||
Test client info by calling PDO::getAttribute with PDO::ATTR_CLIENT_VERSION
|
||||
Test client info by calling PDO::getAttribute with PDO::ATTR_CLIENT_VERSION
|
||||
--SKIPIF--
|
||||
<?php require('skipif_mid-refactor.inc'); ?>
|
||||
--FILE--
|
||||
<?php
|
||||
require_once("MsSetup.inc");
|
||||
require_once("MsCommon_mid-refactor.inc");
|
||||
|
||||
$conn = new PDO( "sqlsrv:server=$server", "$uid", "$pwd" );
|
||||
try {
|
||||
$conn = connect();
|
||||
// An example using PDO::ATTR_CLIENT_VERSION
|
||||
print_r($conn->getAttribute(PDO::ATTR_CLIENT_VERSION));
|
||||
|
||||
// An example using PDO::ATTR_CLIENT_VERSION
|
||||
print_r($conn->getAttribute( PDO::ATTR_CLIENT_VERSION ));
|
||||
|
||||
//free the connection
|
||||
$conn=null;
|
||||
//free the connection
|
||||
unset($conn);
|
||||
} catch (PDOException $e) {
|
||||
var_dump($e->errorInfo);
|
||||
}
|
||||
?>
|
||||
--EXPECTREGEX--
|
||||
Array
|
||||
|
|
@ -19,4 +24,4 @@ Array
|
|||
\[DriverODBCVer\] => [0-9]{1,2}\.[0-9]{1,2}
|
||||
\[DriverVer\] => [0-9]{1,2}\.[0-9]{1,2}\.[0-9]{4}
|
||||
\[ExtensionVer\] => [0-9].[0-9]\.[0-9](-(RC[0-9]?|preview))?(\.[0-9]+)?(\+[0-9]+)?
|
||||
\)
|
||||
\)
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue