diff --git a/.github/workflows/jdbc-tests-with-jtds.yml b/.github/workflows/jdbc-tests-with-jtds.yml new file mode 100644 index 0000000000..554ebc89fc --- /dev/null +++ b/.github/workflows/jdbc-tests-with-jtds.yml @@ -0,0 +1,175 @@ +name: JDBC Tests with JTDS +on: [push, pull_request] + +jobs: + run-babelfish-jdbc-tests: + env: + INSTALL_DIR: psql + useJTDSInsteadOfMSSQLJDBC: "true" + runs-on: ubuntu-20.04 + steps: + - uses: actions/checkout@v2 + id: checkout + + - name: Install Dependencies + id: install-dependencies + if: always() + uses: ./.github/composite-actions/install-dependencies + + - name: Build Modified Postgres + id: build-modified-postgres + if: always() && steps.install-dependencies.outcome == 'success' + uses: ./.github/composite-actions/build-modified-postgres + with: + install_dir: 'psql' + code_coverage: 'yes' + + - name: Compile ANTLR + id: compile-antlr + if: always() && steps.build-modified-postgres.outcome == 'success' + uses: ./.github/composite-actions/compile-antlr + + - name: Build Extensions + id: build-extensions + if: always() && steps.compile-antlr.outcome == 'success' + uses: ./.github/composite-actions/build-extensions + + - name: Build tds_fdw Extension + id: build-tds_fdw-extension + if: always() && steps.build-extensions.outcome == 'success' + uses: ./.github/composite-actions/build-tds_fdw-extension + + - name: Build vector Extension + id: build-vector-extension + if: always() && steps.build-tds_fdw-extension.outcome == 'success' + uses: ./.github/composite-actions/build-vector-extension + + - name: Build PostGIS Extension + id: build-postgis-extension + if: always() && steps.build-vector-extension.outcome == 'success' + uses: ./.github/composite-actions/build-postgis-extension + + - name: Install Extensions + id: install-extensions + if: always() && steps.build-postgis-extension.outcome == 'success' + uses: ./.github/composite-actions/install-extensions + with: + wal_level: logical + + - name: Run JDBC Tests + id: jdbc + if: always() && steps.install-extensions.outcome == 'success' + timeout-minutes: 60 + uses: ./.github/composite-actions/run-jdbc-tests + + - name: Start secondary server + id: start-secondary + if: always() && steps.jdbc.outcome == 'success' + uses: ./.github/composite-actions/install-extensions + with: + psql_port: 5433 + tsql_port: 8199 + wal_level: logical + + - name: Setup Publication and Subscription + id: setup-pub-sub + if: always() && steps.start-secondary.outcome == 'success' + run: | + ~/${{env.INSTALL_DIR}}/bin/psql -v ON_ERROR_STOP=1 -d jdbc_testdb -U runner -c "CREATE PUBLICATION my_pub;" + ~/${{env.INSTALL_DIR}}/bin/psql -v ON_ERROR_STOP=1 -d jdbc_testdb -U runner -p 5433 -c "CREATE SUBSCRIPTION my_sub CONNECTION 'host=localhost port=5432 user=jdbc_user dbname=jdbc_testdb password=12345678' PUBLICATION my_pub;" + + - name: Run Replication Tests + id: replication + if: always() && steps.setup-pub-sub.outcome == 'success' + timeout-minutes: 60 + uses: ./.github/composite-actions/run-jdbc-tests + with: + input_dir: 'replication' + + - name: Cleanup babelfish database + id: cleanup + if: always() && steps.replication.outcome == 'success' + run: | + sudo ~/psql/bin/psql -d postgres -U runner -v user="jdbc_user" -v db="jdbc_testdb" -f .github/scripts/cleanup_babelfish_database.sql + + - name: Upload Log + if: always() && (steps.jdbc.outcome == 'failure' || steps.replication.outcome == 'failure') + uses: actions/upload-artifact@v2 + with: + name: postgres-log-jdbc + path: | + ~/psql/data/logfile + ~/psql/data_5433/logfile + + # The test summary files contain paths with ':' characters, which is not allowed with the upload-artifact actions + - name: Rename Test Summary Files + id: test-file-rename + if: always() && (steps.jdbc.outcome == 'failure' || steps.replication.outcome == 'failure') + run: | + cd test/JDBC/Info + timestamp=`ls -Art | tail -n 1` + cd $timestamp + mv $timestamp.diff ../output-diff.diff + mv "$timestamp"_runSummary.log ../run-summary.log + cd .. + # get the replication output diff as well if it is present + dir_count=`ls | wc -l` + if [[ $dir_count -eq 2 ]];then + timestamp=`ls -rt | tail -n 2 | sort -r | tail -n 1` + cd $timestamp + mv $timestamp.diff ../replication-output-diff.diff + mv "$timestamp"_runSummary.log ../replication-run-summary.log + + - name: Upload Run Summary + if: always() && steps.test-file-rename.outcome == 'success' + uses: actions/upload-artifact@v2 + with: + name: run-summary.log + path: | + test/JDBC/Info/run-summary.log + test/JDBC/Info/replication-run-summary.log + + - name: Upload Output Diff + if: always() && (steps.jdbc.outcome == 'failure' || steps.replication.outcome == 'failure') + uses: actions/upload-artifact@v2 + with: + name: jdbc-output-diff.diff + path: | + test/JDBC/Info/output-diff.diff + test/JDBC/Info/replication-output-diff.diff + + - name: Check and upload coredumps + if: always() && (steps.jdbc.outcome == 'failure' || steps.replication.outcome == 'failure') + uses: ./.github/composite-actions/upload-coredump + + - name: Generate Code Coverage + id: generate-code-coverage + if: always() && (steps.jdbc.outcome == 'success' && steps.replication.outcome == 'success') + run: | + export PG_CONFIG=~/psql/bin/pg_config + export PG_SRC=~/work/postgresql_modified_for_babelfish + export cmake=$(which cmake) + cd contrib + for ext in babelfishpg_common babelfishpg_money babelfishpg_tds babelfishpg_tsql + do + cd $ext + /usr/bin/lcov --gcov-tool /usr/bin/gcov -q --no-external -c -d . -d ./ -o lcov_test.info + cd .. + done + shell: bash + + - name: Summarize code coverage + id: code-coverage-summary + if: always() && steps.generate-code-coverage.outcome == 'success' + run: | + cd contrib/ + lcov -a babelfishpg_tsql/lcov_test.info -a babelfishpg_tds/lcov_test.info -a babelfishpg_common/lcov_test.info -a babelfishpg_money/lcov_test.info -o jdbc-lcov.info + lcov --list jdbc-lcov.info + + - name: Upload Coverage Report for Babelfish Extensions + if: always() && steps.code-coverage-summary.outcome == 'success' + uses: actions/upload-artifact@v3 + with: + name: coverage-babelfish-extensions-jdbc + path: contrib/jdbc-lcov.info + retention-days: 1 diff --git a/contrib/babelfishpg_tds/src/backend/tds/tdslogin.c b/contrib/babelfishpg_tds/src/backend/tds/tdslogin.c index 770a87a4bd..edde0b0e8e 100644 --- a/contrib/babelfishpg_tds/src/backend/tds/tdslogin.c +++ b/contrib/babelfishpg_tds/src/backend/tds/tdslogin.c @@ -1989,41 +1989,45 @@ TdsProcessLogin(Port *port, bool loadedSsl) TdsErrorContext->phase = 0; TdsErrorContext->reqType = TDS_LOGIN7; - PG_TRY(); + if (!TdsReadNextBuffer() && TdsCheckMessageType(TDS_PRELOGIN)) { - TdsErrorContext->err_text = "Parsing PreLogin Request"; - /* Pre-Login */ - rc = ParsePreLoginRequest(); + PG_TRY(); + { + TdsErrorContext->err_text = "Parsing PreLogin Request"; + /* Pre-Login */ + rc = ParsePreLoginRequest(); + if (rc < 0) + return rc; + + TdsErrorContext->err_text = "Make PreLogin Response"; + + loadEncryption = MakePreLoginResponse(port, loadedSsl); + TdsFlush(); + + TdsErrorContext->err_text = "Setup SSL Handshake"; + /* Setup the SSL handshake */ + if (loadEncryption == TDS_ENCRYPT_ON || + loadEncryption == TDS_ENCRYPT_OFF || + loadEncryption == TDS_ENCRYPT_REQ) + rc = SecureOpenServer(port); + } + PG_CATCH(); + { + PG_RE_THROW(); + } + PG_END_TRY(); + + /* + * If SSL handshake failure has occurred then no need to go ahead with + * login, Just return from here. + */ if (rc < 0) return rc; - TdsErrorContext->err_text = "Make PreLogin Response"; + if (loadEncryption == TDS_ENCRYPT_ON) + TDSInstrumentation(INSTR_TDS_LOGIN_END_TO_END_ENCRYPT); - loadEncryption = MakePreLoginResponse(port, loadedSsl); - TdsFlush(); - - TdsErrorContext->err_text = "Setup SSL Handshake"; - /* Setup the SSL handshake */ - if (loadEncryption == TDS_ENCRYPT_ON || - loadEncryption == TDS_ENCRYPT_OFF || - loadEncryption == TDS_ENCRYPT_REQ) - rc = SecureOpenServer(port); - } - PG_CATCH(); - { - PG_RE_THROW(); } - PG_END_TRY(); - - /* - * If SSL handshake failure has occurred then no need to go ahead with - * login, Just return from here. - */ - if (rc < 0) - return rc; - - if (loadEncryption == TDS_ENCRYPT_ON) - TDSInstrumentation(INSTR_TDS_LOGIN_END_TO_END_ENCRYPT); PG_TRY(); { diff --git a/contrib/babelfishpg_tds/src/backend/tds/tdsresponse.c b/contrib/babelfishpg_tds/src/backend/tds/tdsresponse.c index d1a19fed4c..9ffc3004eb 100644 --- a/contrib/babelfishpg_tds/src/backend/tds/tdsresponse.c +++ b/contrib/babelfishpg_tds/src/backend/tds/tdsresponse.c @@ -1785,6 +1785,7 @@ PrepareRowDescription(TupleDesc typeinfo, PlannedStmt *plannedstmt, List *target } SetAttributesForColmetada(col); + col->atttypmod = atttypmod; switch (finfo->sendFuncId) { @@ -1855,15 +1856,36 @@ PrepareRowDescription(TupleDesc typeinfo, PlannedStmt *plannedstmt, List *target /* If this is vector datatype, we should adjust the typmod */ if (is_sys_vector_datatype(col->pgTypeOid)) atttypmod = -1; - - SetColMetadataForCharTypeHelper(col, TDS_TYPE_VARCHAR, - att->attcollation, (atttypmod == -1) ? - atttypmod : (atttypmod - 4)); + /* + * If client being connected is using TDS version lower than or equal to + * 7.1 then TSQL treats varchar(max) as Text. + */ + if (tdsVersion <= TDS_VERSION_7_1_1 && atttypmod == -1) + { + SetColMetadataForTextTypeHelper(col, TDS_TYPE_TEXT, + att->attcollation, (atttypmod - 4)); + sendTableName |= col->sendTableName; + } + else + SetColMetadataForCharTypeHelper(col, TDS_TYPE_VARCHAR, + att->attcollation, (atttypmod == -1) ? + atttypmod : (atttypmod - 4)); break; case TDS_SEND_NVARCHAR: - SetColMetadataForCharTypeHelper(col, TDS_TYPE_NVARCHAR, - att->attcollation, (atttypmod == -1) ? - atttypmod : (atttypmod - 4) * 2); + /* + * If client being connected is using TDS version lower than or equal to + * 7.1 then TSQL treats nvarchar(max) as NText. + */ + if (tdsVersion <= TDS_VERSION_7_1_1 && atttypmod == -1) + { + SetColMetadataForTextTypeHelper(col, TDS_TYPE_NTEXT, + att->attcollation, (atttypmod - 4) * 2); + sendTableName |= col->sendTableName; + } + else + SetColMetadataForCharTypeHelper(col, TDS_TYPE_NVARCHAR, + att->attcollation, (atttypmod == -1) ? + atttypmod : (atttypmod - 4) * 2); break; case TDS_SEND_MONEY: if (col->attNotNull) @@ -1976,8 +1998,18 @@ PrepareRowDescription(TupleDesc typeinfo, PlannedStmt *plannedstmt, List *target case TDS_SEND_VARBINARY: if (atttypmod == -1 && tle != NULL) atttypmod = resolve_varbinary_typmod_from_exp((Node *) tle->expr); - SetColMetadataForBinaryType(col, TDS_TYPE_VARBINARY, (atttypmod == -1) ? - atttypmod : atttypmod - VARHDRSZ); + /* + * If client being connected is using TDS version lower than or equal to + * 7.1 then TSQL treats varbinary(max) as Image. + */ + if (tdsVersion <= TDS_VERSION_7_1_1 && atttypmod == -1) + { + SetColMetadataForImageType(col, TDS_TYPE_IMAGE); + sendTableName |= col->sendTableName; + } + else + SetColMetadataForBinaryType(col, TDS_TYPE_VARBINARY, (atttypmod == -1) ? + atttypmod : atttypmod - VARHDRSZ); break; case TDS_SEND_UNIQUEIDENTIFIER: SetColMetadataForFixedType(col, TDS_TYPE_UNIQUEIDENTIFIER, TDS_MAXLEN_UNIQUEIDENTIFIER); @@ -2051,10 +2083,10 @@ PrepareRowDescription(TupleDesc typeinfo, PlannedStmt *plannedstmt, List *target /* * If client being connected is using TDS version lower * than 7.3A then TSQL treats DATETIMEOFFSET as NVARCHAR. - * Max len here would be 64('YYYY-MM-DD hh:mm:ss[.nnnnnnn] + * Max len here would be 68('YYYY-MM-DD hh:mm:ss[.nnnnnnn] * [+|-]hh:mm'). and Making use of default collation Oid. */ - SetColMetadataForCharTypeHelper(col, TDS_TYPE_NVARCHAR, serverCollationOid, 64); + SetColMetadataForCharTypeHelper(col, TDS_TYPE_NVARCHAR, serverCollationOid, 68); else { if (atttypmod == -1) @@ -2362,6 +2394,42 @@ SendReturnValueTokenInternal(ParameterToken token, uint8 status, (token->paramMeta.sendFunc) (finfo, datum, (void *) &token->paramMeta); } +/* + * SendReturnValueIntInternal + * + * status - stored procedure (0x01) or UDF (0x02) + */ +void +SendReturnValueIntInternal(uint8 status, int32 value) +{ + SendPendingDone(true); + + /* token type */ + TDS_DEBUG(TDS_DEBUG2, "SendReturnValueIntInternal: token=0x%02x", TDS_TOKEN_RETURNVALUE); + + /* TokenType */ + TdsPutUInt8(TDS_TOKEN_RETURNVALUE); + /* ParamOrdinal */ + TdsPutUInt16LE(0x0d); + /* ParamName */ + TdsPutUInt8(0); + /* Status */ + TdsPutUInt8(status); + /* UserType */ + if (GetClientTDSVersion() <= TDS_VERSION_7_1_1) + TdsPutUInt16LE(0); + else + TdsPutUInt32LE(0); + /* Flags */ + TdsPutUInt16LE(0); + /* TypeInfo */ + TdsPutUInt8(TDS_TYPE_INTEGER); + TdsPutUInt8(0x04); + /* Value */ + TdsPutUInt8(0x04); + TdsPutInt32LE(value); +} + int GetTypModForToken(ParameterToken token) { diff --git a/contrib/babelfishpg_tds/src/backend/tds/tdsrpc.c b/contrib/babelfishpg_tds/src/backend/tds/tdsrpc.c index 24a16de028..b920e41a24 100644 --- a/contrib/babelfishpg_tds/src/backend/tds/tdsrpc.c +++ b/contrib/babelfishpg_tds/src/backend/tds/tdsrpc.c @@ -1253,6 +1253,13 @@ GetSetColMetadataForTextType(ParameterToken temp, StringInfo message, uint8_t td (collation & 0xFFF00000) >> 20, sortId, temp->maxLen); + /* + * Update max length to the max allowed text/ntext length from metadata + * (that is currently hardcoded to 0x7fffffff) so it can pass the lenght + * check. + */ + temp->maxLen = temp->paramMeta.metaEntry.type3.maxSize; + *mainOffset = offset; return STATUS_OK; } @@ -2345,6 +2352,7 @@ HandleSPCursorOpenCommon(TDSRequestSP req) int curoptions = 0; int ret; StringInfoData buf; + char *paramdefstr; TdsErrorContext->err_text = "Processing SP_CURSOROPEN Common Request"; /* fetch cursor options */ @@ -2392,8 +2400,13 @@ HandleSPCursorOpenCommon(TDSRequestSP req) pgstat_report_activity(STATE_RUNNING, activity); pfree(activity); + if (req->dataParameter->isNull || req->metaDataParameterValue->len == 0) + paramdefstr = NULL; + else + paramdefstr = req->metaDataParameterValue->data; + ret = pltsql_plugin_handler_ptr->sp_cursorprepare_callback((int *) &req->cursorPreparedHandle, buf.data, curoptions, &req->scrollopt, &req->ccopt, - (int) req->nTotalBindParams, req->boundParamsOidList); + 0, NULL, paramdefstr); break; case SP_CURSORPREPEXEC: set_ps_display("active"); @@ -2428,7 +2441,13 @@ HandleSPCursorOpenCommon(TDSRequestSP req) TDSStatementEndCallback(NULL, NULL); /* Send the response now */ - SendCursorResponse(req); + if (req->spType == SP_CURSORPREPARE) + { + SendReturnValueIntInternal(1, req->cursorPreparedHandle); + TdsSendDone(TDS_TOKEN_DONEPROC, TDS_DONE_FINAL, 0xe0, 0); + } + else + SendCursorResponse(req); /* Log immediately if dictated by log_statement and log_duration */ TDSLogStatementCursorHandler(req, buf.data, PRINT_BOTH_CURSOR_HANDLE); @@ -2518,6 +2537,7 @@ FetchAndValidateCursorFetchOptions(TDSRequestSP req, int *fetchType, case SP_CURSOR_FETCH_PREV: case SP_CURSOR_FETCH_LAST: case SP_CURSOR_FETCH_ABSOLUTE: + case SP_CURSOR_FETCH_INFO: break; /* @@ -2528,7 +2548,6 @@ FetchAndValidateCursorFetchOptions(TDSRequestSP req, int *fetchType, */ case SP_CURSOR_FETCH_RELATIVE: case SP_CURSOR_FETCH_REFRESH: - case SP_CURSOR_FETCH_INFO: case SP_CURSOR_FETCH_PREV_NOADJUST: case SP_CURSOR_FETCH_SKIP_UPDT_CNCY: ereport(ERROR, @@ -2543,7 +2562,7 @@ FetchAndValidateCursorFetchOptions(TDSRequestSP req, int *fetchType, token = req->cursorExtraArg2; - if (token) + if (token && !token->isNull) { /* the token must be integer */ Assert(token->paramMeta.metaLen == sizeof(token->paramMeta.metaEntry.type1) && @@ -2567,7 +2586,7 @@ FetchAndValidateCursorFetchOptions(TDSRequestSP req, int *fetchType, token = req->cursorExtraArg3; - if (token) + if (token && !token->isNull) { /* the token must be integer */ Assert(token->paramMeta.metaLen == sizeof(token->paramMeta.metaEntry.type1) && @@ -2591,6 +2610,10 @@ FetchAndValidateCursorFetchOptions(TDSRequestSP req, int *fetchType, errmsg("invalid nrow value 0 for cursor type %X", *fetchType))); } } + else if (*fetchType == SP_CURSOR_FETCH_INFO) + { + *howMany = -1; + } else { /* If nrows is not specified, the default value is 20 rows. */ @@ -2635,6 +2658,13 @@ HandleSPCursorFetchRequest(TDSRequestSP req) TDSStatementEndCallback(NULL, NULL); + if (fetchType == SP_CURSOR_FETCH_INFO) + { + /* return rownum and nrows as output parameters */ + SendReturnValueIntInternal(1, rownum); + SendReturnValueIntInternal(1, nrows); + } + TdsSendDone(TDS_TOKEN_DONEINPROC, TDS_DONE_MORE, TDS_CMD_SELECT, SPI_processed); /* for success, the return status is 0 */ @@ -3309,9 +3339,9 @@ GetRPCRequest(StringInfo message) case SP_CURSORPREPARE: { /* - * 1. Cursor prepared Handle parameter (mandatory) 2. query - * parameter (mandatory) 3. ExtraArg1 = scrollopt 4. ExtraArg2 - * = ccopt + * 1. Cursor prepared Handle parameter OUT (mandatory) 2. parameters + * definition (mandatory) 3. query parameter (mandatory) 4. options + * (mandatory) 5. ExtraArg1 = scrollopt 6. ExtraArg2 = ccopt */ TDSInstrumentation(INSTR_UNSUPPORTED_TDS_SP_CURSORPREPARE); if (unlikely(parameterCount < 4)) @@ -3325,27 +3355,33 @@ GetRPCRequest(StringInfo message) errmsg("%s parameter should be of %s type", "Cursor prepared handle", "integer"))); request->cursorPreparedHandleParameter = request->parameter; + if (unlikely(!request->cursorPreparedHandleParameter->next)) + ereport(ERROR, + (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), + errmsg("%s parameter is mandatory", "Parameters definition"))); + if (unlikely(FetchDataTypeNameFromParameter(request->cursorPreparedHandleParameter->next) != TDS_TYPE_NVARCHAR && + FetchDataTypeNameFromParameter(request->cursorPreparedHandleParameter->next) != TDS_TYPE_NCHAR && + FetchDataTypeNameFromParameter(request->cursorPreparedHandleParameter->next) != TDS_TYPE_NTEXT)) + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("%s parameter should be of %s type", "Parameters definition", "NVARCHAR, NCHAR or NTEXT"))); + request->dataParameter = request->cursorPreparedHandleParameter->next; + TdsReadUnicodeDataFromTokenCommon(message->data, - request->cursorPreparedHandleParameter->next, + request->dataParameter, request->metaDataParameterValue); - if (unlikely(!request->cursorPreparedHandleParameter->next->next)) + if (unlikely(!request->dataParameter->next)) ereport(ERROR, (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), errmsg("%s parameter should not be null", "Query"))); - if (unlikely(FetchDataTypeNameFromParameter(request->cursorPreparedHandleParameter->next->next) != TDS_TYPE_NVARCHAR && - FetchDataTypeNameFromParameter(request->cursorPreparedHandleParameter->next->next) != TDS_TYPE_NTEXT)) + if (unlikely(FetchDataTypeNameFromParameter(request->dataParameter->next) != TDS_TYPE_NVARCHAR && + FetchDataTypeNameFromParameter(request->dataParameter->next) != TDS_TYPE_NCHAR && + FetchDataTypeNameFromParameter(request->dataParameter->next) != TDS_TYPE_NTEXT)) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("%s parameter should be of %s type", "Query", "NVARCHAR or NTEXT"))); - request->queryParameter = request->cursorPreparedHandleParameter->next->next; - - if (unlikely(FetchDataTypeNameFromParameter(request->queryParameter) != TDS_TYPE_NVARCHAR && - FetchDataTypeNameFromParameter(request->parameter) != TDS_TYPE_NCHAR && - FetchDataTypeNameFromParameter(request->parameter) != TDS_TYPE_NTEXT)) - ereport(ERROR, - (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("%s parameter should be of %s type", "Query", "NVARCHAR or NTEXT"))); + errmsg("%s parameter should be of %s type", "Query", "NVARCHAR, NCHAR or NTEXT"))); + request->queryParameter = request->dataParameter->next; request->cursorExtraArg1 = request->queryParameter->next; if (unlikely(FetchDataTypeNameFromParameter(request->cursorExtraArg1) != TDS_TYPE_INTEGER)) @@ -3364,9 +3400,6 @@ GetRPCRequest(StringInfo message) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("%s parameter should be of %s type", "ccopt", "integer"))); - ereport(ERROR, - (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("\n Tds %s not supported yet", "SP_CURSORPREPARE"))); } break; case SP_EXECUTESQL: @@ -3589,12 +3622,14 @@ ProcessRPCRequest(TDSRequest request) HandleSPCursorRequest(req); break; case SP_CURSOROPEN: - case SP_CURSORPREPARE: case SP_CURSORPREPEXEC: case SP_CURSOREXEC: GenerateBindParamsData(req); HandleSPCursorOpenCommon(req); break; + case SP_CURSORPREPARE: + HandleSPCursorOpenCommon(req); + break; case SP_CURSORFETCH: HandleSPCursorFetchRequest(req); break; diff --git a/contrib/babelfishpg_tds/src/backend/tds/tdstimestamp.c b/contrib/babelfishpg_tds/src/backend/tds/tdstimestamp.c index ff880b19b8..8ff3cb7f90 100644 --- a/contrib/babelfishpg_tds/src/backend/tds/tdstimestamp.c +++ b/contrib/babelfishpg_tds/src/backend/tds/tdstimestamp.c @@ -15,6 +15,7 @@ */ #include "postgres.h" +#include "utils/builtins.h" /* for pg_ultostr_zeropad() */ #include "utils/datetime.h" #include "src/include/tds_timestamp.h" @@ -378,7 +379,8 @@ GetDatetimeFromDaysTicks(uint32 numDays, uint32 numTicks, CalculateTargetDate(y1, &d2, &m2, &y2, numDays); Assert((int) numTicks >= 0); - numMilli = (int) (3.33333333 * numTicks); + /* add 0.5 before casting to int to round the result up */ + numMilli = (int) ((3.33333333 * numTicks) + 0.5); *fsec = (numMilli % 1000) * 1000; numMilli /= 1000; @@ -551,3 +553,197 @@ TdsGetTimestampFromDayTime(uint32 numDays, uint64 numMicro, int tz, (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), errmsg("timestamp out of range"))); } + +char* +TdsTimeGetDateAsString(Datum value) +{ + struct pg_tm ti, + *tm = &ti; + char *result; + + memset(tm, '\0', sizeof(struct pg_tm)); + GetDateFromDatum(value, tm); + /* + * Adjust the timestamp converting it from Postgres' datetime where tm_mon + * is counted from 1 and tm_year is relative to 1 BCE to POSIX datetime + * where tm_mon counts from 0 and tm_year is relative to 1900. + */ + tm->tm_year -= 1900; + tm->tm_mon -= 1; + + result = palloc(10 + 1); + if (!pg_strftime(result, 10 + 1, "%Y-%m-%d", tm)) + ereport(ERROR, + (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), + errmsg("date out of range"))); + + return result; +} + +/* + * Appends fractional seconds to specified str with a specified scale. + * + * Takes NULL-terminated string and appends (scale + 1) characters to it and + * a NULL terminator. Does not modify input buf if scale is 0. + */ +static void +AppendFractionalSeconds(char *st, fsec_t fsec, int scale) +{ + int value, + oldval, + remainder, + idx; + char buf[MAX_TIMESTAMP_PRECISION], + *cp; + + if (scale <= 0) + return; + + cp = st + (size_t) strlen(st); + *cp++ = '.'; + value = abs(fsec); + + for (idx = sizeof(buf) - 1; idx >= 0; idx--) + { + if (value > 0) + { + oldval = value; + value /= 10; + remainder = oldval - value * 10; + buf[idx] = '0' + remainder; + } + else + buf[idx] = '0'; + } + + for (idx = 0; idx < scale; idx++) + { + if (idx < sizeof(buf)) + *cp++ = buf[idx]; + else + *cp++ = '0'; + } + + *cp++ = '\0'; +} + +char* +TdsTimeGetTimeAsString(TimeADT value, int scale) +{ + struct pg_tm tt, + *tm = &tt; + fsec_t fsec; + char *buf; + + memset(tm, '\0', sizeof(struct pg_tm)); + time2tm(value, tm, &fsec); + + buf = palloc0(16 + 1); + if (!pg_strftime(buf, 10 + 1, "%H:%M:%S", tm)) + ereport(ERROR, + (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), + errmsg("date out of range"))); + + AppendFractionalSeconds(buf, fsec, scale); + + return buf; +} + +char* +TdsTimeGetDatetime2AsString(Timestamp value, int scale) +{ + struct pg_tm tt, + *tm = &tt; + fsec_t fsec; + char *buf; + + memset(tm, '\0', sizeof(struct pg_tm)); + if (TIMESTAMP_NOT_FINITE(value) || + timestamp2tm(value, NULL, tm, &fsec, NULL, NULL) != 0) + ereport(ERROR, + (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), + errmsg("timestamp out of range"))); + + /* + * Adjust the timestamp converting it from Postgres' datetime where tm_mon + * is counted from 1 and tm_year is relative to 1 BCE to POSIX datetime + * where tm_mon counts from 0 and tm_year is relative to 1900. + */ + tm->tm_year -= 1900; + tm->tm_mon -= 1; + + buf = palloc0(27 + 1); + if (!pg_strftime(buf, 19 + 1, "%Y-%m-%d %H:%M:%S", tm)) + ereport(ERROR, + (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), + errmsg("date out of range"))); + + AppendFractionalSeconds(buf, fsec, scale); + + return buf; +} + +/* + * Appends representation of a numeric timezone offset to str. + * + * Takes NULL-terminated string and appends 7 characters to it and + * a NULL terminator. + */ +static void +AppendTimezone(char *st, int tz) +{ + int hour, + min; + char *cp; + + cp = st + (size_t) strlen(st); + + min = abs(tz); + hour = min / MINS_PER_HOUR; + min -= hour * MINS_PER_HOUR; + + *cp++ = ' '; + /* TZ is negated compared to sign we wish to display ... */ + *cp++ = (tz <= 0 ? '+' : '-'); + + cp = pg_ultostr_zeropad(cp, hour, 2); + *cp++ = ':'; + cp = pg_ultostr_zeropad(cp, min, 2); + + *cp++ = '\0'; +} + +char* +TdsTimeGetDatetimeoffsetAsString(tsql_datetimeoffset *value, int scale) +{ + struct pg_tm tt, + *tm = &tt; + fsec_t fsec; + char *buf; + + memset(tm, '\0', sizeof(struct pg_tm)); + if (TIMESTAMP_NOT_FINITE(value->tsql_ts) || + timestamp2tm(value->tsql_ts, NULL, tm, &fsec, NULL, NULL) != 0) + ereport(ERROR, + (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), + errmsg("datetimeoffset out of range"))); + + /* + * Adjust the timestamp converting it from Postgres' datetime where tm_mon + * is counted from 1 and tm_year is relative to 1 BCE to POSIX datetime + * where tm_mon counts from 0 and tm_year is relative to 1900. + */ + tm->tm_year -= 1900; + tm->tm_mon -= 1; + + buf = palloc0(34 + 1); + if (!pg_strftime(buf, 19 + 1, "%Y-%m-%d %H:%M:%S", tm)) + ereport(ERROR, + (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), + errmsg("datetimeoffset out of range"))); + + AppendFractionalSeconds(buf, fsec, scale); + AppendTimezone(buf, value->tsql_tz); + + return buf; +} \ No newline at end of file diff --git a/contrib/babelfishpg_tds/src/backend/tds/tdstypeio.c b/contrib/babelfishpg_tds/src/backend/tds/tdstypeio.c index b03a7f394b..fe24674805 100644 --- a/contrib/babelfishpg_tds/src/backend/tds/tdstypeio.c +++ b/contrib/babelfishpg_tds/src/backend/tds/tdstypeio.c @@ -28,6 +28,7 @@ #include "miscadmin.h" #include "parser/scansup.h" #include "utils/cash.h" +#include "utils/datetime.h" #include "utils/hsearch.h" #include "utils/builtins.h" /* for format_type_be() */ #include "utils/guc.h" @@ -2775,9 +2776,18 @@ TdsSendTypeVarchar(FmgrInfo *finfo, Datum value, void *vMetaData) * store given string in given encoding. */ maxLen; /* max size of given column in bytes */ char *destBuf, - *buf = OutputFunctionCall(finfo, value); + *buf; TdsColumnMetaData *col = (TdsColumnMetaData *) vMetaData; + /* + * If client being connected is using TDS version lower than or equal to + * 7.1 then TSQL treats varchar(max) as Text. + */ + if (GetClientTDSVersion() <= TDS_VERSION_7_1_1 && + col->metaEntry.type3.tdsTypeId == TDS_TYPE_TEXT) + return TdsSendTypeText(finfo, value, vMetaData); + + buf = OutputFunctionCall(finfo, value); len = strlen(buf); destBuf = TdsEncodingConversion(buf, len, PG_UTF8, col->encoding, &actualLen); @@ -2835,11 +2845,21 @@ TdsSendTypeVarbinary(FmgrInfo *finfo, Datum value, void *vMetaData) int rc = EOF, len = 0, maxlen = 0; - bytea *vlena = DatumGetByteaPCopy(value); - char *buf = VARDATA_ANY(vlena); + bytea *vlena; + char *buf; TdsColumnMetaData *col = (TdsColumnMetaData *) vMetaData; + /* + * If client being connected is using TDS version lower than or equal to + * 7.1 then TSQL treats varbinary(max) as Image. + */ + if (GetClientTDSVersion() <= TDS_VERSION_7_1_1 && + col->metaEntry.type8.tdsTypeId == TDS_TYPE_IMAGE) + return TdsSendTypeImage(finfo, value, vMetaData); + maxlen = col->metaEntry.type7.maxSize; + vlena = DatumGetByteaPCopy(value); + buf = VARDATA_ANY(vlena); len = VARSIZE_ANY_EXHDR(vlena); if (maxlen != 0xffff) @@ -2957,10 +2977,19 @@ TdsSendTypeNVarchar(FmgrInfo *finfo, Datum value, void *vMetaData) int rc, maxlen; - char *out = OutputFunctionCall(finfo, value); + char *out; TdsColumnMetaData *col = (TdsColumnMetaData *) vMetaData; StringInfoData buf; + /* + * If client being connected is using TDS version lower than or equal to + * 7.1 then TSQL treats nvarchar(max) as NText. + */ + if (GetClientTDSVersion() <= TDS_VERSION_7_1_1 && + col->metaEntry.type3.tdsTypeId == TDS_TYPE_NTEXT) + return TdsSendTypeNText(finfo, value, vMetaData); + + out = OutputFunctionCall(finfo, value); initStringInfo(&buf); TdsUTF8toUTF16StringInfo(&buf, out, strlen(out)); maxlen = col->metaEntry.type2.maxSize; @@ -3309,6 +3338,33 @@ TdsSendTypeUniqueIdentifier(FmgrInfo *finfo, Datum value, void *vMetaData) return rc; } +static int +TdsSendTimeAsNVarcharHelper(FmgrInfo *finfo, Datum value, void *vMetaData) +{ + int rc, + scale; + char *st; + TdsColumnMetaData *col; + StringInfoData buf; + + col = (TdsColumnMetaData *) vMetaData; + scale = (int) col->atttypmod; + if (scale < 0) + scale = MAX_TIMESTAMP_PRECISION + 1; + + st = TdsTimeGetTimeAsString((TimeADT) value, scale); + + initStringInfo(&buf); + TdsUTF8toUTF16StringInfo(&buf, st, strlen(st)); + pfree(st); + + if ((rc = TdsPutInt16LE(buf.len)) == 0) + TdsPutbytes(buf.data, buf.len); + + pfree(buf.data); + return rc; +} + int TdsSendTypeTime(FmgrInfo *finfo, Datum value, void *vMetaData) { @@ -3325,7 +3381,7 @@ TdsSendTypeTime(FmgrInfo *finfo, Datum value, void *vMetaData) * If client being connected is using TDS version lower than 7.3A then * TSQL treats TIME as NVARCHAR. */ - return TdsSendTypeNVarchar(finfo, value, vMetaData); + return TdsSendTimeAsNVarcharHelper(finfo, value, vMetaData); scale = col->metaEntry.type6.scale; @@ -3355,6 +3411,33 @@ TdsSendTypeTime(FmgrInfo *finfo, Datum value, void *vMetaData) return rc; } +static int +TdsSendDatetime2AsNVarcharHelper(FmgrInfo *finfo, Datum value, void *vMetaData) +{ + int rc, + scale; + char *st; + TdsColumnMetaData *col; + StringInfoData buf; + + col = (TdsColumnMetaData *) vMetaData; + scale = (int) col->atttypmod; + if (scale < 0) + scale = MAX_TIMESTAMP_PRECISION + 1; + + st = TdsTimeGetDatetime2AsString((Timestamp) value, scale); + + initStringInfo(&buf); + TdsUTF8toUTF16StringInfo(&buf, st, strlen(st)); + pfree(st); + + if ((rc = TdsPutInt16LE(buf.len)) == 0) + TdsPutbytes(buf.data, buf.len); + + pfree(buf.data); + return rc; +} + int TdsSendTypeDatetime2(FmgrInfo *finfo, Datum value, void *vMetaData) { @@ -3371,7 +3454,7 @@ TdsSendTypeDatetime2(FmgrInfo *finfo, Datum value, void *vMetaData) * If client being connected is using TDS version lower than 7.3A then * TSQL treats DATETIME2 as NVARCHAR. */ - return TdsSendTypeNVarchar(finfo, value, vMetaData); + return TdsSendDatetime2AsNVarcharHelper(finfo, value, vMetaData); scale = col->metaEntry.type6.scale; @@ -3772,6 +3855,48 @@ TdsTypeSqlVariantToDatum(StringInfo buf) PG_RETURN_BYTEA_P(result); } +/* + * dataformat: totalLen(4B) + baseType(1B) + metadatalen(1B) + + * encodingLen(5B) + dataLen(2B) + data(dataLen) + */ +static int +TdsSendTypeSqlvariantAsNVarcharHelper(const char *st) +{ + int rc = EOF, + totalLen = 0; + StringInfoData strbuf; + int actualDataLen = 0; /* Number of bytes that would be + * needed to store given string in + * given encoding. */ + + initStringInfo(&strbuf); + TdsUTF8toUTF16StringInfo(&strbuf, st, strlen(st)); + + actualDataLen = strbuf.len; + totalLen = actualDataLen + VARIANT_TYPE_METALEN_FOR_CHAR_DATATYPES; + + rc = TdsPutUInt32LE(totalLen); + rc |= TdsPutInt8(VARIANT_TYPE_NVARCHAR); + rc |= TdsPutInt8(VARIANT_TYPE_BASE_METALEN_FOR_CHAR_DATATYPES); + + /* + * 5B of fixed collation TODO: [BABEL-1069] Remove collation related + * hardcoding from sql_variant sender for char class basetypes + */ + rc |= TdsPutInt8(9); + rc |= TdsPutInt8(4); + rc |= TdsPutInt8(208); + rc |= TdsPutInt8(0); + rc |= TdsPutInt8(52); + + rc |= TdsPutUInt16LE(actualDataLen); + + rc |= TdsPutbytes(strbuf.data, actualDataLen); + pfree(strbuf.data); + + return rc; +} + int TdsSendTypeSqlvariant(FmgrInfo *finfo, Datum value, void *vMetaData) { @@ -3785,7 +3910,10 @@ TdsSendTypeSqlvariant(FmgrInfo *finfo, Datum value, void *vMetaData) bytea *vlena = DatumGetByteaPCopy(value); char *buf = VARDATA(vlena), *decString = NULL, - *out = NULL; + *out = NULL, + *dateStr = NULL, + *timeStr = NULL, + *datetime2Str = NULL; bool isBaseNum = false, isBaseChar = false; bool isBaseBin = false, @@ -3985,22 +4113,36 @@ TdsSendTypeSqlvariant(FmgrInfo *finfo, Datum value, void *vMetaData) } else if (isBaseDate) { - /* - * dataformat : totalLen(4B) + baseType(1B) + metadatalen(1B) + - * data(3B) - */ if (variantBaseType == VARIANT_TYPE_DATE) { memset(&dateval, 0, sizeof(dateval)); memcpy(&dateval, buf, sizeof(dateval)); - numDays = TdsDayDifference(dateval); - dataLen = 3; - totalLen = dataLen + VARIANT_TYPE_METALEN_FOR_DATE; - rc = TdsPutUInt32LE(totalLen); - rc |= TdsPutInt8(variantBaseType); - rc |= TdsPutInt8(VARIANT_TYPE_BASE_METALEN_FOR_DATE); - rc |= TdsPutDate(numDays); + + if (GetClientTDSVersion() <= TDS_VERSION_7_2) + { + /* + * DATENTYPE type was introduced in TDS 7.3, with earlier protocol + * versions date is sent as NVARCHARTYPE. + */ + dateStr = TdsTimeGetDateAsString(dateval); + rc = TdsSendTypeSqlvariantAsNVarcharHelper(dateStr); + pfree(dateStr); + } + else + { + /* + * dataformat : totalLen(4B) + baseType(1B) + metadatalen(1B) + + * data(3B) + */ + numDays = TdsDayDifference(dateval); + dataLen = 3; + totalLen = dataLen + VARIANT_TYPE_METALEN_FOR_DATE; + rc = TdsPutUInt32LE(totalLen); + rc |= TdsPutInt8(variantBaseType); + rc |= TdsPutInt8(VARIANT_TYPE_BASE_METALEN_FOR_DATE); + rc |= TdsPutDate(numDays); + } } /* @@ -4038,64 +4180,92 @@ TdsSendTypeSqlvariant(FmgrInfo *finfo, Datum value, void *vMetaData) } else if (variantBaseType == VARIANT_TYPE_TIME) { - /* - * dataformat : totalLen(4B) + baseType(1B) + metadatalen(1B) + - * scale(1B) + data(3B-5B) - */ + memcpy(&numMicro, buf, sizeof(numMicro)); + if (scale == 0xff || scale < 0 || scale > 7) scale = DATETIMEOFFSETMAXSCALE; - if (scale >= 0 && scale < 3) - dataLen = 3; - else if (scale >= 3 && scale < 5) - dataLen = 4; - else if (scale >= 5 && scale <= 7) - dataLen = 5; - - memcpy(&numMicro, buf, sizeof(numMicro)); - temp = scale; - if (scale == 7 || scale == 0xff) - numMicro *= 10; - - while (temp < 6) + if (GetClientTDSVersion() <= TDS_VERSION_7_2) { - numMicro /= 10; - temp++; + /* + * TIMENTYPE type was introduced in TDS 7.3, with earlier protocol + * versions time is sent as NVARCHARTYPE. + */ + timeStr = TdsTimeGetTimeAsString((TimeADT) numMicro, scale); + rc = TdsSendTypeSqlvariantAsNVarcharHelper(timeStr); + pfree(timeStr); + } + else + { + /* + * dataformat : totalLen(4B) + baseType(1B) + metadatalen(1B) + + * scale(1B) + data(3B-5B) + */ + if (scale >= 0 && scale < 3) + dataLen = 3; + else if (scale >= 3 && scale < 5) + dataLen = 4; + else if (scale >= 5 && scale <= 7) + dataLen = 5; + + temp = scale; + if (scale == 7 || scale == 0xff) + numMicro *= 10; + + while (temp < 6) + { + numMicro /= 10; + temp++; + } + totalLen = dataLen + VARIANT_TYPE_METALEN_FOR_TIME; + rc = TdsPutUInt32LE(totalLen); + rc |= TdsPutInt8(variantBaseType); + rc |= TdsPutInt8(VARIANT_TYPE_BASE_METALEN_FOR_TIME); + rc |= TdsPutInt8(scale); + rc = TdsPutbytes(&numMicro, dataLen); } - totalLen = dataLen + VARIANT_TYPE_METALEN_FOR_TIME; - rc = TdsPutUInt32LE(totalLen); - rc |= TdsPutInt8(variantBaseType); - rc |= TdsPutInt8(VARIANT_TYPE_BASE_METALEN_FOR_TIME); - rc |= TdsPutInt8(scale); - rc = TdsPutbytes(&numMicro, dataLen); } else if (variantBaseType == VARIANT_TYPE_DATETIME2) { - /* - * dataformat : totalLen(4B) + baseType(1B) + metadatalen(1B) + - * scale(1B) + data(6B-8B) - */ + memcpy(×tamp, buf, sizeof(timestamp)); + if (scale == 0xff || scale < 0 || scale > 7) scale = DATETIMEOFFSETMAXSCALE; - if (scale >= 0 && scale < 3) - dataLen = 6; - else if (scale >= 3 && scale < 5) - dataLen = 7; - else if (scale >= 5 && scale <= 7) - dataLen = 8; - - memcpy(×tamp, buf, sizeof(timestamp)); - TdsGetDayTimeFromTimestamp((Timestamp) timestamp, &numDays, - &numMicro, scale); - - totalLen = dataLen + VARIANT_TYPE_METALEN_FOR_DATETIME2; - rc = TdsPutUInt32LE(totalLen); - rc |= TdsPutInt8(variantBaseType); - rc |= TdsPutInt8(VARIANT_TYPE_BASE_METALEN_FOR_DATETIME2); - rc |= TdsPutInt8(scale); - rc |= TdsPutbytes(&numMicro, dataLen - 3); - rc |= TdsPutDate(numDays); + if (GetClientTDSVersion() <= TDS_VERSION_7_2) + { + /* + * DATETIME2NTYPE type was introduced in TDS 7.3, with earlier protocol + * versions datetime2 is sent as NVARCHARTYPE. + */ + datetime2Str = TdsTimeGetDatetime2AsString(timestamp, scale); + rc = TdsSendTypeSqlvariantAsNVarcharHelper(datetime2Str); + pfree(datetime2Str); + } + else + { + /* + * dataformat : totalLen(4B) + baseType(1B) + metadatalen(1B) + + * scale(1B) + data(6B-8B) + */ + if (scale >= 0 && scale < 3) + dataLen = 6; + else if (scale >= 3 && scale < 5) + dataLen = 7; + else if (scale >= 5 && scale <= 7) + dataLen = 8; + + TdsGetDayTimeFromTimestamp((Timestamp) timestamp, &numDays, + &numMicro, scale); + + totalLen = dataLen + VARIANT_TYPE_METALEN_FOR_DATETIME2; + rc = TdsPutUInt32LE(totalLen); + rc |= TdsPutInt8(variantBaseType); + rc |= TdsPutInt8(VARIANT_TYPE_BASE_METALEN_FOR_DATETIME2); + rc |= TdsPutInt8(scale); + rc |= TdsPutbytes(&numMicro, dataLen - 3); + rc |= TdsPutDate(numDays); + } } else if (variantBaseType == VARIANT_TYPE_DATETIMEOFFSET) { @@ -4155,6 +4325,33 @@ TdsRecvTypeDatetimeoffset(const char *message, const ParameterToken token) return result; } +static int +TdsSendDatetimeoffsetAsNVarcharHelper(FmgrInfo *finfo, Datum value, void *vMetaData) +{ + int rc, + scale; + char *st; + TdsColumnMetaData *col; + StringInfoData buf; + + col = (TdsColumnMetaData *) vMetaData; + scale = (int) col->atttypmod; + if (scale < 0) + scale = MAX_TIMESTAMP_PRECISION + 1; + + st = TdsTimeGetDatetimeoffsetAsString((tsql_datetimeoffset *) value, scale); + + initStringInfo(&buf); + TdsUTF8toUTF16StringInfo(&buf, st, strlen(st)); + pfree(st); + + if ((rc = TdsPutInt16LE(buf.len)) == 0) + TdsPutbytes(buf.data, buf.len); + + pfree(buf.data); + return rc; +} + int TdsSendTypeDatetimeoffset(FmgrInfo *finfo, Datum value, void *vMetaData) { @@ -4175,7 +4372,7 @@ TdsSendTypeDatetimeoffset(FmgrInfo *finfo, Datum value, void *vMetaData) * If client being connected is using TDS version lower than 7.3A then * TSQL treats DATETIMEOFFSET as NVARCHAR. */ - return TdsSendTypeNVarchar(finfo, value, vMetaData); + return TdsSendDatetimeoffsetAsNVarcharHelper(finfo, value, vMetaData); TDSInstrumentation(INSTR_TDS_DATATYPE_DATETIME_OFFSET); diff --git a/contrib/babelfishpg_tds/src/include/tds_response.h b/contrib/babelfishpg_tds/src/include/tds_response.h index 698b52fa20..89dbe8c6d2 100644 --- a/contrib/babelfishpg_tds/src/include/tds_response.h +++ b/contrib/babelfishpg_tds/src/include/tds_response.h @@ -75,6 +75,7 @@ extern void PrepareRowDescription(TupleDesc typeinfo, PlannedStmt *plannedstmt, extern void SendReturnValueTokenInternal(ParameterToken token, uint8 status, FmgrInfo *finfo, Datum datum, bool isNull, bool forceCoercion); +extern void SendReturnValueIntInternal(uint8 status, int32 value); extern void TdsSendEnvChange(int envid, const char *new_val, const char *old_val); extern void TdsSendInfoOrError(int token, int number, int state, int class, char *message, char *server_name, diff --git a/contrib/babelfishpg_tds/src/include/tds_timestamp.h b/contrib/babelfishpg_tds/src/include/tds_timestamp.h index 1508e58ae2..c10448cb73 100644 --- a/contrib/babelfishpg_tds/src/include/tds_timestamp.h +++ b/contrib/babelfishpg_tds/src/include/tds_timestamp.h @@ -33,6 +33,9 @@ extern void TdsTimeGetDatumFromDays(uint32 numDays, uint64 *val); extern void TdsTimeGetDatumFromDatetime(uint32 numDays, uint32 numTicks, Timestamp *timestamp); extern uint32 TdsGetDayDifferenceHelper(int day, int mon, int year, bool isDateType); +extern char* TdsTimeGetDateAsString(Datum value); +extern char* TdsTimeGetTimeAsString(TimeADT value, int scale); +extern char* TdsTimeGetDatetime2AsString(Timestamp value, int scale); /* * structure for datatimeoffset support with separate time zone field @@ -43,6 +46,8 @@ typedef struct tsql_datetimeoffset int16 tsql_tz; } tsql_datetimeoffset; +extern char* TdsTimeGetDatetimeoffsetAsString(tsql_datetimeoffset *value, int scale); + /* datetimeoffset macros */ #define DATETIMEOFFSET_LEN MAXALIGN(sizeof(tsql_datetimeoffset)) /* datetimeoffset default value in internal representation */ diff --git a/contrib/babelfishpg_tds/src/include/tds_typeio.h b/contrib/babelfishpg_tds/src/include/tds_typeio.h index da293399bf..660840bc8c 100644 --- a/contrib/babelfishpg_tds/src/include/tds_typeio.h +++ b/contrib/babelfishpg_tds/src/include/tds_typeio.h @@ -195,6 +195,7 @@ typedef struct TdsColumnMetaData * an expression column */ AttrNumber attrNum; /* attribute number in the relation */ TdsRelationMetaDataInfo relinfo; + int32 atttypmod; /* type-specific data supplied at table creation time */ bool attNotNull; /* true if the column has not null constraint */ bool attidentity; /* true if it is an identity column */ bool attgenerated; /* true if it is a computed column */ diff --git a/contrib/babelfishpg_tsql/src/cursor.c b/contrib/babelfishpg_tsql/src/cursor.c index e79d8d1b8d..ede125e7cd 100644 --- a/contrib/babelfishpg_tsql/src/cursor.c +++ b/contrib/babelfishpg_tsql/src/cursor.c @@ -47,6 +47,8 @@ void enable_sp_cursor_find_param_hook(void); void disable_sp_cursor_find_param_hook(void); void add_sp_cursor_param(char *name); void reset_sp_cursor_params(void); +InlineCodeBlockArgs *create_args(int numargs); +void read_param_def(InlineCodeBlockArgs *args, const char *paramdefstr); /* cursor information hashtab */ typedef struct cursorhashent @@ -57,6 +59,7 @@ typedef struct cursorhashent int16 fetch_status; int16 last_operation; uint64 row_count; + int64 fetch_info_rownum; int32 cursor_handle; bool api_cursor; /* only used in cursor_list now. can be * deprecated once we supprot global cursor */ @@ -85,6 +88,7 @@ void pltsql_delete_cursor_entry(char *curname, bool missing_ok); void pltsql_get_cursor_definition(char *curname, PLtsql_expr **explicit_expr, int *cursor_options); void pltsql_update_cursor_fetch_status(char *curname, int fetch_status); void pltsql_update_cursor_row_count(char *curname, int64 row_count); +void pltsql_update_cursor_fetch_info_rownum(char *curname, int64 rownum); void pltsql_update_cursor_last_operation(char *curname, int last_operation); static const char *LOCAL_CURSOR_INFIX = "##sys_gen##"; @@ -503,6 +507,7 @@ pltsql_insert_cursor_entry(char *curname, PLtsql_expr *explicit_expr, int cursor hentry->cursor_options = cursor_options; hentry->fetch_status = -9; hentry->row_count = 0; + hentry->fetch_info_rownum = 0; hentry->last_operation = 0; if (cursor_handle) /* use given cursor_handle. mostly api cursor */ hentry->cursor_handle = *cursor_handle; @@ -584,6 +589,16 @@ pltsql_update_cursor_row_count(char *curname, int64 row_count) hentry->row_count = row_count; } +void +pltsql_update_cursor_fetch_info_rownum(char *curname, int64 rownum) +{ + CursorHashEnt *hentry; + + hentry = (CursorHashEnt *) hash_search(CursorHashTable, curname, HASH_FIND, NULL); + if (hentry) + hentry->fetch_info_rownum = rownum; +} + void pltsql_update_cursor_last_operation(char *curname, int last_operation) { @@ -1086,11 +1101,29 @@ execute_sp_cursoropen_old(int *cursor_handle, const char *stmt, int *pscrollopt, return execute_sp_cursoropen_common(NULL, cursor_handle, stmt, pscrollopt, pccopt, row_count, nparams, 0, NULL, values, nulls, true /* prepare */ , false /* save_plan */ , true /* execute */ ); } +/* + * Either nBindParams + boundParamsOidList or raw paramDef string can be passed by the caller. + */ int -execute_sp_cursorprepare(int *stmt_handle, const char *stmt, int options, int *pscrollopt, int *pccopt, int nBindParams, Oid *boundParamsOidList) +execute_sp_cursorprepare(int *stmt_handle, const char *stmt, int options, int *pscrollopt, int *pccopt, int nBindParams, Oid *boundParamsOidList, const char* paramDef) { /* TODO: options handling */ - return execute_sp_cursoropen_common(stmt_handle, NULL, stmt, pscrollopt, pccopt, NULL, 0, nBindParams, boundParamsOidList, NULL, NULL, true /* prepare */ , true /* save_plan */ , false /* execute */ ); + InlineCodeBlockArgs *args; + int nBindParamsPass; + Oid *boundParamsOidListPass; + + if (paramDef) + { + args = create_args(0); + read_param_def(args, paramDef); + nBindParamsPass = args->numargs; + boundParamsOidListPass = args->argtypes; + } else { + nBindParamsPass = nBindParams; + boundParamsOidListPass = boundParamsOidList; + } + + return execute_sp_cursoropen_common(stmt_handle, NULL, stmt, pscrollopt, pccopt, NULL, 0, nBindParamsPass, boundParamsOidListPass, NULL, NULL, true /* prepare */ , true /* save_plan */ , false /* execute */ ); } int @@ -1153,6 +1186,7 @@ execute_sp_cursorfetch(int cursor_handle, int *pfetchtype, int *prownum, int *pn int fetchtype; int rownum; int nrows; + int64 fetch_info_rownum; DestReceiver *receiver; TupleTableSlot *slot; int rno; @@ -1224,56 +1258,90 @@ execute_sp_cursorfetch(int cursor_handle, int *pfetchtype, int *prownum, int *pn /* fetch in forward direction */ SPI_scroll_cursor_fetch_dest(portal, FETCH_FORWARD, nrows, CreateDestReceiver(DestSPI)); break; + case SP_CURSOR_FETCH_INFO: + /* return fetch_info_rownum saved during the last fetch */ + if (hentry->fetch_info_rownum > INT_MAX) + elog(ERROR, "fetch_info_rownum overflow: %ld", hentry->fetch_info_rownum); + *prownum = (int) hentry->fetch_info_rownum; + /* number of rows in cursor is not available in PG */ + *pnrows = -1; + break; case SP_CURSOR_FETCH_RELATIVE: case SP_CURSOR_FETCH_REFRESH: - case SP_CURSOR_FETCH_INFO: case SP_CURSOR_FETCH_PREV_NOADJUST: case SP_CURSOR_FETCH_SKIP_UPDT_CNCY: default: Assert(0); } - if (SPI_result != 0) - elog(ERROR, "error in SPI_scroll_cursor_fetch: %d", SPI_result); - - /* - * In case of FETCH_FIRST/FETCH_LAST with 0 nrows, we just moved cursor - * and no actual fetch is called. SPI_tuptable can be NULL. skip storing - * the result - */ - if (SPI_tuptable) + if (fetchtype != SP_CURSOR_FETCH_INFO) { - /* store result in fetch buffer */ - tuplestore_clear(hentry->fetch_buffer); + if (SPI_result != 0) + elog(ERROR, "error in SPI_scroll_cursor_fetch: %d", SPI_result); - oldcontext = MemoryContextSwitchTo(CursorHashtabContext); - for (rno = 0; rno < SPI_processed; ++rno) - tuplestore_puttuple(hentry->fetch_buffer, SPI_tuptable->vals[rno]); - MemoryContextSwitchTo(oldcontext); + /* + * In case of FETCH_FIRST/FETCH_LAST with 0 nrows, we just moved cursor + * and no actual fetch is called. SPI_tuptable can be NULL. skip storing + * the result + */ + if (SPI_tuptable) + { + /* store result in fetch buffer */ + tuplestore_clear(hentry->fetch_buffer); - tuplestore_rescan(hentry->fetch_buffer); + oldcontext = MemoryContextSwitchTo(CursorHashtabContext); + for (rno = 0; rno < SPI_processed; ++rno) + tuplestore_puttuple(hentry->fetch_buffer, SPI_tuptable->vals[rno]); + MemoryContextSwitchTo(oldcontext); - /* send result to DestRemote */ - receiver = CreateDestReceiver(DestRemote); - SetRemoteDestReceiverParams(receiver, portal); + tuplestore_rescan(hentry->fetch_buffer); - slot = MakeSingleTupleTableSlot(hentry->tupdesc, &TTSOpsMinimalTuple); - receiver->rStartup(receiver, (int) CMD_SELECT, hentry->tupdesc); - while (tuplestore_gettupleslot(hentry->fetch_buffer, true, false, slot)) - receiver->receiveSlot(slot, receiver); - receiver->rShutdown(receiver); - } + /* send result to DestRemote */ + receiver = CreateDestReceiver(DestRemote); + SetRemoteDestReceiverParams(receiver, portal); - /* update cursor status */ - pltsql_update_cursor_fetch_status(curname, SPI_processed == 0 ? -1 : 0); - pltsql_update_cursor_row_count(curname, SPI_processed); - pltsql_update_cursor_last_operation(curname, 2); + slot = MakeSingleTupleTableSlot(hentry->tupdesc, &TTSOpsMinimalTuple); + receiver->rStartup(receiver, (int) CMD_SELECT, hentry->tupdesc); + while (tuplestore_gettupleslot(hentry->fetch_buffer, true, false, slot)) + receiver->receiveSlot(slot, receiver); + receiver->rShutdown(receiver); + } - /* If AUTO_CLOSE is set and we fetched all the result, close the cursor */ - if ((hentry->cursor_options & TSQL_CURSOR_OPT_AUTO_CLOSE) && - portal->atEnd) - { - execute_sp_cursorclose(cursor_handle); + /* + * Calculate rownum value for possible subsequent FETCH_INFO calls. + * + * SPI_scroll_cursor_fetch_dest call above has just read an + * SPI_processed number of rows from portal and has sent these rows + * to client. If FETCH_INFO call will follow, we will need to return + * the 1-based portal index of the first row of all rows that were sent + * to client. + * + * If no rows were read by last SPI_scroll_cursor_fetch_dest call: + * if cursor is not open: 0 (currently not supported), + * if cursor is positioned before the result set: 0, + * if cursor is positioned after the result set: -1. + */ + if (SPI_processed > 0) + fetch_info_rownum = portal->portalPos - SPI_processed + 1; + else if (portal->atEnd) + fetch_info_rownum = -1; + else if (portal->atStart) + fetch_info_rownum = 0; + else + fetch_info_rownum = portal->portalPos + 1; + + /* update cursor status */ + pltsql_update_cursor_fetch_status(curname, SPI_processed == 0 ? -1 : 0); + pltsql_update_cursor_row_count(curname, SPI_processed); + pltsql_update_cursor_fetch_info_rownum(curname, fetch_info_rownum); + pltsql_update_cursor_last_operation(curname, 2); + + /* If AUTO_CLOSE is set and we fetched all the result, close the cursor */ + if ((hentry->cursor_options & TSQL_CURSOR_OPT_AUTO_CLOSE) && + portal->atEnd) + { + execute_sp_cursorclose(cursor_handle); + } } if ((rc = SPI_finish()) != SPI_OK_FINISH) @@ -1419,6 +1487,7 @@ execute_sp_cursorclose(int cursor_handle) SPI_cursor_close(portal); pltsql_update_cursor_row_count(curname, 0); + pltsql_update_cursor_fetch_info_rownum(curname, 0); pltsql_update_cursor_last_operation(curname, 6); pltsql_delete_cursor_entry(curname, false); @@ -1681,6 +1750,7 @@ validate_and_get_sp_cursorfetch_params(int *fetchtype_in, int *rownum_in, int *n case SP_CURSOR_FETCH_PREV: case SP_CURSOR_FETCH_LAST: case SP_CURSOR_FETCH_ABSOLUTE: + case SP_CURSOR_FETCH_INFO: break; /* @@ -1691,7 +1761,6 @@ validate_and_get_sp_cursorfetch_params(int *fetchtype_in, int *rownum_in, int *n */ case SP_CURSOR_FETCH_RELATIVE: case SP_CURSOR_FETCH_REFRESH: - case SP_CURSOR_FETCH_INFO: case SP_CURSOR_FETCH_PREV_NOADJUST: case SP_CURSOR_FETCH_SKIP_UPDT_CNCY: elog(ERROR, "cursor fetch type %X not supported", *fetchtype_in); diff --git a/contrib/babelfishpg_tsql/src/pl_exec-2.c b/contrib/babelfishpg_tsql/src/pl_exec-2.c index 1c20406f1c..feebd325b3 100644 --- a/contrib/babelfishpg_tsql/src/pl_exec-2.c +++ b/contrib/babelfishpg_tsql/src/pl_exec-2.c @@ -1950,7 +1950,7 @@ exec_stmt_exec_sp(PLtsql_execstate *estate, PLtsql_stmt_exec_sp *stmt) options, (scrollopt_null ? NULL : &scrollopt), (ccopt_null ? NULL : &ccopt), - args->numargs, args->argtypes); + args->numargs, args->argtypes, NULL); } PG_CATCH(); { @@ -2505,6 +2505,28 @@ is_char_identpart(char c) (c >= '0' && c <= '9')); } +static List * +rewrite_decimal_names_to_numeric(List *name_list) +{ + Node *name_node; + char *name_str; + String *numeric_string; + + if(list_length(name_list) != 1) + return name_list; + + name_node = (Node *) linitial(name_list); + name_str = strVal(name_node); + if (!strcmp("decimal", name_str)) + { + numeric_string = makeString("numeric"); + name_list = list_delete_first(name_list); + name_list = lcons(numeric_string, name_list); + } + + return name_list; +} + /* * Read parameter definitions */ @@ -2575,6 +2597,13 @@ read_param_def(InlineCodeBlockArgs *args, const char *paramdefstr) * error will be thrown in the parser itself. */ p->argType->names = rewrite_plain_name(p->argType->names); + /* + * Typemod is ignored for decimal columns that can make input values + * to be inserted with incorrect scale. Rewriting "decimal" to + * "numeric" in paramdefs to look up numeric typeId instead of decimal. + * See issue gh-2678 for details. + */ + p->argType->names = rewrite_decimal_names_to_numeric(p->argType->names); typenameTypeIdAndMod(NULL, p->argType, &(args->argtypes[i]), &(args->argtypmods[i])); i++; diff --git a/contrib/babelfishpg_tsql/src/pltsql.h b/contrib/babelfishpg_tsql/src/pltsql.h index bbea96beec..caaf7960f3 100644 --- a/contrib/babelfishpg_tsql/src/pltsql.h +++ b/contrib/babelfishpg_tsql/src/pltsql.h @@ -1698,7 +1698,7 @@ typedef struct PLtsql_protocol_plugin int (*sp_cursoropen_callback) (int *cursor_handle, const char *stmt, int *scrollopt, int *ccopt, int *row_count, int nparams, Datum *values, const char *nulls); int (*sp_cursorprepare_callback) (int *stmt_handle, const char *stmt, int options, int *scrollopt, int *ccopt, - int nBindParams, Oid *boundParamsOidList); + int nBindParams, Oid *boundParamsOidList, const char* paramDef); int (*sp_cursorexecute_callback) (int stmt_handle, int *cursor_handle, int *scrollopt, int *ccopt, int *rowcount, int nparams, Datum *values, const char *nulls); int (*sp_cursorprepexec_callback) (int *stmt_handle, int *cursor_handle, const char *stmt, int options, int *scrollopt, int *ccopt, @@ -2165,7 +2165,7 @@ int execute_sp_cursor(int cursor_handle, int opttype, int rownum, const char * int execute_sp_cursoropen_old(int *cursor_handle, const char *stmt, int *scrollopt, int *ccopt, int *row_count, int nparams, Datum *values, const char *nulls); /* old interface to be * compatabile with TDS */ int execute_sp_cursoropen(int *cursor_handle, const char *stmt, int *scrollopt, int *ccopt, int *row_count, int nparams, int nBindParams, Oid *boundParamsOidList, Datum *values, const char *nulls); -int execute_sp_cursorprepare(int *stmt_handle, const char *stmt, int options, int *scrollopt, int *ccopt, int nBindParams, Oid *boundParamsOidList); +int execute_sp_cursorprepare(int *stmt_handle, const char *stmt, int options, int *scrollopt, int *ccopt, int nBindParams, Oid *boundParamsOidList, const char* paramDef); int execute_sp_cursorexecute(int stmt_handle, int *cursor_handle, int *scrollopt, int *ccopt, int *rowcount, int nparams, Datum *values, const char *nulls); int execute_sp_cursorprepexec(int *stmt_handle, int *cursor_handle, const char *stmt, int options, int *scrollopt, int *ccopt, int *row_count, int nparams, int nBindParams, Oid *boundParamsOidList, Datum *values, const char *nulls); int execute_sp_cursorunprepare(int stmt_handle); diff --git a/test/JDBC/expected/jtds-TestBinary.out b/test/JDBC/expected/jtds-TestBinary.out new file mode 100644 index 0000000000..679905c3e1 --- /dev/null +++ b/test/JDBC/expected/jtds-TestBinary.out @@ -0,0 +1,69 @@ +CREATE TABLE BINARY_dt(a BINARY(8), b VARBINARY(10)); +#inserting random values +INSERT INTO BINARY_dt(a, b) values (1234, 12345); +~~ROW COUNT: 1~~ + +INSERT INTO BINARY_dt(a, b) values (NULL, NULL); +~~ROW COUNT: 1~~ + +#INSERT INTO BINARY_dt(a, b) values (0x31323334, 0x3132333435); +SELECT * FROM BINARY_dt +~~START~~ +binary#!#varbinary +00000000000004D2#!#00003039 +#!# +~~END~~ + +#prepst#!# INSERT INTO BINARY_dt(a, b) values(@a, @b) #!#binary|-|a|-|1234#!#varbinary|-|b|-|12345 +DROP TABLE BINARY_dt + + +CREATE TABLE BINARY_dt(a VARBINARY(max)); +INSERT INTO BINARY_dt(a) values (NULL); +~~ROW COUNT: 1~~ + +SELECT * FROM BINARY_dt; +~~START~~ +image + +~~END~~ + +DROP TABLE BINARY_dt; + +create table BINARY_dt (a VARBINARY(max), b int, c int, d int, e int ,f int, g int, h int, i int); +insert into BINARY_dt (a,b,c,d,e,f,g,h,i) values (NULL,1,2,3,4,5,6,7,8); +~~ROW COUNT: 1~~ + +select * from BINARY_dt; +~~START~~ +image#!#int#!#int#!#int#!#int#!#int#!#int#!#int#!#int +#!#1#!#2#!#3#!#4#!#5#!#6#!#7#!#8 +~~END~~ + +drop table BINARY_dt; + +CREATE TABLE BINARY_dt(a BINARY(8), b VARBINARY(10)); +INSERT INTO BINARY_dt(a, b) values (1234, 12345); +~~ROW COUNT: 1~~ + +prepst#!# INSERT INTO BINARY_dt(a, b) values(?, ?) #!#binary|-|a|-|1234#!#varbinary|-|b|-|12345 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#binary|-|a|-|12345678#!#varbinary|-|b|-|12345 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#binary|-|a|-|1234#!#varbinary|-|b|-|123456789 +~~ROW COUNT: 1~~ + +SELECT * FROM BINARY_dt; +~~START~~ +binary#!#varbinary +00000000000004D2#!#00003039 +3132333400000000#!#3132333435 +3132333435363738#!#3132333435 +3132333400000000#!#313233343536373839 +~~END~~ + +DROP TABLE BINARY_dt; + + diff --git a/test/JDBC/expected/jtds-TestCursorFetchNext.out b/test/JDBC/expected/jtds-TestCursorFetchNext.out new file mode 100644 index 0000000000..7f419a2092 --- /dev/null +++ b/test/JDBC/expected/jtds-TestCursorFetchNext.out @@ -0,0 +1,273 @@ +CREATE TABLE test_cursors_fetch_next(a INT, b SMALLINT, c BIGINT, d TINYINT, e BIT); +INSERT INTO test_cursors_fetch_next values(0, 0, 0, 0, 0) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values(NULL, NULL, NULL, NULL, NULL) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values(1, 2, 3, 4, 1) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values(211234, 9780, 891372401, 56, 1) +~~ROW COUNT: 1~~ + +# SET escape_hatch_session_settings to ignore CURSOR_CLOSE_ON_COMMIT +EXEC sp_babelfish_configure 'babelfishpg_tsql.escape_hatch_session_settings', 'ignore'; +cursor#!#open#!#SELECT * FROM test_cursors_fetch_next#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +~~SUCCESS~~ +cursor#!#fetch#!#next +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +0#!#0#!#0#!#0#!#false +~~END~~ + +cursor#!#fetch#!#abs#!#2 +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +#!##!##!##!# +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +1#!#2#!#3#!#4#!#true +~~END~~ + +cursor#!#fetch#!#first +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +0#!#0#!#0#!#0#!#false +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +#!##!##!##!# +~~END~~ + +#cursor#!#fetch#!#last +cursor#!#fetch#!#abs#!#4 +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +211234#!#9780#!#891372401#!#56#!#true +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +~~ERROR (Code: 0)~~ + +~~ERROR (Message: No current row in the ResultSet.)~~ + +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +~~SUCCESS~~ +DROP TABLE test_cursors_fetch_next + +CREATE TABLE test_cursors_fetch_next(a CHAR(30), b VARCHAR(30), c NCHAR(30), d NVARCHAR(30)); +INSERT INTO test_cursors_fetch_next values(' ', ' ', ' ', ' ') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values(NULL, NULL, NULL, NULL) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values('hello', 'from the', N'server', N'side 😆') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values('Its', 'always', N'day', N'1') +~~ROW COUNT: 1~~ + +cursor#!#open#!#SELECT * FROM test_cursors_fetch_next#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +~~SUCCESS~~ +cursor#!#fetch#!#abs#!#3 +~~START~~ +char#!#varchar#!#nchar#!#nvarchar +hello #!#from the#!#server #!#side 😆 +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +char#!#varchar#!#nchar#!#nvarchar +Its #!#always#!#day #!#1 +~~END~~ + +cursor#!#fetch#!#first +~~START~~ +char#!#varchar#!#nchar#!#nvarchar + #!# #!# #!# +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +char#!#varchar#!#nchar#!#nvarchar +#!##!##!# +~~END~~ + +#cursor#!#fetch#!#last +cursor#!#fetch#!#abs#!#4 +~~START~~ +char#!#varchar#!#nchar#!#nvarchar +Its #!#always#!#day #!#1 +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +char#!#varchar#!#nchar#!#nvarchar +~~ERROR (Code: 0)~~ + +~~ERROR (Message: No current row in the ResultSet.)~~ + +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +~~SUCCESS~~ +DROP TABLE test_cursors_fetch_next + +CREATE TABLE test_cursors_fetch_next(a DATE, b DATETIME, c SMALLDATETIME); +INSERT INTO test_cursors_fetch_next values('2000-12-13', '1900-02-28 23:59:59.989', '2000-12-13 12:58:23') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values(NULL, NULL, NULL) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values('1997-05-07', '1900-02-28 11:23:17.895', '2000-12-13 10:23:44') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values('1876-08-07', '1980-02-05 16:11:45.215', '1987-10-01 07:55:24') +~~ROW COUNT: 1~~ + +cursor#!#open#!#SELECT * FROM test_cursors_fetch_next#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +~~SUCCESS~~ +cursor#!#fetch#!#first +~~START~~ +nvarchar#!#datetime#!#smalldatetime +2000-12-13#!#1900-02-28 23:59:59.99#!#2000-12-13 12:58:00.0 +~~END~~ + +cursor#!#fetch#!#abs#!#4 +~~START~~ +nvarchar#!#datetime#!#smalldatetime +1876-08-07#!#1980-02-05 16:11:45.217#!#1987-10-01 07:55:00.0 +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +nvarchar#!#datetime#!#smalldatetime +~~ERROR (Code: 0)~~ + +~~ERROR (Message: No current row in the ResultSet.)~~ + +cursor#!#fetch#!#first +~~START~~ +nvarchar#!#datetime#!#smalldatetime +2000-12-13#!#1900-02-28 23:59:59.99#!#2000-12-13 12:58:00.0 +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +nvarchar#!#datetime#!#smalldatetime +#!##!# +~~END~~ + +#cursor#!#fetch#!#last +cursor#!#fetch#!#abs#!#4 +~~START~~ +nvarchar#!#datetime#!#smalldatetime +1876-08-07#!#1980-02-05 16:11:45.217#!#1987-10-01 07:55:00.0 +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +nvarchar#!#datetime#!#smalldatetime +~~ERROR (Code: 0)~~ + +~~ERROR (Message: No current row in the ResultSet.)~~ + +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +~~SUCCESS~~ +DROP TABLE test_cursors_fetch_next + +CREATE TABLE test_cursors_fetch_next(a FLOAT, b REAL, c MONEY, d SMALLMONEY); +INSERT INTO test_cursors_fetch_next values(0, 0, '$0', '$0') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values(NULL, NULL, NULL, NULL) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values(241.7832, 1214.691236, '62,514.00', '690.817') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursors_fetch_next values('32546', '980.709', '1,988,232.08', '$86,798') +~~ROW COUNT: 1~~ + +cursor#!#open#!#SELECT * FROM test_cursors_fetch_next#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +~~SUCCESS~~ +cursor#!#fetch#!#next +~~START~~ +float#!#real#!#money#!#smallmoney +0.0#!#0.0#!#0.0000#!#0.0000 +~~END~~ + +cursor#!#fetch#!#abs#!#2 +~~START~~ +float#!#real#!#money#!#smallmoney +#!##!##!# +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +float#!#real#!#money#!#smallmoney +241.7832#!#1214.6913#!#62514.0000#!#690.8170 +~~END~~ + +cursor#!#fetch#!#first +~~START~~ +float#!#real#!#money#!#smallmoney +0.0#!#0.0#!#0.0000#!#0.0000 +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +float#!#real#!#money#!#smallmoney +#!##!##!# +~~END~~ + +#cursor#!#fetch#!#last +cursor#!#fetch#!#abs#!#4 +~~START~~ +float#!#real#!#money#!#smallmoney +32546.0#!#980.709#!#1988232.0800#!#86798.0000 +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +float#!#real#!#money#!#smallmoney +~~ERROR (Code: 0)~~ + +~~ERROR (Message: No current row in the ResultSet.)~~ + +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +~~SUCCESS~~ +DROP TABLE test_cursors_fetch_next +EXEC sp_babelfish_configure 'babelfishpg_tsql.escape_hatch_session_settings', 'strict'; diff --git a/test/JDBC/expected/jtds-TestCursorPrepExecFetchNext.out b/test/JDBC/expected/jtds-TestCursorPrepExecFetchNext.out new file mode 100644 index 0000000000..c68ac7e218 --- /dev/null +++ b/test/JDBC/expected/jtds-TestCursorPrepExecFetchNext.out @@ -0,0 +1,264 @@ +CREATE TABLE test_cursor_prep_exec_fetch_next(a INT, b SMALLINT, c BIGINT, d TINYINT, e BIT); +INSERT INTO test_cursor_prep_exec_fetch_next values(0, 0, 0, 0, 0) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values(NULL, NULL, NULL, NULL, NULL) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values(1, 2, 3, 4, 1) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values(211234, 9780, 891372401, 56, 1) +~~ROW COUNT: 1~~ + + +# SET escape_hatch_session_settings to ignore CURSOR_CLOSE_ON_COMMIT +EXEC sp_babelfish_configure 'babelfishpg_tsql.escape_hatch_session_settings', 'ignore'; +cursor#!#open#!#prepst#!#SELECT * FROM test_cursor_prep_exec_fetch_next WHERE a > ? #!#INT|-|a|-|-2#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +~~SUCCESS~~ +cursor#!#fetch#!#next +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +0#!#0#!#0#!#0#!#false +~~END~~ + +cursor#!#fetch#!#abs#!#2 +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +1#!#2#!#3#!#4#!#true +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +211234#!#9780#!#891372401#!#56#!#true +~~END~~ + +cursor#!#fetch#!#first +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +0#!#0#!#0#!#0#!#false +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +1#!#2#!#3#!#4#!#true +~~END~~ + +cursor#!#close +~~SUCCESS~~ +cursor#!#open#!#prepst#!#exec#!#INT|-|a|-|0#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#HOLD_CURSORS_OVER_COMMIT +~~SUCCESS~~ +#cursor#!#fetch#!#last +cursor#!#fetch#!#next +~~START~~ +int#!#smallint#!#bigint#!#tinyint#!#bit +1#!#2#!#3#!#4#!#true +~~END~~ + +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +~~SUCCESS~~ +DROP TABLE test_cursor_prep_exec_fetch_next + +CREATE TABLE test_cursor_prep_exec_fetch_next(a CHAR(30), b VARCHAR(30), c NCHAR(30), d NVARCHAR(30)); +INSERT INTO test_cursor_prep_exec_fetch_next values(' ', ' ', ' ', ' ') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values(NULL, NULL, NULL, NULL) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values('hello', 'from the', N'server', N'side 😆') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values('Its', 'always', N'day', N'1') +~~ROW COUNT: 1~~ + +cursor#!#open#!#prepst#!#SELECT * FROM test_cursor_prep_exec_fetch_next WHERE a <> ? #!#CHAR|-|a|-|hello#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +~~SUCCESS~~ +cursor#!#fetch#!#abs#!#3 +~~START~~ +char#!#varchar#!#nchar#!#nvarchar +~~ERROR (Code: 0)~~ + +~~ERROR (Message: No current row in the ResultSet.)~~ + +cursor#!#fetch#!#next +~~START~~ +char#!#varchar#!#nchar#!#nvarchar +~~ERROR (Code: 0)~~ + +~~ERROR (Message: No current row in the ResultSet.)~~ + +cursor#!#fetch#!#first +~~START~~ +char#!#varchar#!#nchar#!#nvarchar + #!# #!# #!# +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +char#!#varchar#!#nchar#!#nvarchar +Its #!#always#!#day #!#1 +~~END~~ + +cursor#!#close +~~SUCCESS~~ +cursor#!#open#!#prepst#!#exec#!#CHAR|-|a|-|Its#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +~~SUCCESS~~ +#cursor#!#fetch#!#last +cursor#!#fetch#!#next +~~START~~ +char#!#varchar#!#nchar#!#nvarchar + #!# #!# #!# +~~END~~ + +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +~~SUCCESS~~ +DROP TABLE test_cursor_prep_exec_fetch_next + +CREATE TABLE test_cursor_prep_exec_fetch_next(a DATE, b DATETIME, c SMALLDATETIME); +INSERT INTO test_cursor_prep_exec_fetch_next values('2000-12-13', '1900-02-28 23:59:59.989', '2000-12-13 12:58:23') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values(NULL, NULL, NULL) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values('1997-05-07', '1900-02-28 11:23:17.895', '2000-12-13 10:23:44') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values('1876-08-07', '1980-02-05 16:11:45.215', '1987-10-01 07:55:24') +~~ROW COUNT: 1~~ + +cursor#!#open#!#prepst#!#SELECT * FROM test_cursor_prep_exec_fetch_next WHERE b > ? #!#DATETIME|-|b|-|1753-01-01 00:00:00.000#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +~~SUCCESS~~ +cursor#!#fetch#!#first +~~START~~ +nvarchar#!#datetime#!#smalldatetime +2000-12-13#!#1900-02-28 23:59:59.99#!#2000-12-13 12:58:00.0 +~~END~~ + +cursor#!#fetch#!#abs#!#2 +~~START~~ +nvarchar#!#datetime#!#smalldatetime +1997-05-07#!#1900-02-28 11:23:17.897#!#2000-12-13 10:24:00.0 +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +nvarchar#!#datetime#!#smalldatetime +1876-08-07#!#1980-02-05 16:11:45.217#!#1987-10-01 07:55:00.0 +~~END~~ + +cursor#!#fetch#!#first +~~START~~ +nvarchar#!#datetime#!#smalldatetime +2000-12-13#!#1900-02-28 23:59:59.99#!#2000-12-13 12:58:00.0 +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +nvarchar#!#datetime#!#smalldatetime +1997-05-07#!#1900-02-28 11:23:17.897#!#2000-12-13 10:24:00.0 +~~END~~ + +cursor#!#close +~~SUCCESS~~ +cursor#!#open#!#prepst#!#exec#!#DATETIME|-|b|-|1947-01-01 11:23:17.374#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +~~SUCCESS~~ +#cursor#!#fetch#!#last +cursor#!#fetch#!#next +~~START~~ +nvarchar#!#datetime#!#smalldatetime +1876-08-07#!#1980-02-05 16:11:45.217#!#1987-10-01 07:55:00.0 +~~END~~ + +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +~~SUCCESS~~ +DROP TABLE test_cursor_prep_exec_fetch_next + +CREATE TABLE test_cursor_prep_exec_fetch_next(a FLOAT, b REAL, c MONEY, d SMALLMONEY); +INSERT INTO test_cursor_prep_exec_fetch_next values(0, 0, '$0', '$0') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values(NULL, NULL, NULL, NULL) +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values(241.7832, 1214.691236, '62,514.00', '690.817') +~~ROW COUNT: 1~~ + +INSERT INTO test_cursor_prep_exec_fetch_next values('32546', '980.709', '1,988,232.08', '$86,798') +~~ROW COUNT: 1~~ + +cursor#!#open#!#prepst#!#SELECT * FROM test_cursor_prep_exec_fetch_next WHERE b > ? #!#REAL|-|b|-|12.0834#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +~~SUCCESS~~ +cursor#!#fetch#!#next +~~START~~ +float#!#real#!#money#!#smallmoney +241.7832#!#1214.6913#!#62514.0000#!#690.8170 +~~END~~ + +cursor#!#fetch#!#abs#!#3 +~~START~~ +float#!#real#!#money#!#smallmoney +~~ERROR (Code: 0)~~ + +~~ERROR (Message: No current row in the ResultSet.)~~ + +cursor#!#fetch#!#next +~~START~~ +float#!#real#!#money#!#smallmoney +~~ERROR (Code: 0)~~ + +~~ERROR (Message: No current row in the ResultSet.)~~ + +cursor#!#fetch#!#first +~~START~~ +float#!#real#!#money#!#smallmoney +241.7832#!#1214.6913#!#62514.0000#!#690.8170 +~~END~~ + +cursor#!#fetch#!#next +~~START~~ +float#!#real#!#money#!#smallmoney +32546.0#!#980.709#!#1988232.0800#!#86798.0000 +~~END~~ + +cursor#!#close +~~SUCCESS~~ +cursor#!#open#!#prepst#!#exec#!#REAL|-|b|-|1000.241#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +~~SUCCESS~~ +#cursor#!#fetch#!#last +cursor#!#fetch#!#next +~~START~~ +float#!#real#!#money#!#smallmoney +241.7832#!#1214.6913#!#62514.0000#!#690.8170 +~~END~~ + +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +~~SUCCESS~~ +DROP TABLE test_cursor_prep_exec_fetch_next diff --git a/test/JDBC/expected/jtds-TestDate.out b/test/JDBC/expected/jtds-TestDate.out new file mode 100644 index 0000000000..2604929076 --- /dev/null +++ b/test/JDBC/expected/jtds-TestDate.out @@ -0,0 +1,61 @@ +CREATE TABLE DATE_dt (a DATE) +prepst#!# INSERT INTO DATE_dt(a) values(?) #!#DATE|-|a|-|2000-12-13 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATE|-|a|-|2000-02-28 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATE|-|a|-|0001-01-01 +~~ERROR (Code: 0)~~ + +~~ERROR (Message: Only dates between January 1, 1753 and December 31, 9999 are accepted.)~~ + +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATE|-|a|-|9999-12-31 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATE|-|a|-| +~~ROW COUNT: 1~~ + +SELECT * FROM DATE_dt; +~~START~~ +nvarchar +2000-12-13 +2000-02-28 +2000-02-28 +9999-12-31 + +~~END~~ + +INSERT INTO DATE_dt(a) values('2000-12-13') +~~ROW COUNT: 1~~ + +INSERT INTO DATE_dt(a) values('1900-02-28') +~~ROW COUNT: 1~~ + +INSERT INTO DATE_dt(a) values('0001-01-01') +~~ROW COUNT: 1~~ + +INSERT INTO DATE_dt(a) values('9999-12-31') +~~ROW COUNT: 1~~ + +INSERT INTO DATE_dt(a) values(NULL) +~~ROW COUNT: 1~~ + +SELECT * FROM DATE_dt; +~~START~~ +nvarchar +2000-12-13 +2000-02-28 +2000-02-28 +9999-12-31 + +2000-12-13 +1900-02-28 +0001-01-01 +9999-12-31 + +~~END~~ + +DROP TABLE DATE_dt; diff --git a/test/JDBC/expected/jtds-TestDatetime.out b/test/JDBC/expected/jtds-TestDatetime.out new file mode 100644 index 0000000000..f456cd786d --- /dev/null +++ b/test/JDBC/expected/jtds-TestDatetime.out @@ -0,0 +1,410 @@ +CREATE TABLE DATETIME_dt (a DATETIME) +prepst#!# INSERT INTO DATETIME_dt(a) values(?) #!#DATETIME|-|a|-|2000-12-13 12:58:23.123 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.989 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.990 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.991 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.992 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.993 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.994 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.995 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.996 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.997 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.998 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.999 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|1900-02-28 23:59:59.989 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|1753-01-01 00:00:00.000 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-|9999-12-31 23:59:59.997 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#DATETIME|-|a|-| +~~ROW COUNT: 1~~ + +SELECT * FROM DATETIME_dt; +~~START~~ +datetime +2000-12-13 12:58:23.123 +2000-02-28 23:59:59.99 +2000-02-28 23:59:59.99 +2000-02-28 23:59:59.99 +2000-02-28 23:59:59.993 +2000-02-28 23:59:59.993 +2000-02-28 23:59:59.993 +2000-02-28 23:59:59.997 +2000-02-28 23:59:59.997 +2000-02-28 23:59:59.997 +2000-02-28 23:59:59.997 +2000-02-29 00:00:00.0 +1900-02-28 23:59:59.99 +1753-01-01 00:00:00.0 +9999-12-31 23:59:59.997 + +~~END~~ + +INSERT INTO DATETIME_dt(a) values('2000-12-13 12:58:23.123') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.989') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.990') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.991') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.992') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.993') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.994') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.995') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.996') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.997') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.998') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.999') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('2000-02-28 23:59:59.989') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('1753-01-01 00:00:00.000') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values('9999-12-31 23:59:59.997') +~~ROW COUNT: 1~~ + +INSERT INTO DATETIME_dt(a) values(NULL) +~~ROW COUNT: 1~~ + +SELECT * FROM DATETIME_dt; +~~START~~ +datetime +2000-12-13 12:58:23.123 +2000-02-28 23:59:59.99 +2000-02-28 23:59:59.99 +2000-02-28 23:59:59.99 +2000-02-28 23:59:59.993 +2000-02-28 23:59:59.993 +2000-02-28 23:59:59.993 +2000-02-28 23:59:59.997 +2000-02-28 23:59:59.997 +2000-02-28 23:59:59.997 +2000-02-28 23:59:59.997 +2000-02-29 00:00:00.0 +1900-02-28 23:59:59.99 +1753-01-01 00:00:00.0 +9999-12-31 23:59:59.997 + +2000-12-13 12:58:23.123 +1900-02-28 23:59:59.99 +1900-02-28 23:59:59.99 +1900-02-28 23:59:59.99 +1900-02-28 23:59:59.993 +1900-02-28 23:59:59.993 +1900-02-28 23:59:59.993 +1900-02-28 23:59:59.997 +1900-02-28 23:59:59.997 +1900-02-28 23:59:59.997 +1900-02-28 23:59:59.997 +1900-03-01 00:00:00.0 +2000-02-28 23:59:59.99 +1753-01-01 00:00:00.0 +9999-12-31 23:59:59.997 + +~~END~~ + +DROP TABLE DATETIME_dt; + +select convert(datetime, '2022-11-10 09:15:30.000'); +~~START~~ +datetime +2022-11-10 09:15:30.0 +~~END~~ + +select convert(datetime, '2022-11-10 09:15:30.001'); +~~START~~ +datetime +2022-11-10 09:15:30.0 +~~END~~ + +select convert(datetime, '2022-11-10 09:15:30.002'); +~~START~~ +datetime +2022-11-10 09:15:30.003 +~~END~~ + +select convert(datetime, '2022-11-10 09:15:30.003'); +~~START~~ +datetime +2022-11-10 09:15:30.003 +~~END~~ + +select convert(datetime, '2022-11-10 09:15:30.004'); +~~START~~ +datetime +2022-11-10 09:15:30.003 +~~END~~ + +select convert(datetime, '2022-11-10 09:15:30.005'); +~~START~~ +datetime +2022-11-10 09:15:30.007 +~~END~~ + +select convert(datetime, '2022-11-10 09:15:30.006'); +~~START~~ +datetime +2022-11-10 09:15:30.007 +~~END~~ + +select convert(datetime, '2022-11-10 09:15:30.007'); +~~START~~ +datetime +2022-11-10 09:15:30.007 +~~END~~ + +select convert(datetime, '2022-11-10 09:15:30.008'); +~~START~~ +datetime +2022-11-10 09:15:30.007 +~~END~~ + +select convert(datetime, '2022-11-10 09:15:30.009'); +~~START~~ +datetime +2022-11-10 09:15:30.01 +~~END~~ + +select convert(datetime, '2022-11-10 09:15:30.999'); +~~START~~ +datetime +2022-11-10 09:15:31.0 +~~END~~ + + +select convert(datetime, '2022-11-10 21:26:45.120'); +~~START~~ +datetime +2022-11-10 21:26:45.12 +~~END~~ + +select convert(datetime, '2022-11-10 21:26:45.341'); +~~START~~ +datetime +2022-11-10 21:26:45.34 +~~END~~ + +select convert(datetime, '2022-11-10 21:26:45.562'); +~~START~~ +datetime +2022-11-10 21:26:45.563 +~~END~~ + +select convert(datetime, '2022-11-10 21:26:45.783'); +~~START~~ +datetime +2022-11-10 21:26:45.783 +~~END~~ + +select convert(datetime, '2022-11-10 21:26:45.904'); +~~START~~ +datetime +2022-11-10 21:26:45.903 +~~END~~ + +select convert(datetime, '2022-11-10 21:26:45.215'); +~~START~~ +datetime +2022-11-10 21:26:45.217 +~~END~~ + +select convert(datetime, '2022-11-10 21:26:45.436'); +~~START~~ +datetime +2022-11-10 21:26:45.437 +~~END~~ + +select convert(datetime, '2022-11-10 21:26:45.657'); +~~START~~ +datetime +2022-11-10 21:26:45.657 +~~END~~ + +select convert(datetime, '2022-11-10 21:26:45.878'); +~~START~~ +datetime +2022-11-10 21:26:45.877 +~~END~~ + +select convert(datetime, '2022-11-10 21:26:45.909'); +~~START~~ +datetime +2022-11-10 21:26:45.91 +~~END~~ + + +select convert(datetime, '2000-12-13 12:58:23.123'); +~~START~~ +datetime +2000-12-13 12:58:23.123 +~~END~~ + +select convert(datetime, '2000-12-13 12:58:23.223'); +~~START~~ +datetime +2000-12-13 12:58:23.223 +~~END~~ + +select convert(datetime, '2000-12-13 12:58:23.323'); +~~START~~ +datetime +2000-12-13 12:58:23.323 +~~END~~ + +select convert(datetime, '2000-12-13 12:58:23.423'); +~~START~~ +datetime +2000-12-13 12:58:23.423 +~~END~~ + +select convert(datetime, '2000-12-13 12:58:23.523'); +~~START~~ +datetime +2000-12-13 12:58:23.523 +~~END~~ + +select convert(datetime, '2000-12-13 12:58:23.623'); +~~START~~ +datetime +2000-12-13 12:58:23.623 +~~END~~ + +select convert(datetime, '2000-12-13 12:58:23.723'); +~~START~~ +datetime +2000-12-13 12:58:23.723 +~~END~~ + +select convert(datetime, '2000-12-13 12:58:23.823'); +~~START~~ +datetime +2000-12-13 12:58:23.823 +~~END~~ + +select convert(datetime, '2000-12-13 12:58:23.923'); +~~START~~ +datetime +2000-12-13 12:58:23.923 +~~END~~ + +select convert(datetime, '2000-12-13 12:58:23.023'); +~~START~~ +datetime +2000-12-13 12:58:23.023 +~~END~~ + + +select convert(datetime, '1753-01-01 23:59:59.997'); +~~START~~ +datetime +1753-01-01 23:59:59.997 +~~END~~ + +select convert(datetime, '1753-12-31 23:59:59.998'); +~~START~~ +datetime +1753-12-31 23:59:59.997 +~~END~~ + +select convert(datetime, '1753-12-31 23:59:59.999'); +~~START~~ +datetime +1754-01-01 00:00:00.0 +~~END~~ + +select convert(datetime, '9999-12-31 23:59:59.998'); +~~START~~ +datetime +9999-12-31 23:59:59.997 +~~END~~ + +select convert(datetime, '9999-12-31 23:59:59.999'); +~~ERROR (Code: 517)~~ + +~~ERROR (Message: data out of range for datetime)~~ + +select convert(datetime, '1752-12-31 23:59:59.997'); +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: The conversion of a VARCHAR data type to a DATETIME data type resulted in an out-of-range value.)~~ + +select convert(datetime, '0000-00-00 00:00:00.000'); +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: The conversion of a VARCHAR data type to a DATETIME data type resulted in an out-of-range value.)~~ + +select convert(datetime, NULL); +~~START~~ +datetime + +~~END~~ + + +select convert(datetime, '1900-01-01 02:18:53.003') +~~START~~ +datetime +1900-01-01 02:18:53.003 +~~END~~ + +select convert(datetime, '1900-01-02 00:00:00.003') +~~START~~ +datetime +1900-01-02 00:00:00.003 +~~END~~ + +select convert(datetime, '1900-01-02 01:00:00.003') +~~START~~ +datetime +1900-01-02 01:00:00.003 +~~END~~ + diff --git a/test/JDBC/expected/jtds-TestDatetime2.out b/test/JDBC/expected/jtds-TestDatetime2.out new file mode 100644 index 0000000000..22c633f847 --- /dev/null +++ b/test/JDBC/expected/jtds-TestDatetime2.out @@ -0,0 +1,43 @@ +Create table TestDatetime2(a Datetime2(6)) + +prepst#!# Insert into TestDatetime2 Values(?) #!#Datetime2|-|a|-|2016-10-23 12:45:37.123|-|0 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.123|-|3 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.12|-|2 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.1|-|1 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.1234|-|4 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.123456|-|6 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.123456|-|5 +~~ROW COUNT: 1~~ + +#prepst#!#exec#!#Datetime2|-|a|-|12:45:37.123456|-|5 +prepst#!#exec#!#Datetime2|-|a|-| +~~ROW COUNT: 1~~ + + +select * from TestDatetime2 +~~START~~ +nvarchar +2016-10-23 12:45:37.123000 +2016-10-23 12:45:37.123000 +2016-10-23 12:45:37.120000 +2016-10-23 12:45:37.100000 +2016-10-23 12:45:37.123000 +2016-10-23 12:45:37.123000 +2016-10-23 12:45:37.123000 + +~~END~~ + + +Drop table TestDatetime2 diff --git a/test/JDBC/expected/jtds-TestDatetimeoffset-vu-cleanup.out b/test/JDBC/expected/jtds-TestDatetimeoffset-vu-cleanup.out new file mode 100644 index 0000000000..b6c273394c --- /dev/null +++ b/test/JDBC/expected/jtds-TestDatetimeoffset-vu-cleanup.out @@ -0,0 +1,9 @@ +-- Clean up +drop table TestDatetimeoffset_vu_prepare_testing; +go +drop table TestDatetimeoffset_vu_prepare_t1; +go +drop procedure TestDatetimeoffset_vu_prepare_cast; +go +drop procedure TestDatetimeoffset_vu_prepare_cmp; +go diff --git a/test/JDBC/expected/jtds-TestDatetimeoffset-vu-prepare.out b/test/JDBC/expected/jtds-TestDatetimeoffset-vu-prepare.out new file mode 100644 index 0000000000..0eb2d29cde --- /dev/null +++ b/test/JDBC/expected/jtds-TestDatetimeoffset-vu-prepare.out @@ -0,0 +1,73 @@ +-- Testing inserting into the table +create table TestDatetimeoffset_vu_prepare_testing (df datetimeoffset); +go +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('23:40:29.998'); +go +~~ROW COUNT: 1~~ + +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('1900-01-01 00:00+0:00'); +go +~~ROW COUNT: 1~~ + +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('0001-01-01 00:00:00 +0:00'); +go +~~ROW COUNT: 1~~ + +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('2020-03-15 09:00:00 +8:00'); +go +~~ROW COUNT: 1~~ + +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('2020-03-15 09:00:00 +9:00'); +go +~~ROW COUNT: 1~~ + +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('1800-03-15 09:00:00 +12:00'); +go +~~ROW COUNT: 1~~ + +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('2020-03-15 09:00:00 -8:20'); +go +~~ROW COUNT: 1~~ + +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('1992-03-15 09:00:00'); +go +~~ROW COUNT: 1~~ + +-- out of range +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('10000-01-01 00:00:00 +0:00'); +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type datetimeoffset: "10000-01-01 00:00:00 +0:00")~~ + + +CREATE INDEX TestDatetimeoffset_vu_prepare_idx ON TestDatetimeoffset_vu_prepare_testing (df); +go + +-- Test datetimeoffset default value +create table TestDatetimeoffset_vu_prepare_t1 (a datetimeoffset, b int); +go +insert into TestDatetimeoffset_vu_prepare_t1 (b) values (1); +go +~~ROW COUNT: 1~~ + + +-- test casting datetimeoffset inside procedure +-- NOTE: This is not supported behavior in tsql and will fail +CREATE PROCEDURE TestDatetimeoffset_vu_prepare_cast (@val datetimeoffset) AS +BEGIN + DECLARE @DF datetimeoffset = @val + PRINT @DF + PRINT cast(@DF as datetimeoffset(5)) +END; +go + +-- test comparing datetimeoffset inside procedure +CREATE PROCEDURE TestDatetimeoffset_vu_prepare_cmp (@val datetimeoffset) AS +BEGIN + IF @val > CAST('2000-01-01 13:39:29.123456 +0:00' AS datetimeoffset) + PRINT @val - make_interval(1) + ELSE + PRINT @val + make_interval(1) +END; +go diff --git a/test/JDBC/expected/jtds-TestDatetimeoffset-vu-verify.out b/test/JDBC/expected/jtds-TestDatetimeoffset-vu-verify.out new file mode 100644 index 0000000000..68cc9b5eba --- /dev/null +++ b/test/JDBC/expected/jtds-TestDatetimeoffset-vu-verify.out @@ -0,0 +1,864 @@ +select * from TestDatetimeoffset_vu_prepare_testing; +go +~~START~~ +nvarchar +1900-01-01 23:40:29.9980000 +00:00 +1900-01-01 00:00:00.0000000 +00:00 +0001-01-01 00:00:00.0000000 +00:00 +2020-03-15 09:00:00.0000000 +08:00 +2020-03-15 09:00:00.0000000 +09:00 +1800-03-15 09:00:00.0000000 +12:00 +2020-03-15 09:00:00.0000000 -08:20 +1992-03-15 09:00:00.0000000 +00:00 +~~END~~ + + +-- Test comparision with datetime/smalldatetime/date +select * from TestDatetimeoffset_vu_prepare_testing where df >= '2020-03-15 00:00:00'; +go +~~START~~ +nvarchar +2020-03-15 09:00:00.0000000 +08:00 +2020-03-15 09:00:00.0000000 +09:00 +2020-03-15 09:00:00.0000000 -08:20 +~~END~~ + +select * from TestDatetimeoffset_vu_prepare_testing where df >= '2020-03-15 09:00:00 +7'; +go +~~START~~ +nvarchar +2020-03-15 09:00:00.0000000 -08:20 +~~END~~ + +select * from TestDatetimeoffset_vu_prepare_testing where df >= '2020-03-15 09:00:00 +8' + and df < '2020-03-15 09:00:00'; +go +~~START~~ +nvarchar +2020-03-15 09:00:00.0000000 +08:00 +~~END~~ + +select * from TestDatetimeoffset_vu_prepare_testing where df < '1992-05-24'; +go +~~START~~ +nvarchar +1900-01-01 23:40:29.9980000 +00:00 +1900-01-01 00:00:00.0000000 +00:00 +0001-01-01 00:00:00.0000000 +00:00 +1800-03-15 09:00:00.0000000 +12:00 +1992-03-15 09:00:00.0000000 +00:00 +~~END~~ + + +-- Test datetimeoffset default value +select a from TestDatetimeoffset_vu_prepare_t1 where b = 1; +go +~~START~~ +nvarchar + +~~END~~ + + +-- Testing rounding for different typmod +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset); +go +~~START~~ +nvarchar +2079-06-06 23:59:29.1234560 -09:30 +~~END~~ + +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(0)); +go +~~START~~ +nvarchar +2079-06-06 23:59:29 -09:30 +~~END~~ + +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(1)); +go +~~START~~ +nvarchar +2079-06-06 23:59:29.1 -09:30 +~~END~~ + +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(2)); +go +~~START~~ +nvarchar +2079-06-06 23:59:29.12 -09:30 +~~END~~ + +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(3)); +go +~~START~~ +nvarchar +2079-06-06 23:59:29.123 -09:30 +~~END~~ + +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(4)); +go +~~START~~ +nvarchar +2079-06-06 23:59:29.1235 -09:30 +~~END~~ + +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(5)); +go +~~START~~ +nvarchar +2079-06-06 23:59:29.12346 -09:30 +~~END~~ + +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(6)); +go +~~START~~ +nvarchar +2079-06-06 23:59:29.123456 -09:30 +~~END~~ + +-- Testing edge cases +select CAST('1900-06-06 20:00:00.499 +0:00' AS datetimeoffset(0)); +go +~~START~~ +nvarchar +1900-06-06 20:00:00 +00:00 +~~END~~ + +select CAST('1900-06-06 20:00:00.500 +0:00' AS datetimeoffset(0)); +go +~~START~~ +nvarchar +1900-06-06 20:00:01 +00:00 +~~END~~ + +select CAST('1900-06-06 20:00:00.501 +0:00' AS datetimeoffset(0)); +go +~~START~~ +nvarchar +1900-06-06 20:00:01 +00:00 +~~END~~ + +select CAST('2079-06-06 20:00:00.499 +0:00' AS datetimeoffset(0)); +go +~~START~~ +nvarchar +2079-06-06 20:00:00 +00:00 +~~END~~ + +select CAST('2079-06-06 20:00:00.500 +0:00' AS datetimeoffset(0)); +go +~~START~~ +nvarchar +2079-06-06 20:00:01 +00:00 +~~END~~ + +select CAST('2079-06-06 20:00:00.501 +0:00' AS datetimeoffset(0)); +go +~~START~~ +nvarchar +2079-06-06 20:00:01 +00:00 +~~END~~ + +select CAST('1979-06-06 20:00:00.000499 +0:00' AS datetimeoffset(3)); +go +~~START~~ +nvarchar +1979-06-06 20:00:00.000 +00:00 +~~END~~ + +select CAST('1979-06-06 20:00:00.000500 +0:00' AS datetimeoffset(3)); +go +~~START~~ +nvarchar +1979-06-06 20:00:00.001 +00:00 +~~END~~ + +select CAST('1979-06-06 20:00:00.000501 +0:00' AS datetimeoffset(3)); +go +~~START~~ +nvarchar +1979-06-06 20:00:00.001 +00:00 +~~END~~ + +select CAST('2079-06-06 20:00:00.000499 +0:00' AS datetimeoffset(3)); +go +~~START~~ +nvarchar +2079-06-06 20:00:00.000 +00:00 +~~END~~ + +select CAST('2079-06-06 20:00:00.000500 +0:00' AS datetimeoffset(3)); +go +~~START~~ +nvarchar +2079-06-06 20:00:00.001 +00:00 +~~END~~ + +select CAST('2079-06-06 20:00:00.000501 +0:00' AS datetimeoffset(3)); +go +~~START~~ +nvarchar +2079-06-06 20:00:00.001 +00:00 +~~END~~ + +select CAST('1979-06-06 20:00:00.000049 +0:00' AS datetimeoffset(4)); +go +~~START~~ +nvarchar +1979-06-06 20:00:00.0000 +00:00 +~~END~~ + +select CAST('1979-06-06 20:00:00.000050 +0:00' AS datetimeoffset(4)); +go +~~START~~ +nvarchar +1979-06-06 20:00:00.0001 +00:00 +~~END~~ + +select CAST('1979-06-06 20:00:00.000051 +0:00' AS datetimeoffset(4)); +go +~~START~~ +nvarchar +1979-06-06 20:00:00.0001 +00:00 +~~END~~ + +select CAST('2079-06-06 20:00:00.000049 +0:00' AS datetimeoffset(4)); +go +~~START~~ +nvarchar +2079-06-06 20:00:00.0000 +00:00 +~~END~~ + +select CAST('2079-06-06 20:00:00.000050 +0:00' AS datetimeoffset(4)); +go +~~START~~ +nvarchar +2079-06-06 20:00:00.0001 +00:00 +~~END~~ + +select CAST('2079-06-06 20:00:00.000051 +0:00' AS datetimeoffset(4)); +go +~~START~~ +nvarchar +2079-06-06 20:00:00.0001 +00:00 +~~END~~ + +select CAST('1979-06-06 20:00:00.000004 +0:00' AS datetimeoffset(5)); +go +~~START~~ +nvarchar +1979-06-06 20:00:00.00000 +00:00 +~~END~~ + +select CAST('1979-06-06 20:00:00.000005 +0:00' AS datetimeoffset(5)); +go +~~START~~ +nvarchar +1979-06-06 20:00:00.00001 +00:00 +~~END~~ + +select CAST('2079-06-06 20:00:00.000004 +0:00' AS datetimeoffset(5)); +go +~~START~~ +nvarchar +2079-06-06 20:00:00.00000 +00:00 +~~END~~ + +select CAST('2079-06-06 20:00:00.000005 +0:00' AS datetimeoffset(5)); +go +~~START~~ +nvarchar +2079-06-06 20:00:00.00001 +00:00 +~~END~~ + +-- out of range +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(7)); +go +~~START~~ +nvarchar +2079-06-06 23:59:29.123456 -09:30 +~~END~~ + + +-- Test type cast to/from other time formats +-- Test datetime/dateime2 +select CAST(CAST('2020-03-15 23:59:29.99' AS datetime) AS datetimeoffset); +go +~~START~~ +nvarchar +2020-03-15 23:59:29.9900000 +00:00 +~~END~~ + +select CAST(CAST('2079-06-06 23:59:29.998 +8:00' AS datetimeoffset) AS datetime); +go +~~START~~ +datetime +2079-06-06 23:59:29.997 +~~END~~ + +select CAST(CAST('2079-06-06 23:59:29.998 -9:30' AS datetimeoffset) AS datetime); +go +~~START~~ +datetime +2079-06-06 23:59:29.997 +~~END~~ + +select CAST(CAST('1920-05-25 00:59:29.99' AS datetime2) AS datetimeoffset); +go +~~START~~ +nvarchar +1920-05-25 00:59:29.9900000 +00:00 +~~END~~ + +select CAST(CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) AS datetime2); +go +~~START~~ +nvarchar +1900-05-06 13:59:29.9980000 +~~END~~ + + +-- Test date +select CAST(CAST('1999-12-31' AS date) AS datetimeoffset); +go +~~START~~ +nvarchar +1999-12-31 00:00:00.0000000 +00:00 +~~END~~ + +select CAST(CAST('0001-12-31' AS date) AS datetimeoffset); +go +~~START~~ +nvarchar +0001-12-31 00:00:00.0000000 +00:00 +~~END~~ + +select CAST(CAST('2000-01-01 23:59:59.999' AS datetimeoffset) AS date); +go +~~START~~ +nvarchar +2000-01-01 +~~END~~ + +select CAST(CAST('2000-01-01 23:59:59.999+8' AS datetimeoffset) AS date); +go +~~START~~ +nvarchar +2000-01-01 +~~END~~ + +select CAST(CAST('1900-05-06 23:59:29.998+8:20' AS datetimeoffset) AS date); +go +~~START~~ +nvarchar +1900-05-06 +~~END~~ + +-- out of range +select CAST(CAST('12000-01-01' AS date) AS datetimeoffset); +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data out of range for datetimeoffset)~~ + + +-- Test time +select CAST(CAST('23:59:59.999' AS time) AS datetimeoffset); +go +~~START~~ +nvarchar +1900-01-01 23:59:59.9990000 +00:00 +~~END~~ + +select CAST(CAST('00:30:31' AS time) AS datetimeoffset); +go +~~START~~ +nvarchar +1900-01-01 00:30:31.0000000 +00:00 +~~END~~ + +select CAST(CAST('1900-05-06 23:59:29.998+8:00' AS datetimeoffset) AS time); +go +~~START~~ +nvarchar +23:59:29.9980000 +~~END~~ + +select CAST(CAST('1920-05-25 00:59:29.99 +0' AS datetimeoffset) AS time); +go +~~START~~ +nvarchar +00:59:29.9900000 +~~END~~ + +select CAST(CAST('2050-05-06 00:00:00 +0' AS datetimeoffset) AS time); +go +~~START~~ +nvarchar +00:00:00.0000000 +~~END~~ + +select CAST(CAST('2050-05-06 12:00:00 +0' AS datetimeoffset) AS time); +go +~~START~~ +nvarchar +12:00:00.0000000 +~~END~~ + +select CAST(CAST('2050-05-06 15:31:22 +0' AS datetimeoffset) AS time); +go +~~START~~ +nvarchar +15:31:22.0000000 +~~END~~ + +select CAST(CAST('2050-05-06 23:59:29.998+8:00' AS datetimeoffset) AS time); +go +~~START~~ +nvarchar +23:59:29.9980000 +~~END~~ + + +-- Test smalldatetime +select CAST(CAST('2000-06-06 23:59:29.998 -9:30' AS datetimeoffset) AS smalldatetime); +go +~~START~~ +smalldatetime +2000-06-06 23:59:00.0 +~~END~~ + +select CAST(CAST('2079-06-06 23:59:29.998 +8:00' AS datetimeoffset) AS smalldatetime); +go +~~START~~ +smalldatetime +2079-06-06 23:59:00.0 +~~END~~ + +select CAST(CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) AS smalldatetime); +go +~~START~~ +smalldatetime +1900-05-06 13:59:00.0 +~~END~~ + +select CAST(CAST('2020-03-15 23:59:29.99' AS smalldatetime) AS datetimeoffset); +go +~~START~~ +nvarchar +2020-03-15 23:59:00.0000000 +00:00 +~~END~~ + +select CAST(CAST('1920-05-25 00:59:29.99' AS smalldatetime) AS datetimeoffset); +go +~~START~~ +nvarchar +1920-05-25 00:59:00.0000000 +00:00 +~~END~~ + +-- out of range +select CAST(CAST('8000-05-25 00:59:29.99' AS smalldatetime) AS datetimeoffset); +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data out of range for smalldatetime)~~ + + +-- Test datetimeoffset value ranges +select cast('0001-01-01 +0' as datetimeoffset); +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type datetimeoffset: "0001-01-01 +0")~~ + +select cast('0001-01-01 -1' as datetimeoffset); +go +select cast('2079-06-06 23:59:29.998 +0' as datetimeoffset); +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: syntax error near 'select' at line 3 and character position 0)~~ + +select cast('9999-12-31 23:59:29.998 +0' as datetimeoffset); +go +~~START~~ +nvarchar +9999-12-31 23:59:29.9980000 +00:00 +~~END~~ + +-- out of range +select cast('0001-01-01 +0 BC' as datetimeoffset); +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type datetimeoffset: "0001-01-01 +0 BC")~~ + +-- out of range +select cast('0001-01-01 +1' as datetimeoffset); +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type datetimeoffset: "0001-01-01 +1")~~ + +-- out of range +select cast('0001-01-01 +0:20' as datetimeoffset); +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type datetimeoffset: "0001-01-01 +0:20")~~ + +-- out of range +select cast('9999-12-31 23:59:29.998 -1' as datetimeoffset); +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data out of range for datetimeoffset)~~ + +-- out of range +select cast('10000-01-01 00:00' as datetimeoffset); +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type datetimeoffset: "10000-01-01 00:00")~~ + + +-- Testing arithmetic operators +-- Testing datetimeoffset adding interval +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(1); +go +~~START~~ +nvarchar +1901-05-06 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0,1); +go +~~START~~ +nvarchar +1900-06-06 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('1900-01-30 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0,1); +go +~~START~~ +nvarchar +1900-02-28 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('1900-12-31 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0,1); +go +~~START~~ +nvarchar +1901-01-31 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('2000-02-29 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(1,0); +go +~~START~~ +nvarchar +2001-02-28 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0,1,3); +go +~~START~~ +nvarchar +2030-06-27 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0,0,1); +go +~~START~~ +nvarchar +2030-05-13 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(1,0,3); +go +~~START~~ +nvarchar +2031-05-27 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(1, 2, 3, 4, 5, 6, 7); +go +~~START~~ +nvarchar +1901-08-01 03:05:36.9980000 -08:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(1, 2, 3, 4, 5, 6, 7); +go +~~START~~ +nvarchar +2031-08-01 03:05:36.9980000 -08:00 +~~END~~ + +-- SQL Server does not support named parameters in functions, only in prodecures +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0, 0, 0, 0, 0, 70); +go +~~START~~ +nvarchar +2030-05-06 23:09:29.9980000 -08:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0, 0, 0, 0, 0, -70); +go +~~START~~ +nvarchar +2030-05-06 20:49:29.9980000 -08:00 +~~END~~ + +-- Testing interval adding datetimeoffset +select make_interval(1) + CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset); +go +~~START~~ +nvarchar +1901-05-06 21:59:29.9980000 -08:00 +~~END~~ + +select make_interval(1, 2, 3, 4, 5, 6, 7) + CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) ; +go +~~START~~ +nvarchar +1901-08-01 03:05:36.9980000 -08:00 +~~END~~ + +select make_interval(0, 0, 0, 0, 0, 70) + CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset); +go +~~START~~ +nvarchar +2030-05-06 23:09:29.9980000 -08:00 +~~END~~ + +-- Testing datetimeoffset subtracting interval +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1); +go +~~START~~ +nvarchar +1899-05-06 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0,1); +go +~~START~~ +nvarchar +1900-04-06 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('1900-01-31 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0,1); +go +~~START~~ +nvarchar +1899-12-31 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('2000-02-29 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1,0); +go +~~START~~ +nvarchar +1999-02-28 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('2000-03-31 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1,0); +go +~~START~~ +nvarchar +1999-03-31 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('2050-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1); +go +~~START~~ +nvarchar +2049-05-06 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0,1,3); +go +~~START~~ +nvarchar +2030-03-16 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0,0,1); +go +~~START~~ +nvarchar +2030-04-29 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1,0,3); +go +~~START~~ +nvarchar +2029-04-15 21:59:29.9980000 -08:00 +~~END~~ + +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1, 2, 3, 4, 5, 6, 7); +go +~~START~~ +nvarchar +1899-02-09 16:53:22.9980000 -08:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1, 2, 3, 4, 5, 6, 7); +go +~~START~~ +nvarchar +2029-02-09 16:53:22.9980000 -08:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0, 0, 0, 0, 0, 70); +go +~~START~~ +nvarchar +2030-05-06 20:49:29.9980000 -08:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0, 0, 0, 0, 0, -70); +go +~~START~~ +nvarchar +2030-05-06 23:09:29.9980000 -08:00 +~~END~~ + +-- Testing datetimeoffset subtracting datetimeoffset +select CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) - CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset); +go +~~START~~ +text +-08:00:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset); +go +~~START~~ +text +08:00:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - CAST('2030-05-06 13:59:29.998 +8:20' AS datetimeoffset); +go +~~START~~ +text +16:20:00 +~~END~~ + +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - CAST('1992-05-06 13:20:29.998 +0:00' AS datetimeoffset); +go +~~START~~ +text +13879 days 08:39:00 +~~END~~ + +select CAST('0001-05-06 13:59:29.998 -8:00' AS datetimeoffset) - CAST('9950-05-06 13:20:29.998 +0:00' AS datetimeoffset); +go +~~START~~ +text +-3633796 days -15:21:00 +~~END~~ + + +-- Test date functions +select ISDATE('2030-05-06 13:59:29.998 -8:00'); +go +~~START~~ +int +1 +~~END~~ + +-- TODO Fix [BABEL-883] missing TDS support for type regtype (was pg_typeof produces error in sqlcmd) +select pg_typeof(sysdatetimeoffset()); +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data type regtype is not supported yet)~~ + + +-- Test data type precedence +select pg_typeof(c1) FROM (SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1 UNION SELECT CAST('2016-12-26 23:30:05' AS datetime) as C1) T; +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data type regtype is not supported yet)~~ + +select pg_typeof(c1) FROM (SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1 UNION SELECT CAST('2016-12-26 23:30:05' AS datetime2) as C1) T; +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data type regtype is not supported yet)~~ + +select pg_typeof(c1) FROM (SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1 UNION SELECT CAST('2016-12-26 23:30:05' AS smalldatetime) as C1) T; +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data type regtype is not supported yet)~~ + +select pg_typeof(c1) FROM (SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1 UNION SELECT CAST('23:30:05' AS time) as C1) T; +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data type regtype is not supported yet)~~ + +select pg_typeof(c1) FROM (SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1 UNION SELECT CAST('2016-12-26' AS date) as C1) T; +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data type regtype is not supported yet)~~ + +select pg_typeof(c1) FROM (SELECT CAST('2016-12-26 23:30:05' AS datetime) as C1 UNION SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset)as C1) T; +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data type regtype is not supported yet)~~ + +select pg_typeof(c1) FROM (SELECT CAST('2016-12-26 23:30:05' AS datetime2) as C1 UNION SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1) T; +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data type regtype is not supported yet)~~ + +select pg_typeof(c1) FROM (SELECT CAST('2016-12-26 23:30:05' AS smalldatetime) as C1 UNION SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1) T; +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data type regtype is not supported yet)~~ + +select pg_typeof(c1) FROM (SELECT CAST('23:30:05' AS time) as C1 UNION SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1) T; +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data type regtype is not supported yet)~~ + +select pg_typeof(c1) FROM (SELECT CAST('2016-12-26' AS date) as C1 UNION SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1) T; +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: data type regtype is not supported yet)~~ + + +-- test casting datetimeoffset inside procedure +-- NOTE: This is not supported behavior in tsql and will fail +DECLARE @dto datetimeoffset = CAST('2030-05-06 13:39:29.123456 +0:00' AS datetimeoffset); +exec TestDatetimeoffset_vu_prepare_cast @dto; +go +DECLARE @dto datetimeoffset = CAST('1920-05-06 13:39:29.123456 +0:00' AS datetimeoffset); +exec TestDatetimeoffset_vu_prepare_cast @dto; +go +-- expect error +DECLARE @dto datetimeoffset = CAST('19200-05-06 13:39:29.123456 +0:00' AS datetimeoffset); +exec TestDatetimeoffset_vu_prepare_cast @dto; +go +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type datetimeoffset: "19200-05-06 13:39:29.123456 +0:00")~~ + + +-- test comparing datetimeoffset inside procedure +DECLARE @dto datetimeoffset = CAST('2030-05-06 13:39:29.123456 +0:00' AS datetimeoffset); +exec TestDatetimeoffset_vu_prepare_cmp @dto; +go +DECLARE @dto datetimeoffset = CAST('1930-05-06 13:39:29.123456 +0:00' AS datetimeoffset); +exec TestDatetimeoffset_vu_prepare_cmp @dto; +go diff --git a/test/JDBC/expected/jtds-TestErrorsWithTryCatch.out b/test/JDBC/expected/jtds-TestErrorsWithTryCatch.out new file mode 100644 index 0000000000..e56025aaa1 --- /dev/null +++ b/test/JDBC/expected/jtds-TestErrorsWithTryCatch.out @@ -0,0 +1,1650 @@ +CREATE TABLE ErrorWithTryCatchTable (a varchar(15) UNIQUE NOT NULL, b nvarchar(25), c int PRIMARY KEY, d char(15) DEFAULT 'Whoops!', e nchar(25), f datetime, g numeric(4,1) CHECK (g >= 103.5)) +GO + +-- setup for "invalid characters found: cannot cast value "%s" to money" error +CREATE TABLE t293_1(a money, b int); +GO + +INSERT INTO t293_1(a, b) values ($100, 1), ($101, 2); +GO +~~ROW COUNT: 2~~ + + +-- setup for error "column \"%s\" of relation \"%s\" is a generated column" error +CREATE TABLE t1752_2(c1 INT, c2 INT, c3 as c1*c2) +GO + +-- setup for "A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations" error +CREATE TABLE t141_2(c1 int, c2 int); +GO + +-- Error: duplicate key value violates unique constraint +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +0 +~~END~~ + +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: duplicate key value violates unique constraint +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: duplicate key value violates unique constraint +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +0 +~~END~~ + +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: duplicate key value violates unique constraint +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: duplicate key value violates unique constraint +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: duplicate key value violates unique constraint +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + + + + +-- Error: check constraint violation +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +0 +~~END~~ + +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: check constraint violation +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: check constraint violation +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +0 +~~END~~ + +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: check constraint violation +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +-1 +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: Uncommittable transaction is detected at the end of the batch. The transaction is rolled back.)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: check constraint violation +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +-1 +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: Uncommittable transaction is detected at the end of the batch. The transaction is rolled back.)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: check constraint violation +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +-1 +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: Uncommittable transaction is detected at the end of the batch. The transaction is rolled back.)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + + + + + + + +-- Error: not null constraint violation +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +0 +~~END~~ + +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: not null constraint violation +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: not null constraint violation +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +0 +~~END~~ + +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: not null constraint violation +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: not null constraint violation +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: not null constraint violation +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + + + + + + + +-- Error: creating an existing table +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +0 +~~END~~ + +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: creating an existing table +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +-1 +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: Uncommittable transaction is detected at the end of the batch. The transaction is rolled back.)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: creating an existing table +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +0 +~~END~~ + +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: creating an existing table +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +-1 +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: Uncommittable transaction is detected at the end of the batch. The transaction is rolled back.)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: creating an existing table +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +-1 +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: Uncommittable transaction is detected at the end of the batch. The transaction is rolled back.)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: creating an existing table +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +-1 +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: Uncommittable transaction is detected at the end of the batch. The transaction is rolled back.)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + + + + + + + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +~~START~~ +smallint +0 +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_2" is a generated column)~~ + +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_2" is a generated column)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +0 +~~END~~ + +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + + +-- Error: "A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations" +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_2; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations" +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_2; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: "value for domain tinyint violates check constraint "tinyint_check"" +-- Simple error inside try-catch +BEGIN TRY + SELECT xact_state(); + DECLARE @a tinyint = 1000; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~START~~ +smallint +0 +~~END~~ + +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;'; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +0 +~~END~~ + +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;'; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +-1 +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: Uncommittable transaction is detected at the end of the batch. The transaction is rolled back.)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;';; +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +0 +~~END~~ + +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;'; +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +-1 +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: Uncommittable transaction is detected at the end of the batch. The transaction is rolled back.)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;'; + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +0 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +-1 +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: Uncommittable transaction is detected at the end of the batch. The transaction is rolled back.)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;'; + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +-1 +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: Uncommittable transaction is detected at the end of the batch. The transaction is rolled back.)~~ + +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- valid INSERT inside catch after an error +-- Simple batch with try catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END TRY +BEGIN CATCH + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Orange', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +select a from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar +Apple +Orange +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + +-- invalid INSERT inside catch after an error +-- Simple batch with try catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END TRY +BEGIN CATCH + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END CATCH; +GO +~~START~~ +smallint +1 +~~END~~ + +~~ROW COUNT: 1~~ + +~~START~~ +smallint +1 +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "errorwithtrycatchtable_a_key")~~ + +select a from ErrorWithTryCatchTable ORDER BY c +GO +~~START~~ +varchar +Apple +~~END~~ + +truncate table ErrorWithTryCatchTable +GO + + +DROP TABLE ErrorWithTryCatchTable +GO + +-- cleanup for "invalid characters found: cannot cast value "%s" to money" error +DROP TABLE t293_1; +GO + +-- cleanup for error "column \"%s\" of relation \"%s\" is a generated column" error +DROP TABLE t1752_2 +GO + +-- cleanup for "A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations" error +DROP TABLE t141_2; +GO + +while (@@trancount > 0) commit tran; +GO + diff --git a/test/JDBC/expected/jtds-TestSQLQueries.out b/test/JDBC/expected/jtds-TestSQLQueries.out new file mode 100644 index 0000000000..5b956e05cc --- /dev/null +++ b/test/JDBC/expected/jtds-TestSQLQueries.out @@ -0,0 +1,839 @@ +#1 CREATE TABLE with primary and unique keyword +EXEC sp_babelfish_configure 'babelfishpg_tsql.escape_hatch_unique_constraint', 'ignore'; +CREATE TABLE tmp(a int PRIMARY KEY, b int UNIQUE); +INSERT INTO tmp(a,b) values(1,1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) values(2,2); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int#!#int +1#!#1 +2#!#2 +~~END~~ + +DROP TABLE tmp; + +#2 2 table with foreign key relation +#CREATE TABLE tmp1(b int PRIMARY KEY); +#CREATE TABLE tmp2(a int PRIMARY KEY, b int FOREIGN KEY REFERENCES tmp1(b)); +#INSERT INTO tmp1(b) VALUES (1); +#INSERT INTO tmp2(a,b) values(1,1); +#SELECT * FROM tmp1; +#SELECT * FROM tmp2; +#DROP TABLE tmp2; +#DROP TABLE tmp1; + +#3 Repeated #2 with CONSTRAINT keyword +#CREATE TABLE tmp1(b int PRIMARY KEY); +#CREATE TABLE tmp2(a int, b int, PRIMARY KEY(a), CONSTRAINT FK_tmp FOREIGN KEY (b) REFERENCES tmp1(b)); +#INSERT INTO tmp1(b) VALUES (1); +#INSERT INTO tmp2(a,b) values(1,1); +#SELECT * FROM tmp1; +#SELECT * FROM tmp2; +#DROP TABLE tmp2; +#DROP TABLE tmp1; + +#4 CREATE TABLE with NOT NULL column +CREATE TABLE tmp(a int PRIMARY KEY,b int NOT NULL); +INSERT INTO tmp(a,b) values(1,1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) values(2,1); +~~ROW COUNT: 1~~ + +#INSERT INTO tmp(a,b) values(2,NULL); +SELECT * FROM tmp; +~~START~~ +int#!#int +1#!#1 +2#!#1 +~~END~~ + +DROP TABLE tmp; + +#5 INSERTION and DELETION +CREATE TABLE tmp(a int PRIMARY KEY); +INSERT INTO tmp(a) VALUES(1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a) VALUES(2); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a) VALUES(3); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a) VALUES(4); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a) VALUES(5); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int +1 +2 +3 +4 +5 +~~END~~ + +DELETE FROM tmp WHERE a>2; +~~ROW COUNT: 3~~ + +SELECT * FROM tmp; +~~START~~ +int +1 +2 +~~END~~ + +DROP TABLE tmp; + +#6 IS NOT NULL condition in WHERE clause +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) values(1,1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) values(2,1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) values(3,NULL); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) values(4,NULL); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp WHERE b IS NOT NULL; +~~START~~ +int#!#int +1#!#1 +2#!#1 +~~END~~ + +DROP TABLE tmp; + +#7 Add new column using ALTER TABLE +CREATE TABLE tmp(a int PRIMARY KEY); +INSERT INTO tmp(a) VALUES(1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a) VALUES(2); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int +1 +2 +~~END~~ + +ALTER TABLE tmp ADD b VARCHAR(20) NULL; +SELECT * FROM tmp; +~~START~~ +int#!#varchar +1#!# +2#!# +~~END~~ + +INSERT INTO tmp(a,b) VALUES(4,'Dipesh'); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(5,' Dipesh'); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int#!#varchar +1#!# +2#!# +4#!#Dipesh +5#!# Dipesh +~~END~~ + +DROP TABLE tmp; + +#8 Repeated #8 with default value for newly added col +CREATE TABLE tmp(a int PRIMARY KEY); +INSERT INTO tmp(a) VALUES(1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a) VALUES(2); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int +1 +2 +~~END~~ + +ALTER TABLE tmp ADD b VARCHAR(20) DEFAULT 'Dipesj'; +SELECT * FROM tmp; +~~START~~ +int#!#varchar +1#!#Dipesj +2#!#Dipesj +~~END~~ + +INSERT INTO tmp(a,b) VALUES(4,'Dipesh'); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(5,' Dipesh'); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int#!#varchar +1#!#Dipesj +2#!#Dipesj +4#!#Dipesh +5#!# Dipesh +~~END~~ + +DROP TABLE tmp; + +#9 Change datatype of existing column using ALTER TABLE +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(2,2); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int#!#int +1#!#1 +2#!#2 +~~END~~ + +ALTER TABLE tmp ALTER COLUMN b VARCHAR(10); +SELECT * FROM tmp; +~~START~~ +int#!#varchar +1#!#1 +2#!#2 +~~END~~ + +INSERT INTO tmp(a,b) VALUES(4,'Dipesh'); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(5,' Dipesh'); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int#!#varchar +1#!#1 +2#!#2 +4#!#Dipesh +5#!# Dipesh +~~END~~ + +DROP TABLE tmp; + +#10 UPDATE TABLE with fancy condition +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(2,2); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(3,3); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(4,4); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(5,5); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int#!#int +1#!#1 +2#!#2 +3#!#3 +4#!#4 +5#!#5 +~~END~~ + +UPDATE tmp SET b=b+1 WHERE b>2; +~~ROW COUNT: 3~~ + +SELECT * FROM tmp; +~~START~~ +int#!#int +1#!#1 +2#!#2 +3#!#4 +4#!#5 +5#!#6 +~~END~~ + +DROP TABLE tmp; + +#11 DROP some column using ALTER TABLE +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(2,2); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(3,3); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(4,4); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(5,5); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int#!#int +1#!#1 +2#!#2 +3#!#3 +4#!#4 +5#!#5 +~~END~~ + +#ALTER TABLE tmp DROP COLUMN b; +#INSERT INTO tmp(a) values (6); +#SELECT * FROM tmp; +DROP TABLE tmp; + +#12 CREATE TABLE with fancy constraint +CREATE TABLE tmp(a int PRIMARY KEY CHECK (a>10),b int); +INSERT INTO tmp(a,b) VALUES(11,1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(12,2); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(13,3); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(14,4); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(15,5); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int#!#int +11#!#1 +12#!#2 +13#!#3 +14#!#4 +15#!#5 +~~END~~ + +DROP TABLE tmp; + +#CREATE PROCEDURE tmp AS +#BEGIN +# CREATE TABLE dip(a int PRIMARY KEY CHECK (a>10),b int); +# INSERT INTO dip(a,b) VALUES(11,1); +# INSERT INTO dip(a,b) VALUES(12,2); +# INSERT INTO dip(a,b) VALUES(13,3); +# INSERT INTO dip(a,b) VALUES(14,4); +# INSERT INTO dip(a,b) VALUES(15,5); +# SELECT * FROM dip; +# DROP TABLE dip; +#END; + +#13 invoke simple stored procedure using EXECUTE +EXECUTE tmp; +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: procedure tmp() does not exist)~~ + + +#14 invoke simple stored procedure using EXEC +EXEC tmp; +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: procedure tmp() does not exist)~~ + + +#DROP PROCEDURE tmp; + +#15 UPDATE rows in existing table +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1),(2,2),(3,3),(4,4),(5,5); +~~ROW COUNT: 5~~ + +SELECT * FROM tmp; +~~START~~ +int#!#int +1#!#1 +2#!#2 +3#!#3 +4#!#4 +5#!#5 +~~END~~ + +UPDATE tmp SET b=b*2+1 WHERE (a>2); +~~ROW COUNT: 3~~ + +SELECT * FROM tmp; +~~START~~ +int#!#int +1#!#1 +2#!#2 +3#!#7 +4#!#9 +5#!#11 +~~END~~ + +DROP TABLE tmp; + +#16 TRUNCATE table +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1),(2,2),(3,3),(4,4),(5,5); +~~ROW COUNT: 5~~ + +SELECT * FROM tmp; +~~START~~ +int#!#int +1#!#1 +2#!#2 +3#!#3 +4#!#4 +5#!#5 +~~END~~ + +TRUNCATE TABLE tmp; +SELECT * FROM tmp; +~~START~~ +int#!#int +~~END~~ + +DROP TABLE tmp; + +CREATE TABLE temp1 (i INT,j INT,t TEXT); + +CREATE TABLE temp2 ( i INT,k INT); + +INSERT INTO temp1 VALUES (1, 4, 'one'); +~~ROW COUNT: 1~~ + +INSERT INTO temp1 VALUES (2, 3, 'two'); +~~ROW COUNT: 1~~ + +INSERT INTO temp1 VALUES (3, 2, 'three'); +~~ROW COUNT: 1~~ + +INSERT INTO temp1 VALUES (4, 1, 'four'); +~~ROW COUNT: 1~~ + +INSERT INTO temp1 VALUES (5, 0, 'five'); +~~ROW COUNT: 1~~ + +INSERT INTO temp1 VALUES (6, 6, 'six'); +~~ROW COUNT: 1~~ + +INSERT INTO temp1 VALUES (7, 7, 'seven'); +~~ROW COUNT: 1~~ + +INSERT INTO temp1 VALUES (8, 8, 'eight'); +~~ROW COUNT: 1~~ + +INSERT INTO temp1 VALUES (0, NULL, 'zero'); +~~ROW COUNT: 1~~ + +INSERT INTO temp1 VALUES (NULL, NULL, NULL); +~~ROW COUNT: 1~~ + +INSERT INTO temp1 VALUES (NULL, 0, 'zero'); +~~ROW COUNT: 1~~ + + +INSERT INTO temp2 VALUES (1, -1); +~~ROW COUNT: 1~~ + +INSERT INTO temp2 VALUES (2, 2); +~~ROW COUNT: 1~~ + +INSERT INTO temp2 VALUES (3, -3); +~~ROW COUNT: 1~~ + +INSERT INTO temp2 VALUES (2, 4); +~~ROW COUNT: 1~~ + +INSERT INTO temp2 VALUES (5, -5); +~~ROW COUNT: 1~~ + +INSERT INTO temp2 VALUES (5, -5); +~~ROW COUNT: 1~~ + +INSERT INTO temp2 VALUES (0, NULL); +~~ROW COUNT: 1~~ + +INSERT INTO temp2 VALUES (NULL, NULL); +~~ROW COUNT: 1~~ + +INSERT INTO temp2 VALUES (NULL, 0); +~~ROW COUNT: 1~~ + + +#17 CROSS JOIN +SELECT * FROM temp1 CROSS JOIN temp2; +~~START~~ +int#!#int#!#text#!#int#!#int +1#!#4#!#one#!#1#!#-1 +2#!#3#!#two#!#1#!#-1 +3#!#2#!#three#!#1#!#-1 +4#!#1#!#four#!#1#!#-1 +5#!#0#!#five#!#1#!#-1 +6#!#6#!#six#!#1#!#-1 +7#!#7#!#seven#!#1#!#-1 +8#!#8#!#eight#!#1#!#-1 +0#!##!#zero#!#1#!#-1 +#!##!##!#1#!#-1 +#!#0#!#zero#!#1#!#-1 +1#!#4#!#one#!#2#!#2 +2#!#3#!#two#!#2#!#2 +3#!#2#!#three#!#2#!#2 +4#!#1#!#four#!#2#!#2 +5#!#0#!#five#!#2#!#2 +6#!#6#!#six#!#2#!#2 +7#!#7#!#seven#!#2#!#2 +8#!#8#!#eight#!#2#!#2 +0#!##!#zero#!#2#!#2 +#!##!##!#2#!#2 +#!#0#!#zero#!#2#!#2 +1#!#4#!#one#!#3#!#-3 +2#!#3#!#two#!#3#!#-3 +3#!#2#!#three#!#3#!#-3 +4#!#1#!#four#!#3#!#-3 +5#!#0#!#five#!#3#!#-3 +6#!#6#!#six#!#3#!#-3 +7#!#7#!#seven#!#3#!#-3 +8#!#8#!#eight#!#3#!#-3 +0#!##!#zero#!#3#!#-3 +#!##!##!#3#!#-3 +#!#0#!#zero#!#3#!#-3 +1#!#4#!#one#!#2#!#4 +2#!#3#!#two#!#2#!#4 +3#!#2#!#three#!#2#!#4 +4#!#1#!#four#!#2#!#4 +5#!#0#!#five#!#2#!#4 +6#!#6#!#six#!#2#!#4 +7#!#7#!#seven#!#2#!#4 +8#!#8#!#eight#!#2#!#4 +0#!##!#zero#!#2#!#4 +#!##!##!#2#!#4 +#!#0#!#zero#!#2#!#4 +1#!#4#!#one#!#5#!#-5 +2#!#3#!#two#!#5#!#-5 +3#!#2#!#three#!#5#!#-5 +4#!#1#!#four#!#5#!#-5 +5#!#0#!#five#!#5#!#-5 +6#!#6#!#six#!#5#!#-5 +7#!#7#!#seven#!#5#!#-5 +8#!#8#!#eight#!#5#!#-5 +0#!##!#zero#!#5#!#-5 +#!##!##!#5#!#-5 +#!#0#!#zero#!#5#!#-5 +1#!#4#!#one#!#5#!#-5 +2#!#3#!#two#!#5#!#-5 +3#!#2#!#three#!#5#!#-5 +4#!#1#!#four#!#5#!#-5 +5#!#0#!#five#!#5#!#-5 +6#!#6#!#six#!#5#!#-5 +7#!#7#!#seven#!#5#!#-5 +8#!#8#!#eight#!#5#!#-5 +0#!##!#zero#!#5#!#-5 +#!##!##!#5#!#-5 +#!#0#!#zero#!#5#!#-5 +1#!#4#!#one#!#0#!# +2#!#3#!#two#!#0#!# +3#!#2#!#three#!#0#!# +4#!#1#!#four#!#0#!# +5#!#0#!#five#!#0#!# +6#!#6#!#six#!#0#!# +7#!#7#!#seven#!#0#!# +8#!#8#!#eight#!#0#!# +0#!##!#zero#!#0#!# +#!##!##!#0#!# +#!#0#!#zero#!#0#!# +1#!#4#!#one#!##!# +2#!#3#!#two#!##!# +3#!#2#!#three#!##!# +4#!#1#!#four#!##!# +5#!#0#!#five#!##!# +6#!#6#!#six#!##!# +7#!#7#!#seven#!##!# +8#!#8#!#eight#!##!# +0#!##!#zero#!##!# +#!##!##!##!# +#!#0#!#zero#!##!# +1#!#4#!#one#!##!#0 +2#!#3#!#two#!##!#0 +3#!#2#!#three#!##!#0 +4#!#1#!#four#!##!#0 +5#!#0#!#five#!##!#0 +6#!#6#!#six#!##!#0 +7#!#7#!#seven#!##!#0 +8#!#8#!#eight#!##!#0 +0#!##!#zero#!##!#0 +#!##!##!##!#0 +#!#0#!#zero#!##!#0 +~~END~~ + + +#18 INNER JOIN +SELECT temp1.i, temp1.j, temp1.t, temp2.k FROM temp1 INNER JOIN temp2 ON temp1.i=temp2.i ORDER BY temp1.i; +~~START~~ +int#!#int#!#text#!#int +0#!##!#zero#!# +1#!#4#!#one#!#-1 +2#!#3#!#two#!#4 +2#!#3#!#two#!#2 +3#!#2#!#three#!#-3 +5#!#0#!#five#!#-5 +5#!#0#!#five#!#-5 +~~END~~ + +SELECT temp1.i, temp1.j, temp1.t, temp2.k FROM temp1 JOIN temp2 ON temp1.i=temp2.i ORDER BY temp1.i; +~~START~~ +int#!#int#!#text#!#int +0#!##!#zero#!# +1#!#4#!#one#!#-1 +2#!#3#!#two#!#4 +2#!#3#!#two#!#2 +3#!#2#!#three#!#-3 +5#!#0#!#five#!#-5 +5#!#0#!#five#!#-5 +~~END~~ + + +#19 LEFT JOIN +SELECT * FROM temp1 LEFT OUTER JOIN temp2 ON temp1.i=temp2.k ORDER BY temp1.i; +~~START~~ +int#!#int#!#text#!#int#!#int +#!#0#!#zero#!##!# +#!##!##!##!# +0#!##!#zero#!##!#0 +1#!#4#!#one#!##!# +2#!#3#!#two#!#2#!#2 +3#!#2#!#three#!##!# +4#!#1#!#four#!#2#!#4 +5#!#0#!#five#!##!# +6#!#6#!#six#!##!# +7#!#7#!#seven#!##!# +8#!#8#!#eight#!##!# +~~END~~ + + +#20 RIGHT JOIN +SELECT * FROM temp1 RIGHT OUTER JOIN temp2 ON temp1.i=temp2.i ORDER BY temp1.i, temp2.k; +~~START~~ +int#!#int#!#text#!#int#!#int +#!##!##!##!# +#!##!##!##!#0 +0#!##!#zero#!#0#!# +1#!#4#!#one#!#1#!#-1 +2#!#3#!#two#!#2#!#2 +2#!#3#!#two#!#2#!#4 +3#!#2#!#three#!#3#!#-3 +5#!#0#!#five#!#5#!#-5 +5#!#0#!#five#!#5#!#-5 +~~END~~ + + +#21 FULL OUTER JOIN +SELECT * FROM temp1,temp2; +~~START~~ +int#!#int#!#text#!#int#!#int +1#!#4#!#one#!#1#!#-1 +2#!#3#!#two#!#1#!#-1 +3#!#2#!#three#!#1#!#-1 +4#!#1#!#four#!#1#!#-1 +5#!#0#!#five#!#1#!#-1 +6#!#6#!#six#!#1#!#-1 +7#!#7#!#seven#!#1#!#-1 +8#!#8#!#eight#!#1#!#-1 +0#!##!#zero#!#1#!#-1 +#!##!##!#1#!#-1 +#!#0#!#zero#!#1#!#-1 +1#!#4#!#one#!#2#!#2 +2#!#3#!#two#!#2#!#2 +3#!#2#!#three#!#2#!#2 +4#!#1#!#four#!#2#!#2 +5#!#0#!#five#!#2#!#2 +6#!#6#!#six#!#2#!#2 +7#!#7#!#seven#!#2#!#2 +8#!#8#!#eight#!#2#!#2 +0#!##!#zero#!#2#!#2 +#!##!##!#2#!#2 +#!#0#!#zero#!#2#!#2 +1#!#4#!#one#!#3#!#-3 +2#!#3#!#two#!#3#!#-3 +3#!#2#!#three#!#3#!#-3 +4#!#1#!#four#!#3#!#-3 +5#!#0#!#five#!#3#!#-3 +6#!#6#!#six#!#3#!#-3 +7#!#7#!#seven#!#3#!#-3 +8#!#8#!#eight#!#3#!#-3 +0#!##!#zero#!#3#!#-3 +#!##!##!#3#!#-3 +#!#0#!#zero#!#3#!#-3 +1#!#4#!#one#!#2#!#4 +2#!#3#!#two#!#2#!#4 +3#!#2#!#three#!#2#!#4 +4#!#1#!#four#!#2#!#4 +5#!#0#!#five#!#2#!#4 +6#!#6#!#six#!#2#!#4 +7#!#7#!#seven#!#2#!#4 +8#!#8#!#eight#!#2#!#4 +0#!##!#zero#!#2#!#4 +#!##!##!#2#!#4 +#!#0#!#zero#!#2#!#4 +1#!#4#!#one#!#5#!#-5 +2#!#3#!#two#!#5#!#-5 +3#!#2#!#three#!#5#!#-5 +4#!#1#!#four#!#5#!#-5 +5#!#0#!#five#!#5#!#-5 +6#!#6#!#six#!#5#!#-5 +7#!#7#!#seven#!#5#!#-5 +8#!#8#!#eight#!#5#!#-5 +0#!##!#zero#!#5#!#-5 +#!##!##!#5#!#-5 +#!#0#!#zero#!#5#!#-5 +1#!#4#!#one#!#5#!#-5 +2#!#3#!#two#!#5#!#-5 +3#!#2#!#three#!#5#!#-5 +4#!#1#!#four#!#5#!#-5 +5#!#0#!#five#!#5#!#-5 +6#!#6#!#six#!#5#!#-5 +7#!#7#!#seven#!#5#!#-5 +8#!#8#!#eight#!#5#!#-5 +0#!##!#zero#!#5#!#-5 +#!##!##!#5#!#-5 +#!#0#!#zero#!#5#!#-5 +1#!#4#!#one#!#0#!# +2#!#3#!#two#!#0#!# +3#!#2#!#three#!#0#!# +4#!#1#!#four#!#0#!# +5#!#0#!#five#!#0#!# +6#!#6#!#six#!#0#!# +7#!#7#!#seven#!#0#!# +8#!#8#!#eight#!#0#!# +0#!##!#zero#!#0#!# +#!##!##!#0#!# +#!#0#!#zero#!#0#!# +1#!#4#!#one#!##!# +2#!#3#!#two#!##!# +3#!#2#!#three#!##!# +4#!#1#!#four#!##!# +5#!#0#!#five#!##!# +6#!#6#!#six#!##!# +7#!#7#!#seven#!##!# +8#!#8#!#eight#!##!# +0#!##!#zero#!##!# +#!##!##!##!# +#!#0#!#zero#!##!# +1#!#4#!#one#!##!#0 +2#!#3#!#two#!##!#0 +3#!#2#!#three#!##!#0 +4#!#1#!#four#!##!#0 +5#!#0#!#five#!##!#0 +6#!#6#!#six#!##!#0 +7#!#7#!#seven#!##!#0 +8#!#8#!#eight#!##!#0 +0#!##!#zero#!##!#0 +#!##!##!##!#0 +#!#0#!#zero#!##!#0 +~~END~~ + + +DROP TABLE temp1; +DROP TABLE temp2; + +#22 dropping all columns +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(2,2); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(3,3); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(4,4); +~~ROW COUNT: 1~~ + +INSERT INTO tmp(a,b) VALUES(5,5); +~~ROW COUNT: 1~~ + +SELECT * FROM tmp; +~~START~~ +int#!#int +1#!#1 +2#!#2 +3#!#3 +4#!#4 +5#!#5 +~~END~~ + +#ALTER TABLE tmp DROP COLUMN b; +#ALTER TABLE tmp DROP COLUMN a; +#SELECT * FROM tmp; +DROP TABLE tmp; + +#23 +CREATE TABLE DATE_dt (a DATE); +INSERT INTO DATE_dt(a) values('2000-12-13'); +~~ROW COUNT: 1~~ + +INSERT INTO DATE_dt(a) values('1900-02-28'); +~~ROW COUNT: 1~~ + +INSERT INTO DATE_dt(a) values('0001-01-01'); +~~ROW COUNT: 1~~ + +INSERT INTO DATE_dt(a) values('9999-12-31'); +~~ROW COUNT: 1~~ + +INSERT INTO DATE_dt(a) values(NULL); +~~ROW COUNT: 1~~ + +SELECT * FROM DATE_dt; +~~START~~ +nvarchar +2000-12-13 +1900-02-28 +0001-01-01 +9999-12-31 + +~~END~~ + +ALTER TABLE DATE_dt ALTER COLUMN a DATETIME; +~~ERROR (Code: 517)~~ + +~~ERROR (Message: data out of range for datetime)~~ + +SELECT * FROM DATE_dt; +~~START~~ +nvarchar +2000-12-13 +1900-02-28 +0001-01-01 +9999-12-31 + +~~END~~ + +DROP TABLE DATE_dt; +EXEC sp_babelfish_configure 'babelfishpg_tsql.escape_hatch_unique_constraint', 'strict'; diff --git a/test/JDBC/expected/jtds-TestSQLVariant-vu-cleanup.out b/test/JDBC/expected/jtds-TestSQLVariant-vu-cleanup.out new file mode 100644 index 0000000000..3e78704b93 --- /dev/null +++ b/test/JDBC/expected/jtds-TestSQLVariant-vu-cleanup.out @@ -0,0 +1,78 @@ +drop table testsqlvariant_sourceTable1; +go + +drop table testsqlvariant_sourceTable2; +go + + +drop table testsqlvariant_sourceTable3; +go + +drop table testsqlvariant_sourceTable4; +go + +drop table testsqlvariant_sourceTable5; +go + +drop table testsqlvariant_sourceTable6; +go + +drop table testsqlvariant_sourceTable7; +go + + +DROP TABLE testsqlvariant_money_dt; +go + +drop table testsqlvariant_sourceTable8; +go + + +drop table testsqlvariant_sourceTable9; +go + + +drop table testsqlvariant_sourceTable10; +go + +drop table testsqlvariant_sourceTable11; +go + +drop table testsqlvariant_sourceTable12; +go + +drop table testsqlvariant_sourceTable13; +go + +drop table testsqlvariant_sourceTable14; +go + +drop table testsqlvariant_sourceTable15; +go + +drop table testsqlvariant_sourceTable16; +go + +drop table testsqlvariant_sourceTable17; +go + +drop table testsqlvariant_sourceTable18; +go + +drop table testsqlvariant_sourceTable19; +go + +drop table testsqlvariant_sourceTable20; +go + +drop table testsqlvariant_sourceTable21; +go + +drop view testsqlvariant_vu_prepare_view1; +go + +drop view testsqlvariant_vu_prepare_view2; +go + +drop table testsqlvariant_sourceTable22; +go diff --git a/test/JDBC/expected/jtds-TestSQLVariant-vu-prepare.out b/test/JDBC/expected/jtds-TestSQLVariant-vu-prepare.out new file mode 100644 index 0000000000..b5450eb917 --- /dev/null +++ b/test/JDBC/expected/jtds-TestSQLVariant-vu-prepare.out @@ -0,0 +1,455 @@ + + +--[BABEL-582]Checking all base datatypes for sql_variant +--The following list of base datatypes cannot be stored by using sql_variant: +--[datetimeoffset(SQL server 2012), geography, geometry, hierarchyid, image, ntext, nvarchar(max), +--rowversion (timestamp), text, varchar(max), varbinary(max), User-defined types, xml] +Create table testsqlvariant_sourceTable1(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable1 values (cast (1 as BIT),cast (1 as BIT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable1 values (cast (NULL as BIT), cast (0 as BIT)); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable2(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable2 values (cast (0 as TINYINT),cast (10 as TINYINT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable2 values (cast (002 as TINYINT),cast (029 as TINYINT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable2 values (cast (004 as TINYINT),cast (87 as TINYINT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable2 values (cast (255 as TINYINT),cast (1000 as TINYINT)); +go +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain tinyint violates check constraint "tinyint_check")~~ + +Insert into testsqlvariant_sourceTable2 values (cast (NULL as TINYINT), cast (100 as TINYINT)); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable3(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable3 values (cast (0 as SMALLINT),cast (-10 as SMALLINT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable3 values (cast (002 as SMALLINT),cast (-029 as SMALLINT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable3 values (cast (876 as SMALLINT),cast (-1234 as SMALLINT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable3 values (cast (-32768 as SMALLINT),cast (32767 as SMALLINT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable3 values (cast (NULL as SMALLINT), cast (100 as SMALLINT)); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable4(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable4 values (cast (0 as INT),cast (-10 as INT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable4 values (cast (-12345 as INT),cast (10 as INT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable4 values (cast (004 as INT),cast (224466 as INT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable4 values (cast (-2147483648 as INT),cast (2147483647 as INT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable4 values (cast (NULL as INT), cast (100 as INT)); +go +~~ROW COUNT: 1~~ + + + +Create table testsqlvariant_sourceTable5(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable5 values (cast (0 as BIGINT),cast (-120 as BIGINT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable5 values (cast (-12345 as BIGINT),cast (00100 as BIGINT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable5 values (cast (-12245532534 as BIGINT),cast (00000000000000086 as BIGINT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable5 values (cast (-9223372036854775808 as BIGINT),cast (9223372036854775807 as BIGINT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable5 values (cast (NULL as BIGINT), cast (-004 as BIGINT)); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable6(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable6 values (cast (0 as REAL),cast (1.050 as REAL)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable6 values (cast (-004 as REAL),cast (01.05 as REAL)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable6 values (cast (00000000000000086 as REAL),cast (-0122455324.5 as REAL)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable6 values (cast (3.40E+38 as REAL),cast (-3.40E+38 as REAL)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable6 values (cast (NULL as REAL), cast (-000002 as REAL)); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable7(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable7 values (cast (0 as FLOAT),cast (1.050 as FLOAT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable7 values (cast (-0012345234.5 as FLOAT),cast (01.05 as FLOAT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable7 values (cast (00000000000086 as FLOAT),cast (-00000002 as FLOAT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable7 values (cast (-1.79E+308 as FLOAT),cast (1.79E+308 as FLOAT)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable7 values (cast (NULL as FLOAT), cast (100 as FLOAT)); +go +~~ROW COUNT: 1~~ + + +CREATE TABLE testsqlvariant_money_dt(a sql_variant, b sql_variant); +go +prepst#!#INSERT INTO testsqlvariant_money_dt(a, b) VALUES (?, ?) #!#smallmoney|-|a|-|100.5#!#money|-|b|-|10.05 +~~ROW COUNT: 1~~ + +go +prepst#!#exec#!#smallmoney|-|a|-|10#!#money|-|b|-|10 +~~ROW COUNT: 1~~ + +go +prepst#!#exec#!#smallmoney|-|a|-|-10.05 #!#money|-|b|-|-10.0 +~~ROW COUNT: 1~~ + +go +prepst#!#exec#!#smallmoney|-|a|-|-214748.3648#!#money|-|b|-|-922337203685477.5808 +~~ROW COUNT: 1~~ + +go +prepst#!#exec#!#smallmoney|-|a|-|214748.3647#!#money|-|b|-|22337203685477.5807 +~~ROW COUNT: 1~~ + +go +prepst#!#exec#!#smallmoney|-|a|-|214748.3647#!#money|-|b|-|22337203685477.5807 +~~ROW COUNT: 1~~ + +go +prepst#!#exec#!#smallmoney|-|a|-|-214,748.3648#!#money|-|b|-|-922,337,203,685,477.5808 +~~ROW COUNT: 1~~ + +go +prepst#!#exec#!#smallmoney|-|a|-|214,748.3647#!#money|-|b|-|922,337,203,685,477.5807 +~~ROW COUNT: 1~~ + +go +prepst#!#exec#!#smallmoney|-|a|-|214,748.3647#!#money|-|b|-|922,337,203,685,477.5807 +~~ROW COUNT: 1~~ + +go +prepst#!#exec#!#smallmoney|-|a|-|#!#money|-|b|-| +~~ROW COUNT: 1~~ + +go + +Create table testsqlvariant_sourceTable8(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable8 values (cast (0 as MONEY),cast ('$1050' as MONEY)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable8 values (cast (NULL as MONEY), cast (-000002 as MONEY)); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable9(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable9 values (cast (0 as SMALLMONEY),cast ('$1050' as SMALLMONEY)); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable9 values (cast (NULL as SMALLMONEY), cast (-000002 as SMALLMONEY)); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable10(a sql_variant, b sql_variant not null); +go +INSERT INTO testsqlvariant_sourceTable10 values(CAST('2000-12-13' as DATE), CAST('1900-02-28' as DATE)) +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable10 values(CAST(NULL as DATE), CAST('0001-01-01' as DATE)) +go +~~ROW COUNT: 1~~ + + + +Create table testsqlvariant_sourceTable11(a sql_variant, b sql_variant not null); +go +INSERT INTO testsqlvariant_sourceTable11 values(CAST('2007-05-08 12:35:29' as SMALLDATETIME), CAST('2007-05-08 12:35:30' as SMALLDATETIME)) +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable11 values(CAST('2007-05-08 12:59:59.998' as SMALLDATETIME), CAST('2000-02-28 23:59:59.999' as SMALLDATETIME)) +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable11 values(CAST('1900-02-28 23:59:59.999' as SMALLDATETIME), CAST('2000-02-28 23:45:29.999' as SMALLDATETIME)) +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable11 values(CAST(NULL as SMALLDATETIME), CAST('1900-01-01 00:00:00' as SMALLDATETIME)) +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable12(a sql_variant, b sql_variant not null); +go +INSERT INTO testsqlvariant_sourceTable12 values(CAST('2000-12-13 12:58:23.123' as DATETIME), CAST('1900-02-28 23:59:59.989' as DATETIME)) +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable12 values(CAST('1900-02-28 23:59:59.990' as DATETIME), CAST('1900-02-28 23:59:59.992' as DATETIME)) +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable12 values(CAST('1900-02-28 23:59:59.994' as DATETIME), CAST('1900-02-28 23:59:59.996' as DATETIME)) +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable12 values(CAST('1900-02-28 23:59:59.998' as DATETIME), CAST('1753-01-01 00:00:00.000' as DATETIME)) +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable12 values(CAST(NULL as DATETIME), CAST('9999-12-31 23:59:59.997' as DATETIME)) +go +~~ROW COUNT: 1~~ + + + +Create table testsqlvariant_sourceTable13(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable13 values (cast ('Satarupa' as CHAR(24)),cast (' Satarupa' as CHAR(24))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable13 values (cast ('' as CHAR(24)),cast (' S,B' as CHAR(24))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable13 values (cast (NULL as CHAR(24)), cast (' ' as CHAR(24))); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable14(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable14 values (cast ('Satarupa' as NCHAR(24)),cast (' Satarupa' as NCHAR(24))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable14 values (cast ('' as NCHAR(24)),cast (' S,B' as NCHAR(24))); +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable14 values(cast (' dthdcjdfjwf dwfw fgegegeg' as NCHAR(24)), cast ('😊😋😎😍😅😆' as NCHAR(24))) +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable14 values (cast (NULL as NCHAR(24)), cast (' ' as NCHAR(24))); +go +~~ROW COUNT: 1~~ + + + +Create table testsqlvariant_sourceTable15(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable15 values (cast ('Satarupa' as NVARCHAR(24)),cast (' Satarupa' as NVARCHAR(24))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable15 values (cast ('' as NVARCHAR(24)),cast (' S,B' as NVARCHAR(24))); +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable15 values(cast (' dthdcjdfjwf dwfw fgegegeg' as NVARCHAR(24)), cast ('😊😋😎😍😅😆' as NVARCHAR(24))) +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable15 values (cast (NULL as NVARCHAR(24)), cast (' ' as NVARCHAR(24))); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable16(a sql_variant, b sql_variant not null); +go +INSERT INTO testsqlvariant_sourceTable16 values(CAST('51f178a6-53c7-472c-9be1-1c08942342d7' as uniqueidentifier), CAST('bab96bc8-60b9-40dd-b0de-c90a80f5739e' as uniqueidentifier)) +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable16 values(CAST('dba2726c-2131-409f-aefa-5c8079571623' as uniqueidentifier), CAST('51f178a6-53c7-472c-9be1-1c08942342d7thisIsTooLong' as uniqueidentifier)) +go +~~ROW COUNT: 1~~ + +INSERT INTO testsqlvariant_sourceTable16 values(NULL, CAST('60aeaa5c-e272-4b17-bad0-c25710fd7a60' as uniqueidentifier)) +go +~~ROW COUNT: 1~~ + + + +Create table testsqlvariant_sourceTable17(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable17 values (cast ('Delhi' as VARCHAR(24)),cast (' Surat' as VARCHAR(24))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable17 values (cast ('' as VARCHAR(24)),cast (' S,B' as VARCHAR(24))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable17 values (cast (NULL as VARCHAR(24)), cast (' ' as VARCHAR(24))); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable18(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable18 values (cast ('Delhi' as char(24)),cast (' Surat' as char(24))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable18 values (cast ('' as char(24)),cast (' S,B' as char(24))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable18 values (cast (NULL as char(24)), cast (' ' as char(24))); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable19(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable19 values (cast (123.456 as numeric(5,2)), cast (123.4 as numeric(5,2))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable19 values (cast (NULL as numeric(5,2)), cast (123 as numeric(5,2))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable19 values (cast (-123.456 as numeric(5,2)), cast (-123 as numeric(5,2))); +go +~~ROW COUNT: 1~~ + + +Create table testsqlvariant_sourceTable20(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable20 values (cast (123.456 as decimal(5,2)), cast (123.4 as decimal(5,2))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable20 values (cast (NULL as decimal(5,2)), cast (123 as decimal(5,2))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable20 values (cast (-123.456 as decimal(5,2)), cast (-123 as decimal(5,2))); +go +~~ROW COUNT: 1~~ + + + +Create table testsqlvariant_sourceTable21(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable21 values (cast ('12:45:37.123' as time(0)), cast ('12:45:37.123' as time(1))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable21 values (cast (NULL as time(3)), cast ('12:45:37.123' as time(2))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable21 values (cast ('12:45:37.123' as time(3)), cast ('12:45:37.1234' as time(4))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable21 values (cast ('12:45:37.12345' as time(5)), cast ('12:45:37.123456' as time(6))); +go +~~ROW COUNT: 1~~ + + + +Create table testsqlvariant_sourceTable22(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable22 values (cast ('2016-10-23 12:45:37.123' as datetime2(0)), cast ('2016-10-23 12:45:37.123' as datetime2(1))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable22 values (cast (NULL as datetime2(3)), cast ('2016-10-23 12:45:37.123' as datetime2(2))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable22 values (cast ('2016-10-23 12:45:37.123' as datetime2(3)), cast ('2016-10-23 12:45:37.1234' as datetime2(4))); +go +~~ROW COUNT: 1~~ + +Insert into testsqlvariant_sourceTable22 values (cast ('2016-10-23 12:45:37.12345' as datetime2(5)), cast ('2016-10-23 12:45:37.123456' as datetime2(6))); +go +~~ROW COUNT: 1~~ + + +-- Test sql_variant cast (Test for BABEL-3404) +CREATE VIEW testsqlvariant_vu_prepare_view1 AS SELECT CAST('abc' AS sql_variant) AS col; +go + +-- Test sql_variant comparison function +CREATE VIEW testsqlvariant_vu_prepare_view2 AS SELECT CASE WHEN a > b THEN a ELSE b END AS val FROM testsqlvariant_sourceTable22; +go diff --git a/test/JDBC/expected/jtds-TestSQLVariant-vu-verify.out b/test/JDBC/expected/jtds-TestSQLVariant-vu-verify.out new file mode 100644 index 0000000000..1bb9057017 --- /dev/null +++ b/test/JDBC/expected/jtds-TestSQLVariant-vu-verify.out @@ -0,0 +1,288 @@ + + +--[BABEL-582]Checking all base datatypes for sql_variant +--The following list of base datatypes cannot be stored by using sql_variant: +--[datetimeoffset(SQL server 2012), geography, geometry, hierarchyid, image, ntext, nvarchar(max), +--rowversion (timestamp), text, varchar(max), varbinary(max), User-defined types, xml] +Select * from testsqlvariant_sourceTable1; +go +~~START~~ +sql_variant#!#sql_variant +1#!#1 +#!#0 +~~END~~ + + +Select * from testsqlvariant_sourceTable2; +go +~~START~~ +sql_variant#!#sql_variant +0#!#10 +2#!#29 +4#!#87 +#!#100 +~~END~~ + + + +Select * from testsqlvariant_sourceTable3; +go +~~START~~ +sql_variant#!#sql_variant +0#!#-10 +2#!#-29 +876#!#-1234 +-32768#!#32767 +#!#100 +~~END~~ + + + +Select * from testsqlvariant_sourceTable4; +go +~~START~~ +sql_variant#!#sql_variant +0#!#-10 +-12345#!#10 +4#!#224466 +-2147483648#!#2147483647 +#!#100 +~~END~~ + + + +Select * from testsqlvariant_sourceTable5; +go +~~START~~ +sql_variant#!#sql_variant +0#!#-120 +-12345#!#100 +-12245532534#!#86 +-9223372036854775808#!#9223372036854775807 +#!#-4 +~~END~~ + + +Select * from testsqlvariant_sourceTable6; +go +~~START~~ +sql_variant#!#sql_variant +0.0#!#1.05 +-4.0#!#1.05 +86.0#!#-1.22455328E8 +3.4E38#!#-3.4E38 +#!#-2.0 +~~END~~ + + + +Select * from testsqlvariant_sourceTable7; +go +~~START~~ +sql_variant#!#sql_variant +0.0#!#1.05 +-1.23452345E7#!#1.05 +86.0#!#-2.0 +-1.79E308#!#1.79E308 +#!#100.0 +~~END~~ + + + +SELECT * FROM testsqlvariant_money_dt; +go +~~START~~ +sql_variant#!#sql_variant +100.5#!#10.05 +10#!#10 +-10.05#!#-10.0 +-214748.3648#!#-922337203685477.5808 +214748.3647#!#22337203685477.5807 +214748.3647#!#22337203685477.5807 +-214748.3648#!#-922337203685477.5808 +214748.3647#!#922337203685477.5807 +214748.3647#!#922337203685477.5807 +#!# +~~END~~ + + +Select * from testsqlvariant_sourceTable8; +go +~~START~~ +sql_variant#!#sql_variant +0.0000#!#1050.0000 +#!#-2.0000 +~~END~~ + + + +Select * from testsqlvariant_sourceTable9; +go +~~START~~ +sql_variant#!#sql_variant +0.0000#!#1050.0000 +#!#-2.0000 +~~END~~ + + + +Select * from testsqlvariant_sourceTable10; +go +~~START~~ +sql_variant#!#sql_variant +2000-12-13#!#1900-02-28 +#!#0001-01-01 +~~END~~ + + + +Select * from testsqlvariant_sourceTable11; +go +~~START~~ +sql_variant#!#sql_variant +2007-05-08 12:35:00.0#!#2007-05-08 12:36:00.0 +2007-05-08 13:00:00.0#!#2000-02-29 00:00:00.0 +1900-03-01 00:00:00.0#!#2000-02-28 23:46:00.0 +#!#1900-01-01 00:00:00.0 +~~END~~ + + + +Select * from testsqlvariant_sourceTable12; +go +~~START~~ +sql_variant#!#sql_variant +2000-12-13 12:58:23.123#!#1900-02-28 23:59:59.99 +1900-02-28 23:59:59.99#!#1900-02-28 23:59:59.993 +1900-02-28 23:59:59.993#!#1900-02-28 23:59:59.997 +1900-02-28 23:59:59.997#!#1753-01-01 00:00:00.0 +#!#9999-12-31 23:59:59.997 +~~END~~ + + + +Select * from testsqlvariant_sourceTable13; +go +~~START~~ +sql_variant#!#sql_variant +Satarupa #!# Satarupa + #!# S,B +#!# +~~END~~ + + + +Select * from testsqlvariant_sourceTable14; +go +~~START~~ +sql_variant#!#sql_variant +Satarupa #!# Satarupa + #!# S,B + dthdcjdfjwf dwfw fgegeg#!#😊😋😎😍😅😆 +#!# +~~END~~ + + + +Select * from testsqlvariant_sourceTable15; +go +~~START~~ +sql_variant#!#sql_variant +Satarupa#!# Satarupa +#!# S,B + dthdcjdfjwf dwfw fgegeg#!#😊😋😎😍😅😆 +#!# +~~END~~ + + + +Select * from testsqlvariant_sourceTable16; +go +~~START~~ +sql_variant#!#sql_variant +51F178A6-53C7-472C-9BE1-1C08942342D7#!#BAB96BC8-60B9-40DD-B0DE-C90A80F5739E +DBA2726C-2131-409F-AEFA-5C8079571623#!#51F178A6-53C7-472C-9BE1-1C08942342D7 +#!#60AEAA5C-E272-4B17-BAD0-C25710FD7A60 +~~END~~ + + +Select * from testsqlvariant_sourceTable17; +go +~~START~~ +sql_variant#!#sql_variant +Delhi#!# Surat +#!# S,B +#!# +~~END~~ + + +Select * from testsqlvariant_sourceTable18; +go +~~START~~ +sql_variant#!#sql_variant +Delhi #!# Surat + #!# S,B +#!# +~~END~~ + + +Select * from testsqlvariant_sourceTable19; +go +~~START~~ +sql_variant#!#sql_variant +123.46#!#123.40 +#!#123.00 +-123.46#!#-123.00 +~~END~~ + + +Select * from testsqlvariant_sourceTable20; +go +~~START~~ +sql_variant#!#sql_variant +123.46#!#123.40 +#!#123.00 +-123.46#!#-123.00 +~~END~~ + + +Select * from testsqlvariant_sourceTable21; +go +~~START~~ +sql_variant#!#sql_variant +12:45:37.0000000#!#12:45:37.1000000 +#!#12:45:37.1200000 +12:45:37.1230000#!#12:45:37.1234000 +12:45:37.1234500#!#12:45:37.1234560 +~~END~~ + + +Select * from testsqlvariant_sourceTable22; +go +~~START~~ +sql_variant#!#sql_variant +2016-10-23 12:45:37.0000000#!#2016-10-23 12:45:37.1000000 +#!#2016-10-23 12:45:37.1200000 +2016-10-23 12:45:37.1230000#!#2016-10-23 12:45:37.1234000 +2016-10-23 12:45:37.1234500#!#2016-10-23 12:45:37.1234560 +~~END~~ + + +Select * from testsqlvariant_vu_prepare_view1; +go +~~START~~ +sql_variant +abc +~~END~~ + + +Select * from testsqlvariant_vu_prepare_view2; +go +~~START~~ +sql_variant +2016-10-23 12:45:37.1000000 +2016-10-23 12:45:37.1200000 +2016-10-23 12:45:37.1234000 +2016-10-23 12:45:37.1234560 +~~END~~ + diff --git a/test/JDBC/expected/jtds-TestSimpleErrors.out b/test/JDBC/expected/jtds-TestSimpleErrors.out new file mode 100644 index 0000000000..b44dea6d32 --- /dev/null +++ b/test/JDBC/expected/jtds-TestSimpleErrors.out @@ -0,0 +1,4752 @@ +CREATE TABLE simpleErrorTable (a varchar(15) UNIQUE NOT NULL, b nvarchar(25), c int PRIMARY KEY, d char(15) DEFAULT 'Whoops!', e nchar(25), f datetime, g numeric(4,1) CHECK (g >= 103.5)) +GO + +-- setup for "data out of range for datetime" error +CREATE TABLE t517_1(a datetime); +GO + +-- setup for "A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations" error +CREATE TABLE t141_1(c1 int, c2 int); +GO + +-- setup for "column \"%s\" of relation \"%s\" is a generated column" +CREATE TABLE t1752_1(c1 INT, c2 INT, c3 as c1*c2) +GO + +if @@trancount > 0 commit tran; +GO + +-- Error: duplicate key value violates unique constraint +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int +~~END~~ + +~~ROW COUNT: 1~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + declare @err int = @@error; if @err = 0 select 0 else select 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int +~~END~~ + +~~ROW COUNT: 1~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + declare @err int = @@error; if @err = 0 select 0 else select 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran; +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int +~~END~~ + +~~ROW COUNT: 1~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + declare @err int = @@error; if @err = 0 select 0 else select 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran sp1 +rollback tran; +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int +~~END~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +~~START~~ +int +1 +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "simpleerrortable_a_key")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int +~~END~~ + +~~ROW COUNT: 1~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran; +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran sp1; +rollback tran; +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + declare @err int = @@error; if @err = 0 select 0 else select 1; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int +~~END~~ + +~~ROW COUNT: 1~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +~~START~~ +int +1 +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 517)~~ + +~~ERROR (Message: Adding a value to a 'datetime' column caused an overflow.)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +UPDATE simpleErrorTable SET c = NULL WHERE c = 1; +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int +~~END~~ + +~~ROW COUNT: 1~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + declare @err int = @@error; if @err = 0 select 0 else select 1; +commit tran; +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + declare @err int = @@error; if @err = 0 select 0 else select 1; +rollback tran; +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int +~~END~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + declare @err int = @@error; if @err = 0 select 0 else select 1; + rollback tran sp1; +rollback tran; +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int +~~END~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + declare @err int = @@error; if @err = 0 select 0 else select 1; +commit tran; +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int +~~END~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +~~START~~ +int +1 +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 515)~~ + +~~ERROR (Message: null value in column "c" of relation "simpleerrortable" violates not-null constraint)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + + +-- Error: creating an existing table +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +CREATE TABLE simpleErrorTable (a int); +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +commit tran; +GO +~~ERROR (Code: 3902)~~ + +~~ERROR (Message: COMMIT can only be used in transaction blocks)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +rollback tran; +GO +~~ERROR (Code: 3903)~~ + +~~ERROR (Message: ROLLBACK can only be used in transaction blocks)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +rollback tran sp1; +GO +~~ERROR (Code: 3903)~~ + +~~ERROR (Message: ROLLBACK TO SAVEPOINT can only be used in transaction blocks)~~ + +rollback tran; +GO +~~ERROR (Code: 3903)~~ + +~~ERROR (Message: ROLLBACK can only be used in transaction blocks)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + CREATE TABLE simpleErrorTable (a int); +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +commit tran; +GO +~~ERROR (Code: 3902)~~ + +~~ERROR (Message: COMMIT can only be used in transaction blocks)~~ + +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ROW COUNT: 1~~ + +commit tran; +GO +~~ERROR (Code: 3902)~~ + +~~ERROR (Message: COMMIT can only be used in transaction blocks)~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + CREATE TABLE simpleErrorTable (a int); + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +~~ERROR (Code: 3902)~~ + +~~ERROR (Message: COMMIT can only be used in transaction blocks)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +~~START~~ +int +1 +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 2714)~~ + +~~ERROR (Message: relation "simpleerrortable" already exists)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +GO +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran; +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran sp1; +rollback tran; +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +2 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +2 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +~~START~~ +int +1 +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 1752)~~ + +~~ERROR (Message: column "c3" of relation "t1752_1" is a generated column)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +commit tran +GO +~~ERROR (Code: 3902)~~ + +~~ERROR (Message: COMMIT can only be used in transaction blocks)~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +~~START~~ +int +1 +~~ERROR (Code: 3902)~~ + +~~ERROR (Message: COMMIT can only be used in transaction blocks)~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran; +GO +~~START~~ +int +1 +~~ERROR (Code: 3903)~~ + +~~ERROR (Message: ROLLBACK can only be used in transaction blocks)~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran sp1; +GO +~~START~~ +int +1 +~~ERROR (Code: 3903)~~ + +~~ERROR (Message: ROLLBACK TO SAVEPOINT can only be used in transaction blocks)~~ + +rollback tran; +GO +~~ERROR (Code: 3903)~~ + +~~ERROR (Message: ROLLBACK can only be used in transaction blocks)~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +begin tran +GO +DECLARE @a tinyint = 1000; +GO +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain tinyint violates check constraint "tinyint_check")~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +~~ERROR (Code: 3701)~~ + +~~ERROR (Message: could not find a procedure named "simpleerrorproc1")~~ + +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +begin tran +GO +DECLARE @a tinyint = 1000; +GO +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain tinyint violates check constraint "tinyint_check")~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +~~ERROR (Code: 3701)~~ + +~~ERROR (Message: could not find a procedure named "simpleerrorproc1")~~ + +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a tinyint = 1000; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain tinyint violates check constraint "tinyint_check")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a tinyint = 1000; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +~~START~~ +int +1 +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain tinyint violates check constraint "tinyint_check")~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a tinyint = 1000; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain tinyint violates check constraint "tinyint_check")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +Cherry#!#indigo#!#8#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +~~ERROR (Code: 141)~~ + +~~ERROR (Message: A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations)~~ + +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a tinyint = 1000; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain tinyint violates check constraint "tinyint_check")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +select @@trancount; +GO +~~START~~ +int +0 +~~END~~ + + +if @@trancount > 0 commit tran; +GO + +-- Error: value for domain tinyint violates check constraint "tinyint_check" +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +DECLARE @a tinyint = 1000; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 220)~~ + +~~ERROR (Message: value for domain tinyint violates check constraint "tinyint_check")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +0 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +drop procedure simpleErrorProc1 +GO +~~ERROR (Code: 3701)~~ + +~~ERROR (Message: could not find a procedure named "simpleerrorproc1")~~ + +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +~~ERROR (Code: 3902)~~ + +~~ERROR (Message: COMMIT can only be used in transaction blocks)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran; +GO +~~ERROR (Code: 3903)~~ + +~~ERROR (Message: ROLLBACK can only be used in transaction blocks)~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran sp1; +GO +~~ERROR (Code: 3903)~~ + +~~ERROR (Message: ROLLBACK TO SAVEPOINT can only be used in transaction blocks)~~ + +~~ROW COUNT: 1~~ + +rollback tran; +GO +~~ERROR (Code: 3903)~~ + +~~ERROR (Message: ROLLBACK can only be used in transaction blocks)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +commit tran; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +~~ERROR (Code: 3902)~~ + +~~ERROR (Message: COMMIT can only be used in transaction blocks)~~ + +~~ROW COUNT: 1~~ + +commit tran; +GO +~~ERROR (Code: 3902)~~ + +~~ERROR (Message: COMMIT can only be used in transaction blocks)~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +commit tran +GO +~~ERROR (Code: 3902)~~ + +~~ERROR (Message: COMMIT can only be used in transaction blocks)~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Pineapple#!#pink#!#7#!#Surat #!#Frown😠 #!#2000-12-13 12:58:23.123#!#123.1 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: invalid input syntax for type integer: "abc")~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +~~START~~ +int +1 +~~END~~ + +select * from simpleErrorTable ORDER BY c +GO +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + +select @@trancount +GO +~~START~~ +int +0 +~~END~~ + +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- cleanup for "data out of range for datetime" error +DROP TABLE t517_1; +GO + +-- clean up for "A SELECT statement that assigns a value to a variable must not +-- be combined with data-retrieval operations" error +DROP TABLE t141_1; +GO + +-- setup for "column \"%s\" of relation \"%s\" is a generated column" +DROP TABLE t1752_1; +GO + +drop table simpleErrorTable +GO + +while (@@trancount > 0) commit tran; +GO + diff --git a/test/JDBC/expected/jtds-TestStoredProcedures.out b/test/JDBC/expected/jtds-TestStoredProcedures.out new file mode 100644 index 0000000000..1d484ce889 --- /dev/null +++ b/test/JDBC/expected/jtds-TestStoredProcedures.out @@ -0,0 +1,558 @@ +# PROCEDURE WITH NO BODY +#create procedure sp_test AS BEGIN END; +# PROCEDURE WITH NO PARAMS +create table temp_sp2(a int); +CREATE PROCEDURE sp_test AS BEGIN insert into temp_sp2 values(1); END; +storedproc#!#prep#!#sp_test#!# +~~ROW COUNT: 1~~ + +SELECT * FROM temp_sp2; +~~START~~ +int +1 +~~END~~ + +drop table temp_sp2; +drop Procedure sp_test; +# PROCEDURE WITH INPUT PARAMETER +#drop table temp_sp; +create table temp_sp(a int); +Create Procedure stored_proc1 (@a int) As Begin insert into temp_sp values(@a) End; +# NOT WORKING FOR BABEL,RAISED JIRA 444 +storedproc#!#prep#!#stored_proc1#!#int|-|a|-|-100|-|input +~~ROW COUNT: 1~~ + +# MISMATCH IN RETURN VALUES +exec stored_proc1 -200 +~~ROW COUNT: 1~~ + +exec stored_proc1 0 +~~ROW COUNT: 1~~ + +exec stored_proc1 -1 +~~ROW COUNT: 1~~ + +exec stored_proc1 2 +~~ROW COUNT: 1~~ + +# filed Jira on this, doesnt work for babel +#exec stored_proc1 2.2 +SELECT * FROM temp_sp; +~~START~~ +int +-100 +-200 +0 +-1 +2 +~~END~~ + +DROP table temp_sp; +DROP Procedure stored_proc1 +# input parameter +CREATE PROCEDURE sp_test1 (@a INT) AS BEGIN SET @a=100; Select @a as a; END; +exec sp_test1 2 +~~START~~ +int +100 +~~END~~ + +Declare @a int;Set @a=1; exec sp_test1 @a;select @a as a; +~~START~~ +int +100 +~~END~~ + +~~START~~ +int +1 +~~END~~ + +storedproc#!#prep#!#sp_test1#!#int|-|a|-|1|-|input +~~START~~ +int +100 +~~END~~ + +storedproc#!#prep#!#sp_test1#!#int|-|a|-|10|-|input +~~START~~ +int +100 +~~END~~ + +DROP PROCEDURE sp_test1 +# TESTING OUT PARAMETERS FOR ALL THE DATATYPES +# int +CREATE PROCEDURE sp_test1 (@a INT OUTPUT) AS BEGIN SET @a=100; Select @a as a; END; +#Declare @a int;Set @a=1; exec sp_test1 @a;select @a as a; +storedproc#!#prep#!#sp_test1#!#int|-|a|-|1|-|output +~~START~~ +int +100 +~~END~~ + +storedproc#!#prep#!#sp_test1#!#int|-|a|-|1|-|inputoutput +~~START~~ +int +100 +~~END~~ + +DROP PROCEDURE sp_test1 +# smallint +CREATE PROCEDURE sp_test2 (@a SMALLINT OUTPUT) AS BEGIN SET @a=100; Select @a as a; END; +#Declare @a smallint;Set @a=1; exec sp_test2 @a;select @a as a; +storedproc#!#prep#!#sp_test2#!#smallint|-|a|-|10|-|output +~~START~~ +smallint +100 +~~END~~ + +storedproc#!#prep#!#sp_test2#!#smallint|-|a|-|10|-|inputoutput +~~START~~ +smallint +100 +~~END~~ + +DROP PROCEDURE sp_test2 +# bigint +CREATE PROCEDURE sp_test3 (@a BIGINT OUTPUT) AS BEGIN SET @a=100; Select @a as a; END; +storedproc#!#prep#!#sp_test3#!#bigint|-|a|-|10|-|output +~~START~~ +bigint +100 +~~END~~ + +storedproc#!#prep#!#sp_test3#!#bigint|-|a|-|10|-|inputoutput +~~START~~ +bigint +100 +~~END~~ + +DROP PROCEDURE sp_test3 +# tinyint +#CREATE PROCEDURE sp_test4 (@a tinyint OUTPUT) AS BEGIN SET @a=100; Select @a as a; END; +#storedproc#!#prep#!#sp_test4#!#tinyint|-|a|-|10|-|output +#storedproc#!#prep#!#sp_test4#!#tinyint|-|a|-|10|-|inputoutput +#DROP PROCEDURE sp_test4 +# float +CREATE PROCEDURE sp_test5 (@a float OUTPUT) AS BEGIN SET @a=100.12; Select @a as a; END; +#Declare @a float;Set @a=1.1; exec sp_test5 @a;select @a as a; +storedproc#!#prep#!#sp_test5#!#float|-|a|-|10.1|-|output +~~START~~ +float +100.12 +~~END~~ + +storedproc#!#prep#!#sp_test5#!#float|-|a|-|10.1|-|inputoutput +~~START~~ +float +100.12 +~~END~~ + +DROP PROCEDURE sp_test5 +# varchar +#CREATE PROCEDURE sp_test6 (@a varchar OUTPUT) AS BEGIN SET @a='helloworld'; Select @a as a; END; +#storedproc#!#prep#!#sp_test6#!#varchar|-|a|-|hello|-|output +#storedproc#!#prep#!#sp_test6#!#varchar|-|a|-|hello|-|inputoutput +#DROP PROCEDURE sp_test6 +# char BABEL-705 +#CREATE PROCEDURE sp_test7 (@a char OUTPUT) AS BEGIN SET @a='b'; Select @a as a; END; +#Declare @a varchar;Set @a='h'; exec sp_test7 @a;select @a as a; +#storedproc#!#prep#!#sp_test7#!#char|-|a|-|t|-|output +#storedproc#!#prep#!#sp_test7#!#char|-|a|-|t|-|inputoutput +#DROP PROCEDURE sp_test7 +# nvarchar +#CREATE PROCEDURE sp_test9 (@a nvarchar OUTPUT) AS BEGIN SET @a='helloworld'; Select @a as a; END; +#Declare @a nvarchar;Set @a='hello'; exec sp_test9 @a;select @a as a; +#storedproc#!#prep#!#sp_test9#!#varchar|-|a|-|hello|-|output +#storedproc#!#prep#!#sp_test9#!#varchar|-|a|-|hello|-|inputoutput +#DROP PROCEDURE sp_test9 +# numeric +CREATE PROCEDURE sp_test10 (@a numeric(10,4) OUTPUT) AS BEGIN SET @a=100.41; Select @a as a; END; +#Declare @a numeric(10,4);Set @a=10.04; exec sp_test10 @a;select @a as a; +#storedproc#!#prep#!#sp_test10#!#numeric|-|a|-|123|-|10|-|3|-|output +#storedproc#!#prep#!#sp_test10#!#numeric|-|a|-|123|-|10|-|2|-|inputoutput +DROP PROCEDURE sp_test10 +# decimal +CREATE PROCEDURE sp_test11 (@a decimal(10,4) OUTPUT) AS BEGIN SET @a=100.41; Select @a as a; END; +#Declare @a decimal(10,4);Set @a=10.04; exec sp_test11 @a;select @a as a; +#storedproc#!#prep#!#sp_test11#!#decimal|-|a|-|123|-|10|-|3|-|output +#storedproc#!#prep#!#sp_test11#!#decimal|-|a|-|123|-|10|-|2|-|inputoutput +DROP PROCEDURE sp_test11 +# binary +#CREATE PROCEDURE sp_test12 (@a binary OUTPUT) AS BEGIN SET @a=0x121; Select @a as a; END; +#exec sp_test12 0x122 +#Declare @a binary;Set @a=0x121; exec sp_test12 @a;select @a as a; +#storedproc#!#prep#!#sp_test12#!#binary|-|a|-|0x122|-|output +#storedproc#!#prep#!#sp_test12#!#binary|-|a|-|0x122|-|inputoutput +#DROP PROCEDURE sp_test12 +# varbinary BABEL-701 +#CREATE PROCEDURE sp_test13 (@a varbinary OUTPUT) AS BEGIN SET @a=0x121; Select @a as a; END; +#exec sp_test13 0x122 +#Declare @a varbinary;Set @a=0x122; exec sp_test13 @a;select @a as a; +#storedproc#!#prep#!#sp_test13#!#varbinary|-|a|-|0x122|-|output +#storedproc#!#prep#!#sp_test13#!#varbinary|-|a|-|0x122|-|inputoutput +#DROP PROCEDURE sp_test13 +# date +CREATE PROCEDURE sp_test14 (@a date output) AS BEGIN SET @a='1999-1-3'; Select @a as a; END; +#Declare @a DATE;Set @a='9999-12-31'; exec sp_test14 @a;select @a as a; +storedproc#!#prep#!#sp_test14#!#DATE|-|a|-|9999-12-31|-|output +~~START~~ +nvarchar +1999-01-03 +~~END~~ + +storedproc#!#prep#!#sp_test14#!#DATE|-|a|-|9999-12-31|-|inputoutput +~~START~~ +nvarchar +1999-01-03 +~~END~~ + +DROP PROCEDURE sp_test14 +# time +#CREATE PROCEDURE sp_test15 (@a time(4) OUTPUT) AS BEGIN SET @a='11:25:07.123'; Select @a as a; END; +#Declare @a Time;Set @a='12:45:37.123'; exec sp_test15 @a;select @a as a; +#storedproc#!#prep#!#sp_test15#!#Time|-|a|-|12:45:37.123|-|3|-|output +#storedproc#!#prep#!#sp_test15#!#Time|-|a|-|12:45:37.123|-|3|-|inputoutput +#DROP PROCEDURE sp_test15 +# dateime BABEL-694 +#CREATE PROCEDURE sp_test16 (@a datetime output) AS BEGIN SET @a='2004-05-18 13:59:59.995'; Select @a as a; END; +#Declare @a DATETIME;Set @a='2000-02-28 23:59:59.995'; exec sp_test16 @a;select @a as a; +#storedproc#!#prep#!#sp_test16#!#DATETIME|-|a|-|2000-02-28 23:59:59.995|-|output +#storedproc#!#prep#!#sp_test16#!#DATETIME|-|a|-|2000-02-28 23:59:59.995|-|inputoutput +#DROP PROCEDURE sp_test16 +# datetime2 +#CREATE PROCEDURE sp_test17 (@a datetime2(5) OUTPUT) AS BEGIN SET @a='2014-10-2 1:45:37.123456'; Select @a as a; END; +#Declare @a Datetime2;Set @a='2016-10-23 12:45:37.123456'; exec sp_test17 @a;select @a as a; +#storedproc#!#prep#!#sp_test17#!#Datetime2|-|a|-|2016-10-23 12:45:37.123456|-|5|-|output +#storedproc#!#prep#!#sp_test17#!#Datetime2|-|a|-|2016-10-23 12:45:37.123456|-|5|-|inputoutput +#DROP PROCEDURE sp_test17 +# smalldatetime BABEL-694 +#CREATE PROCEDURE sp_test18 (@a smalldatetime output) AS BEGIN SET @a='2010-02-03 12:58:23'; Select @a as a; END; +#Declare @a SMALLDATETIME;Set @a='2000-12-13 12:58:23'; exec sp_test18 @a;select @a as a; +#storedproc#!#prep#!#sp_test18#!#SMALLDATETIME|-|a|-|2000-12-13 12:58:23|-|output +#storedproc#!#prep#!#sp_test18#!#SMALLDATETIME|-|a|-|2000-12-13 12:58:23|-|inputoutput +#DROP PROCEDURE sp_test18 +# UID +#CREATE PROCEDURE sp_test19 (@a uniqueidentifier OUTPUT) AS BEGIN SET @a='ce8af10a-2709-43b0-9e4e-a02753929d17'; Select @a as a; END; +#Declare @a uniqueidentifier;Set @a='5b7c2e8d-6d90-411d-8e19-9a81067e6f6c'; exec sp_test19 @a;select @a as a; +#storedproc#!#prep#!#sp_test19#!#uniqueidentifier|-|a|-|5b7c2e8d-6d90-411d-8e19-9a81067e6f6c|-|output +#storedproc#!#prep#!#sp_test19#!#uniqueidentifier|-|a|-|5b7c2e8d-6d90-411d-8e19-9a81067e6f6c|-|inputoutput +#DROP PROCEDURE sp_test19 + +CREATE PROCEDURE sp_test20 (@a INT, @b INT OUTPUT) AS BEGIN SET @b=100; SET @a=1000; Select @a as a, @b as b; END; +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @b=@b OUT, @a=@a;select @a as a, @b as b; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#100 +~~END~~ + +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @b=@b, @a=@a OUT;select @a as a, @b as b; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#10 +~~END~~ + +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @b=@b OUT, @a=@a OUT;select @a as a, @b as b; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#100 +~~END~~ + +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @b=@b, @a=@a;select @a as a, @b as b; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#10 +~~END~~ + +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @a=@a, @b=@b;select @a as a, @b as b; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#10 +~~END~~ + +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @a=@a, @b=@b OUT;select @a as a, @b as b; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#100 +~~END~~ + +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @a=@a OUT, @b=@b;select @a as a, @b as b; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#10 +~~END~~ + +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @a=@a OUT, @b=@b OUT;select @a as a, @b as b; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#100 +~~END~~ + +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @a OUT, @b OUT;select @a as a, @b as b; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#100 +~~END~~ + +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|output +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|output#!#int|-|b|-|10|-|input +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|input +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|output#!#int|-|b|-|10|-|output +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|inputoutput#!#int|-|b|-|10|-|inputoutput +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|inputoutput +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|inputoutput#!#int|-|b|-|10|-|input +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +DROP PROCEDURE sp_test20 + +CREATE PROCEDURE sp_test21 (@a INT, @b INT OUTPUT, @d INT, @c INT OUTPUT) AS BEGIN SET @a=100; SET @b=200; SET @c=300; SET @d=400; Select @a as a, @b as b, @c as c, @d as d; END; +Declare @a int;Declare @b int;Declare @c int;Declare @d int;Set @a=20;Set @b=10;Set @c=5;Set @d=30; exec sp_test21 @b=@b OUT, @c=@c OUT, @a=@a, @d=@d; Select @a as a, @b as b, @c as c, @d as d; +~~START~~ +int#!#int#!#int#!#int +100#!#200#!#300#!#400 +~~END~~ + +~~START~~ +int#!#int#!#int#!#int +20#!#200#!#300#!#30 +~~END~~ + +Declare @a int;Declare @b int;Declare @c int;Declare @d int;Set @a=20;Set @b=10;Set @c=5;Set @d=30; exec sp_test21 @b=@b, @c=@c, @a=@a, @d=@d; Select @a as a, @b as b, @c as c, @d as d; +~~START~~ +int#!#int#!#int#!#int +100#!#200#!#300#!#400 +~~END~~ + +~~START~~ +int#!#int#!#int#!#int +20#!#10#!#5#!#30 +~~END~~ + +Declare @a int;Declare @b int;Declare @c int;Declare @d int;Set @a=20;Set @b=10;Set @c=5;Set @d=30; exec sp_test21 @c=@c OUT, @b=@b OUT, @a=@a, @d=@d; Select @a as a, @b as b, @c as c, @d as d; +~~START~~ +int#!#int#!#int#!#int +100#!#200#!#300#!#400 +~~END~~ + +~~START~~ +int#!#int#!#int#!#int +20#!#200#!#300#!#30 +~~END~~ + +Declare @a int;Declare @b int;Declare @c int;Declare @d int;Set @a=20;Set @b=10;Set @c=5;Set @d=30; exec sp_test21 @c=@c, @b=@b, @a=@a OUT, @d=@d OUT; Select @a as a, @b as b, @c as c, @d as d; +~~START~~ +int#!#int#!#int#!#int +100#!#200#!#300#!#400 +~~END~~ + +~~START~~ +int#!#int#!#int#!#int +20#!#10#!#5#!#30 +~~END~~ + +storedproc#!#prep#!#sp_test21#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|inputoutput#!#int|-|c|-|10|-|input#!#int|-|d|-|10|-|inputoutput +~~START~~ +int#!#int#!#int#!#int +100#!#200#!#300#!#400 +~~END~~ + +storedproc#!#prep#!#sp_test21#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|output#!#int|-|c|-|10|-|input#!#int|-|d|-|10|-|output +~~START~~ +int#!#int#!#int#!#int +100#!#200#!#300#!#400 +~~END~~ + +storedproc#!#prep#!#sp_test21#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|output#!#int|-|c|-|10|-|input#!#int|-|d|-|10|-|inputoutput +~~START~~ +int#!#int#!#int#!#int +100#!#200#!#300#!#400 +~~END~~ + +storedproc#!#prep#!#sp_test21#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|inputoutput#!#int|-|c|-|10|-|input#!#int|-|d|-|10|-|output +~~START~~ +int#!#int#!#int#!#int +100#!#200#!#300#!#400 +~~END~~ + +DROP PROCEDURE sp_test21 + +CREATE PROCEDURE sp_test22 (@MixedCaseArg_1 INT, @MixedCaseArg_2 INT OUTPUT) AS BEGIN SET @MixedCaseArg_2=100; SET @MixedCaseArg_1=1000; Select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; END; +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_2=@MixedCaseArg_2 OUT, @MixedCaseArg_1=@MixedCaseArg_1;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#100 +~~END~~ + +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_2=@MixedCaseArg_2, @MixedCaseArg_1=@MixedCaseArg_1 OUT;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#10 +~~END~~ + +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_2=@MixedCaseArg_2 OUT, @MixedCaseArg_1=@MixedCaseArg_1 OUT;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#100 +~~END~~ + +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_2=@MixedCaseArg_2, @MixedCaseArg_1=@MixedCaseArg_1;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#10 +~~END~~ + +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_1=@MixedCaseArg_1, @MixedCaseArg_2=@MixedCaseArg_2;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#10 +~~END~~ + +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_1=@MixedCaseArg_1, @MixedCaseArg_2=@MixedCaseArg_2 OUT;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#100 +~~END~~ + +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_1=@MixedCaseArg_1 OUT, @MixedCaseArg_2=@MixedCaseArg_2;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#10 +~~END~~ + +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_1=@MixedCaseArg_1 OUT, @MixedCaseArg_2=@MixedCaseArg_2 OUT;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#100 +~~END~~ + +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_1 OUT, @MixedCaseArg_2 OUT;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +~~START~~ +int#!#int +1000#!#100 +~~END~~ + +~~START~~ +int#!#int +20#!#100 +~~END~~ + +DROP PROCEDURE sp_test22 diff --git a/test/JDBC/expected/jtds-TestTableType-vu-cleanup.out b/test/JDBC/expected/jtds-TestTableType-vu-cleanup.out new file mode 100644 index 0000000000..9f0742199f --- /dev/null +++ b/test/JDBC/expected/jtds-TestTableType-vu-cleanup.out @@ -0,0 +1,12 @@ +drop procedure TestTableType_vu_prepare_proc1 +go + +drop function TestTableType_vu_prepare_func1 +go + + +drop type TestTableType_vu_prepare_t1 +drop type TestTableType_vu_prepare_t2 +drop type TestTableType_vu_prepare_t3 +drop type TestTableType_vu_prepare_t4 +go diff --git a/test/JDBC/expected/jtds-TestTableType-vu-prepare.out b/test/JDBC/expected/jtds-TestTableType-vu-prepare.out new file mode 100644 index 0000000000..deefd24841 --- /dev/null +++ b/test/JDBC/expected/jtds-TestTableType-vu-prepare.out @@ -0,0 +1,25 @@ +create type TestTableType_vu_prepare_t1 as table (c1 int, c2 int); +go + +create type TestTableType_vu_prepare_t2 as table (c1 int, c2 varchar(30), check (c1 < 5)); +go + +create type TestTableType_vu_prepare_t3 as table (a varchar(15) UNIQUE NOT NULL, b nvarchar(25), c int PRIMARY KEY, d char(15) DEFAULT 'Whoops!', e nchar(25), f datetime, g numeric(4,1) CHECK (g >= 103.5)) +go + +create type TestTableType_vu_prepare_t4 as table(a text not null, b int primary key, c int); +go + +create function TestTableType_vu_prepare_func1 (@number int, @tv TestTableType_vu_prepare_t4 READONLY) returns table as return ( +select *, @number from @tv +); +go + +create procedure TestTableType_vu_prepare_proc1 as +begin + declare @tv TestTableType_vu_prepare_t4 + insert into @tv values('hello1', 1, 1001) + insert into @tv values('hello2', 2, 1002) + select * from TestTableType_vu_prepare_func1(1004, @tv) +end; +go diff --git a/test/JDBC/expected/jtds-TestTableType-vu-verify.out b/test/JDBC/expected/jtds-TestTableType-vu-verify.out new file mode 100644 index 0000000000..fef95e1faf --- /dev/null +++ b/test/JDBC/expected/jtds-TestTableType-vu-verify.out @@ -0,0 +1,85 @@ +declare @tv TestTableType_vu_prepare_t1; +insert @tv values (1,1); +insert @tv values (2,2); +select * from @tv; +go +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int#!#int +1#!#1 +2#!#2 +~~END~~ + + +declare @tv TestTableType_vu_prepare_t2; +insert @tv values(1,'one'); +insert @tv values(2,'two'); +insert @tv values(3,'three'); +select * from @tv; +insert @tv values(6,'six'); +go +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~START~~ +int#!#varchar +1#!#one +2#!#two +3#!#three +~~ERROR (Code: 547)~~ + +~~ERROR (Message: new row for relation "@tv_0" violates check constraint "testtabletype_vu_prepare_t2_c1_check")~~ + + +declare @tv TestTableType_vu_prepare_t3; +insert @tv values ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +insert @tv (a, b, c, e, f, g) values ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +select * from @tv; +go +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +Apple#!#red#!#1#!#Delhi #!#Sad😞 #!#2000-12-13 12:58:23.123#!#123.1 +Orange#!##!#3#!#Whoops! #!#Happy😀 #!#1900-02-28 23:59:59.99#!#342.5 +~~END~~ + + + + +declare @tv TestTableType_vu_prepare_t3; +insert @tv values ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +insert @tv values ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +select * from @tv; +go +~~ERROR (Code: 2627)~~ + +~~ERROR (Message: duplicate key value violates unique constraint "@tv_0_a_key")~~ + +~~ROW COUNT: 1~~ + +~~START~~ +varchar#!#nvarchar#!#int#!#char#!#nchar#!#datetime#!#numeric +~~END~~ + + +exec TestTableType_vu_prepare_proc1; +go +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~START~~ +text#!#int#!#int#!#int +hello1#!#1#!#1001#!#1004 +hello2#!#2#!#1002#!#1004 +~~END~~ + diff --git a/test/JDBC/expected/jtds-TestTime.out b/test/JDBC/expected/jtds-TestTime.out new file mode 100644 index 0000000000..40bec7f274 --- /dev/null +++ b/test/JDBC/expected/jtds-TestTime.out @@ -0,0 +1,300 @@ +Create table TestTime(a time(6)) + +prepst#!# Insert into TestTime Values(?) #!#Time|-|a|-|12:45:37.123|-|0 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-| +~~ROW COUNT: 1~~ + + +select * from TestTime +~~START~~ +nvarchar +12:45:37.000000 +12:45:37.000000 +12:45:37.000000 +12:45:37.000000 +12:45:37.000000 +12:45:37.000000 +12:45:37.000000 + +~~END~~ + + +Drop table TestTime + +Create table TestTime(a time(5)) + +prepst#!# Insert into TestTime Values(?) #!#Time|-|a|-|12:45:37.123|-|0 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-| +~~ROW COUNT: 1~~ + + +select * from TestTime +~~START~~ +nvarchar +12:45:37.00000 +12:45:37.00000 +12:45:37.00000 +12:45:37.00000 +12:45:37.00000 +12:45:37.00000 +12:45:37.00000 + +~~END~~ + + +Drop table TestTime + +Create table TestTime(a time(4)) + +prepst#!# Insert into TestTime Values(?) #!#Time|-|a|-|12:45:37.123|-|0 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-| +~~ROW COUNT: 1~~ + + +select * from TestTime +~~START~~ +nvarchar +12:45:37.0000 +12:45:37.0000 +12:45:37.0000 +12:45:37.0000 +12:45:37.0000 +12:45:37.0000 +12:45:37.0000 + +~~END~~ + + +Drop table TestTime + +Create table TestTime(a time(3)) + +prepst#!# Insert into TestTime Values(?) #!#Time|-|a|-|12:45:37.123|-|0 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-| +~~ROW COUNT: 1~~ + + +select * from TestTime +~~START~~ +nvarchar +12:45:37.000 +12:45:37.000 +12:45:37.000 +12:45:37.000 +12:45:37.000 +12:45:37.000 +12:45:37.000 + +~~END~~ + + +Drop table TestTime + +Create table TestTime(a time(2)) + +prepst#!# Insert into TestTime Values(?) #!#Time|-|a|-|12:45:37.123|-|0 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-| +~~ROW COUNT: 1~~ + + +select * from TestTime +~~START~~ +nvarchar +12:45:37.00 +12:45:37.00 +12:45:37.00 +12:45:37.00 +12:45:37.00 +12:45:37.00 +12:45:37.00 + +~~END~~ + + +Drop table TestTime + +Create table TestTime(a time(1)) + +prepst#!# Insert into TestTime Values(?) #!#Time|-|a|-|12:45:37.123|-|0 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-| +~~ROW COUNT: 1~~ + + +select * from TestTime +~~START~~ +nvarchar +12:45:37.0 +12:45:37.0 +12:45:37.0 +12:45:37.0 +12:45:37.0 +12:45:37.0 +12:45:37.0 + +~~END~~ + + +Drop table TestTime + +Create table TestTime(a time(0)) + +prepst#!# Insert into TestTime Values(?) #!#Time|-|a|-|12:45:37.123|-|0 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#Time|-|a|-| +~~ROW COUNT: 1~~ + + +select * from TestTime +~~START~~ +nvarchar +12:45:37 +12:45:37 +12:45:37 +12:45:37 +12:45:37 +12:45:37 +12:45:37 + +~~END~~ + + +Drop table TestTime diff --git a/test/JDBC/expected/jtds-TestTransactionSupportForProcedure.out b/test/JDBC/expected/jtds-TestTransactionSupportForProcedure.out new file mode 100644 index 0000000000..434b429b42 --- /dev/null +++ b/test/JDBC/expected/jtds-TestTransactionSupportForProcedure.out @@ -0,0 +1,968 @@ +#setup +create table txnproctable (c1 int not null, c2 varchar(100)) + +# PROC +# BEGIN TRAN +# SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +create procedure txnproc1 as begin tran; insert into txnproctable values (1, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; commit tran; +select @@trancount; +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +~~END~~ + +exec txnproc1; +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +select @@trancount; +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +~~END~~ + + + +# PROC +# BEGIN TRAN +# SAVEPOINT +# ROLLBACK SAVEPOINT +# ROLLBACK +drop procedure txnproc1; +create procedure txnproc1 as begin tran; insert into txnproctable values(2, 'xyz'); save tran sp1; delete from txnproctable; rollback tran sp1; rollback tran; +select @@trancount; +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +~~END~~ + +exec txnproc1; +~~ROW COUNT: 1~~ + +~~ROW COUNT: 2~~ + +select @@trancount; +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +~~END~~ + + + +# PROC +# BEGIN TRAN +# SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +drop procedure txnproc1 +create procedure txnproc1 as begin tran; insert into txnproctable values(3, 'dbd'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +~~END~~ + +exec txnproc1; +~~ERROR (Code: 266)~~ + +~~ERROR (Message: Transaction count after execution indicates a mismatch number of BEGIN and COMMIT statements. Previous count 0 current count 1)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 2~~ + +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +~~END~~ + +commit tran; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +~~END~~ + + + +# PROC +# BEGIN TRAN +# SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +drop procedure txnproc1 +create procedure txnproc1 as begin tran; insert into txnproctable values(4, 'sbd'); save tran sp1; update txnproctable set c1 = c1 + 1; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +~~END~~ + +exec txnproc1; +~~ERROR (Code: 266)~~ + +~~ERROR (Message: Transaction count after execution indicates a mismatch number of BEGIN and COMMIT statements. Previous count 0 current count 1)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 3~~ + +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +~~END~~ + +rollback tran sp1; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +~~END~~ + +commit tran; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +~~END~~ + + + +# BEGIN TRAN +# PROC +# SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +begin tran; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +~~END~~ + +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(5, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +~~END~~ + +exec txnproc1; +~~ROW COUNT: 1~~ + +~~ROW COUNT: 4~~ + +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +5#!#abc +~~END~~ + +commit tran; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +5#!#abc +~~END~~ + + + +# BEGIN TRAN +# PROC +# SAVEPOINT +# ROLLBACK SAVEPOINT +# ROLLBACK +begin tran; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +5#!#abc +~~END~~ + +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(6, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +5#!#abc +~~END~~ + +exec txnproc1; +~~ROW COUNT: 1~~ + +~~ROW COUNT: 5~~ + +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +5#!#abc +6#!#abc +~~END~~ + +commit tran; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +5#!#abc +6#!#abc +~~END~~ + + +# BEGIN TRAN +# PROC +# SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +begin tran; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +5#!#abc +6#!#abc +~~END~~ + +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(7, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; update txnproctable set c1 = c1 + 1; commit tran; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +1#!#abc +3#!#dbd +4#!#sbd +5#!#abc +6#!#abc +~~END~~ + +exec txnproc1; +~~ERROR (Code: 266)~~ + +~~ERROR (Message: Transaction count after execution indicates a mismatch number of BEGIN and COMMIT statements. Previous count 1 current count 0)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 6~~ + +~~ROW COUNT: 6~~ + +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + + +# BEGIN TRAN +# PROC +# SAVEPOINT +# ROLLBACK SAVEPOINT +# ROLLBACK +begin tran; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(8, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; update txnproctable set c1 = c1 + 1; rollback tran; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +exec txnproc1; +~~ERROR (Code: 266)~~ + +~~ERROR (Message: Transaction count after execution indicates a mismatch number of BEGIN and COMMIT statements. Previous count 1 current count 0)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 7~~ + +~~ROW COUNT: 7~~ + +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + + +# BEGIN TRAN +# START SAVEPOINT +# PROC +# ROLLBACK SAVEPOINT +# ROLLBACK +begin tran; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +save tran sp1; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(9, 'abc'); update txnproctable set c1 = c1 + 1; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +exec txnproc1; +~~ROW COUNT: 1~~ + +~~ROW COUNT: 7~~ + +rollback tran sp1; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +rollback tran; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + + +# BEGIN TRAN +# START SAVEPOINT +# PROC +# ROLLBACK SAVEPOINT +# ROLLBACK +begin tran; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +save tran sp1; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(10, 'abc'); update txnproctable set c1 = c1 + 1; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +exec txnproc1; +~~ROW COUNT: 1~~ + +~~ROW COUNT: 7~~ + +rollback tran sp1; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +commit tran; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + + +# BEGIN TRAN +# START SAVEPOINT +# PROC +# ROLLBACK SAVEPOINT +# ROLLBACK +begin tran; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +save tran sp1; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(11, 'abc'); rollback tran sp1; update txnproctable set c1 = c1 + 1; +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +2#!#abc +4#!#dbd +5#!#sbd +6#!#abc +7#!#abc +8#!#abc +~~END~~ + +exec txnproc1; +~~ROW COUNT: 1~~ + +~~ROW COUNT: 6~~ + +commit tran; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +3#!#abc +5#!#dbd +6#!#sbd +7#!#abc +8#!#abc +9#!#abc +~~END~~ + + +# PROC1 +# BEGIN TRAN +# PROC2 +# PROC3 +# BEGIN TRAN +# START SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +# COMMIT +create procedure txnProc3 as begin tran; insert into txnproctable values (16, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +3#!#abc +5#!#dbd +6#!#sbd +7#!#abc +8#!#abc +9#!#abc +~~END~~ + +create procedure txnProc2 as update txnproctable set c1 = c1 + 1; exec txnProc3; commit tran; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +3#!#abc +5#!#dbd +6#!#sbd +7#!#abc +8#!#abc +9#!#abc +~~END~~ + +drop procedure txnproc1 +create procedure txnproc1 as delete from txnproctable; begin tran; exec txnProc2; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +3#!#abc +5#!#dbd +6#!#sbd +7#!#abc +8#!#abc +9#!#abc +~~END~~ + +exec txnproc1; +~~ERROR (Code: 266)~~ + +~~ERROR (Message: Transaction count after execution indicates a mismatch number of BEGIN and COMMIT statements. Previous count 1 current count 2)~~ + +~~ROW COUNT: 6~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +select @@trancount +~~START~~ +int +1 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +16#!#abc +~~END~~ + +commit tran; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +16#!#abc +~~END~~ + + +# PROC1 +# BEGIN TRAN +# PROC2 +# PROC3 +# BEGIN TRAN +# START SAVEPOINT +# ROLLBACK SAVEPOINT +# ROLLBACK TRAN +# COMMIT +drop procedure txnproc3 +create procedure txnProc3 as begin tran; insert into txnproctable values (20, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +16#!#abc +~~END~~ + +drop procedure txnproc2 +create procedure txnProc2 as update txnproctable set c1 = c1 + 1; exec txnProc3; rollback tran; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +16#!#abc +~~END~~ + +drop procedure txnproc1 +create procedure txnproc1 as delete from txnproctable; begin tran; exec txnProc2; +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +16#!#abc +~~END~~ + +exec txnproc1; +~~ERROR (Code: 266)~~ + +~~ERROR (Message: Transaction count after execution indicates a mismatch number of BEGIN and COMMIT statements. Previous count 1 current count 2)~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +~~ROW COUNT: 1~~ + +select @@trancount +~~START~~ +int +0 +~~END~~ + +select * from txnproctable order by c1; +~~START~~ +int#!#varchar +~~END~~ + + +#cleanup +drop procedure txnproc3 +drop procedure txnproc2 +drop procedure txnproc1 +drop table txnproctable diff --git a/test/JDBC/expected/jtds-TestVarChar.out b/test/JDBC/expected/jtds-TestVarChar.out new file mode 100644 index 0000000000..26062c157c --- /dev/null +++ b/test/JDBC/expected/jtds-TestVarChar.out @@ -0,0 +1,159 @@ +CREATE TABLE VARCHAR_dt (a VARCHAR(20), b NVARCHAR(24)) +prepst#!# INSERT INTO VARCHAR_dt(a, b) values(?, ?) #!#VARCHAR|-|a|-|Dipesh#!#NVARCHAR|-|b|-|Dhameliya +~~ROW COUNT: 1~~ + +prepst#!#exec#!#VARCHAR|-|a|-| Dipesh #!#NVARCHAR|-|b|-| Dhameliya +~~ROW COUNT: 1~~ + +prepst#!#exec#!#VARCHAR|-|a|-| D#!#NVARCHAR|-|b|-| 🤣😃 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#VARCHAR|-|a|-| #!#NVARCHAR|-|b|-| +~~ROW COUNT: 1~~ + +prepst#!#exec#!#VARCHAR|-|a|-|#!#NVARCHAR|-|b|-| +~~ROW COUNT: 1~~ + +prepst#!#exec#!#VARCHAR|-|a|-|d#!#NVARCHAR|-|b|-|D +~~ROW COUNT: 1~~ + +prepst#!#exec#!#VARCHAR|-|a|-|abcdefghijklmnopqrst#!#NVARCHAR|-|b|-|abcdefghijklmnopqrstuvwx +~~ROW COUNT: 1~~ + +prepst#!#exec#!#VARCHAR|-|a|-|abcdefghijklmnopqrstu#!#NVARCHAR|-|b|-|abcdefghijklmnopqrstuvwxy +~~ERROR (Code: 8152)~~ + +~~ERROR (Message: value too long for type character varying(20))~~ + +prepst#!#exec#!#VARCHAR|-|a|-| #!#NVARCHAR|-|b|-|😊😋😎😍😅😆 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#VARCHAR|-|a|-|#!#NVARCHAR|-|b|-| +~~ROW COUNT: 1~~ + +SELECT * FROM VARCHAR_dt; +~~START~~ +varchar#!#nvarchar +Dipesh#!#Dhameliya + Dipesh #!# Dhameliya + D#!# 🤣😃 + #!# +#!# +d#!#D +abcdefghijklmnopqrst#!#abcdefghijklmnopqrstuvwx + #!#😊😋😎😍😅😆 +#!# +~~END~~ + +INSERT INTO VARCHAR_dt(a,b) values('Dipesh','Dhameliya') +~~ROW COUNT: 1~~ + +INSERT INTO VARCHAR_dt(a,b) values(' Dipesh',' Dhameliya') +~~ROW COUNT: 1~~ + +INSERT INTO VARCHAR_dt(a,b) values(' D',N' 🤣😃') +~~ROW COUNT: 1~~ + +INSERT INTO VARCHAR_dt(a,b) values(' ',' ') +~~ROW COUNT: 1~~ + +INSERT INTO VARCHAR_dt(a,b) values(' ',N'😊😋😎😍😅😆') +~~ROW COUNT: 1~~ + +INSERT INTO VARCHAR_dt(a,b) values('','') +~~ROW COUNT: 1~~ + +INSERT INTO VARCHAR_dt(a,b) values('d','D') +~~ROW COUNT: 1~~ + +INSERT INTO VARCHAR_dt(a,b) values('abcdefghijklmnopqrst','abcdefghijklmnopqrstuvwx') +~~ROW COUNT: 1~~ + +#INSERT INTO VARCHAR_dt(a,b) values('abcdefghijklmnopqrstu','abcdefghijklmnopqrstuvwxy') -- for this case, BABEL and SQL both will throw an error +INSERT INTO VARCHAR_dt(a,b) values(NULL,NULL) +~~ROW COUNT: 1~~ + +SELECT * FROM VARCHAR_dt; +~~START~~ +varchar#!#nvarchar +Dipesh#!#Dhameliya + Dipesh #!# Dhameliya + D#!# 🤣😃 + #!# +#!# +d#!#D +abcdefghijklmnopqrst#!#abcdefghijklmnopqrstuvwx + #!#😊😋😎😍😅😆 +#!# +Dipesh#!#Dhameliya + Dipesh#!# Dhameliya + D#!# 🤣😃 + #!# + #!#😊😋😎😍😅😆 +#!# +d#!#D +abcdefghijklmnopqrst#!#abcdefghijklmnopqrstuvwx +#!# +~~END~~ + +DROP TABLE VARCHAR_dt; + +CREATE TABLE VARCHAR_dt (a varchar(max), b nvarchar(max)); +INSERT INTO VARCHAR_dt values ('hello', N'hello😃'); +~~ROW COUNT: 1~~ + + +#checking with string of length > 65535 +INSERT INTO VARCHAR_dt values ('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', N'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😃'); +~~ROW COUNT: 1~~ + +INSERT INTO VARCHAR_dt values (NULL, NULL); +~~ROW COUNT: 1~~ + +prepst#!#INSERT INTO VARCHAR_dt values(?, ?)#!#varchar|-|a|-|hello#!#nvarchar|-|b|-|hello😃 +~~ROW COUNT: 1~~ + + +#checking with string of length > 65535 via prep-exec +prepst#!#exec#!#varchar|-|a|-|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#!#nvarchar|-|b|-|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😃 +~~ROW COUNT: 1~~ + +prepst#!#exec#!#varchar|-|a|-|#!#nvarchar|-|b|-| +~~ROW COUNT: 1~~ + +select * from VARCHAR_dt +~~START~~ +text#!#ntext +hello#!#hello😃 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#!#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😃 +#!# +hello#!#hello😃 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#!#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😃 +#!# +~~END~~ + +drop table VARCHAR_dt; + +create table VARCHAR_dt (a varchar(max), b int, c int, d int, e int ,f int, g int, h int, i int); +insert into VARCHAR_dt (a,b,c,d,e,f,g,h,i) values (NULL,1,2,3,4,5,6,7,8); +~~ROW COUNT: 1~~ + +select * from VARCHAR_dt; +~~START~~ +text#!#int#!#int#!#int#!#int#!#int#!#int#!#int#!#int +#!#1#!#2#!#3#!#4#!#5#!#6#!#7#!#8 +~~END~~ + +drop table VARCHAR_dt; + +create table VARCHAR_dt (a varchar(10), b int, c int, d int, e int ,f int, g int, h int, i int); +insert into VARCHAR_dt (a,b,c,d,e,f,g,h,i) values (NULL,1,2,3,4,5,6,7,8); +~~ROW COUNT: 1~~ + +select * from VARCHAR_dt; +~~START~~ +varchar#!#int#!#int#!#int#!#int#!#int#!#int#!#int#!#int +#!#1#!#2#!#3#!#4#!#5#!#6#!#7#!#8 +~~END~~ + +drop table VARCHAR_dt; diff --git a/test/JDBC/expected/jtds-TestXML.out b/test/JDBC/expected/jtds-TestXML.out new file mode 100644 index 0000000000..b156147bd5 --- /dev/null +++ b/test/JDBC/expected/jtds-TestXML.out @@ -0,0 +1,54 @@ +CREATE TABLE XML_dt (a XML) +#prepst#!# INSERT INTO XML_dt values(@a) #!#XML|-|a|-| +#prepst#!# INSERT INTO XML_dt values(@a) #!#XML|-|a|-|Contact Name 2YYY-YYY-YYYY +#prepst#!#exec#!#XML|-|a|-| +SELECT * FROM XML_dt; +~~START~~ +ntext +~~END~~ + +INSERT INTO XML_dt values('Contact Name 2YYY-YYY-YYYY') +~~ROW COUNT: 1~~ + +INSERT INTO XML_dt values(NULL) +~~ROW COUNT: 1~~ + +#INSERT INTO XML_dt values('') +INSERT INTO XML_dt values(Contact Name 2YYY-YYY-YYYY) +~~ERROR (Code: 33557097)~~ + +~~ERROR (Message: syntax error near '<' at line 1 and character position 26)~~ + +SELECT * FROM XML_dt; +~~START~~ +ntext +Contact Name 2YYY-YYY-YYYY + +~~END~~ + +DROP TABLE XML_dt; + +CREATE TABLE [dbo].[notification_definition]([id] [bigint] NOT NULL,[name_tx] [nvarchar](200) NOT NULL,[description_tx] [nvarchar](max) NULL,[schedule_xml] [xml] NULL,[default_sender_tx] [nvarchar](200) NULL,[lock_id] [tinyint] NOT NULL,[settings_xml] [xml] NULL,[agency_id] [bigint] NULL) +INSERT [dbo].[NOTIFICATION_DEFINITION] VALUES (13, N'INTRA_MSG', N'Intra-System Message', NULL, N'donotreply_OPMQA@ospreycompliancesuite.com', 63,N'NTF_SUB_INTRA_MSGNTF_MSG_INTRA_MSGPolicyDocumentTemplateVars11', 1) +~~ROW COUNT: 1~~ + +SELECT ID,NAME_TX,LOCK_ID,DESCRIPTION_TX,N'' as emptystring, SCHEDULE_XML,DEFAULT_SENDER_TX,SETTINGS_XML,AGENCY_ID FROM NOTIFICATION_DEFINITION +~~START~~ +bigint#!#nvarchar#!#tinyint#!#ntext#!#nvarchar#!#ntext#!#nvarchar#!#ntext#!#bigint +13#!#INTRA_MSG#!#63#!#Intra-System Message#!##!##!#donotreply_OPMQA@ospreycompliancesuite.com#!#NTF_SUB_INTRA_MSGNTF_MSG_INTRA_MSGPolicyDocumentTemplateVars11#!#1 +~~END~~ + +DROP TABLE [dbo].[notification_definition]; + +CREATE TABLE [dbo].[notification_definition]([id] [bigint] NOT NULL,[name_tx] [nvarchar](200) NOT NULL,[description_tx] [nvarchar](max) NULL,[schedule_xml] [xml] NULL,[default_sender_tx] [nvarchar](200) NULL,[lock_id] [tinyint] NOT NULL,[settings_xml] [xml] NULL,[agency_id] [bigint] NULL) +prepst#!# INSERT [dbo].[NOTIFICATION_DEFINITION] VALUES(?, ?, ?, ?, ?, ?, ?, ?) #!#bigint|-|a|-|13#!#nvarchar|-|b|-|INTRA_MSG#!#nvarchar|-|c|-|Intra-System Message#!#XML|-|d|-|NULL#!#nvarchar|-|e|-|donotreply_OPMQA#!#tinyint|-|f|-|63#!#XML|-|g|-|NTF_SUB_INTRA_MSGNTF_MSG_INTRA_MSGPolicyDocumentTemplateVars11#!#bigint|-|h|-|1 +~~ROW COUNT: 1~~ + +#INSERT [dbo].[NOTIFICATION_DEFINITION] VALUES (13, N'INTRA_MSG', N'Intra-System Message', NULL, N'donotreply_OPMQA@ospreycompliancesuite.com', 63,N'NTF_SUB_INTRA_MSGNTF_MSG_INTRA_MSGPolicyDocumentTemplateVars11', 1) +SELECT ID,NAME_TX,LOCK_ID,DESCRIPTION_TX,N'' as emptystring, SCHEDULE_XML,DEFAULT_SENDER_TX,SETTINGS_XML,AGENCY_ID FROM NOTIFICATION_DEFINITION +~~START~~ +bigint#!#nvarchar#!#tinyint#!#ntext#!#nvarchar#!#ntext#!#nvarchar#!#ntext#!#bigint +13#!#INTRA_MSG#!#63#!#Intra-System Message#!##!#NULL#!#donotreply_OPMQA#!#NTF_SUB_INTRA_MSGNTF_MSG_INTRA_MSGPolicyDocumentTemplateVars11#!#1 +~~END~~ + +DROP TABLE [dbo].[notification_definition]; diff --git a/test/JDBC/input/jtds/jtds-TestBinary.txt b/test/JDBC/input/jtds/jtds-TestBinary.txt new file mode 100644 index 0000000000..e4f4c5a539 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestBinary.txt @@ -0,0 +1,29 @@ +CREATE TABLE BINARY_dt(a BINARY(8), b VARBINARY(10)); +#inserting random values +INSERT INTO BINARY_dt(a, b) values (1234, 12345); +INSERT INTO BINARY_dt(a, b) values (NULL, NULL); +#INSERT INTO BINARY_dt(a, b) values (0x31323334, 0x3132333435); +SELECT * FROM BINARY_dt +#prepst#!# INSERT INTO BINARY_dt(a, b) values(@a, @b) #!#binary|-|a|-|1234#!#varbinary|-|b|-|12345 +DROP TABLE BINARY_dt + + +CREATE TABLE BINARY_dt(a VARBINARY(max)); +INSERT INTO BINARY_dt(a) values (NULL); +SELECT * FROM BINARY_dt; +DROP TABLE BINARY_dt; + +create table BINARY_dt (a VARBINARY(max), b int, c int, d int, e int ,f int, g int, h int, i int); +insert into BINARY_dt (a,b,c,d,e,f,g,h,i) values (NULL,1,2,3,4,5,6,7,8); +select * from BINARY_dt; +drop table BINARY_dt; + +CREATE TABLE BINARY_dt(a BINARY(8), b VARBINARY(10)); +INSERT INTO BINARY_dt(a, b) values (1234, 12345); +prepst#!# INSERT INTO BINARY_dt(a, b) values(@a, @b) #!#binary|-|a|-|1234#!#varbinary|-|b|-|12345 +prepst#!#exec#!#binary|-|a|-|12345678#!#varbinary|-|b|-|12345 +prepst#!#exec#!#binary|-|a|-|1234#!#varbinary|-|b|-|123456789 +SELECT * FROM BINARY_dt; +DROP TABLE BINARY_dt; + + diff --git a/test/JDBC/input/jtds/jtds-TestCursorFetchNext.txt b/test/JDBC/input/jtds/jtds-TestCursorFetchNext.txt new file mode 100644 index 0000000000..5e91656019 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestCursorFetchNext.txt @@ -0,0 +1,93 @@ +CREATE TABLE test_cursors_fetch_next(a INT, b SMALLINT, c BIGINT, d TINYINT, e BIT); +INSERT INTO test_cursors_fetch_next values(0, 0, 0, 0, 0) +INSERT INTO test_cursors_fetch_next values(NULL, NULL, NULL, NULL, NULL) +INSERT INTO test_cursors_fetch_next values(1, 2, 3, 4, 1) +INSERT INTO test_cursors_fetch_next values(211234, 9780, 891372401, 56, 1) +# SET escape_hatch_session_settings to ignore CURSOR_CLOSE_ON_COMMIT +EXEC sp_babelfish_configure 'babelfishpg_tsql.escape_hatch_session_settings', 'ignore'; +cursor#!#open#!#SELECT * FROM test_cursors_fetch_next#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +cursor#!#fetch#!#next +cursor#!#fetch#!#abs#!#2 +cursor#!#fetch#!#next +cursor#!#fetch#!#first +cursor#!#fetch#!#next +#cursor#!#fetch#!#last +cursor#!#fetch#!#abs#!#4 +cursor#!#fetch#!#next +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +DROP TABLE test_cursors_fetch_next + +CREATE TABLE test_cursors_fetch_next(a CHAR(30), b VARCHAR(30), c NCHAR(30), d NVARCHAR(30)); +INSERT INTO test_cursors_fetch_next values(' ', ' ', ' ', ' ') +INSERT INTO test_cursors_fetch_next values(NULL, NULL, NULL, NULL) +INSERT INTO test_cursors_fetch_next values('hello', 'from the', N'server', N'side 😆') +INSERT INTO test_cursors_fetch_next values('Its', 'always', N'day', N'1') +cursor#!#open#!#SELECT * FROM test_cursors_fetch_next#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +cursor#!#fetch#!#abs#!#3 +cursor#!#fetch#!#next +cursor#!#fetch#!#first +cursor#!#fetch#!#next +#cursor#!#fetch#!#last +cursor#!#fetch#!#abs#!#4 +cursor#!#fetch#!#next +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +DROP TABLE test_cursors_fetch_next + +CREATE TABLE test_cursors_fetch_next(a DATE, b DATETIME, c SMALLDATETIME); +INSERT INTO test_cursors_fetch_next values('2000-12-13', '1900-02-28 23:59:59.989', '2000-12-13 12:58:23') +INSERT INTO test_cursors_fetch_next values(NULL, NULL, NULL) +INSERT INTO test_cursors_fetch_next values('1997-05-07', '1900-02-28 11:23:17.895', '2000-12-13 10:23:44') +INSERT INTO test_cursors_fetch_next values('1876-08-07', '1980-02-05 16:11:45.215', '1987-10-01 07:55:24') +cursor#!#open#!#SELECT * FROM test_cursors_fetch_next#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +cursor#!#fetch#!#first +cursor#!#fetch#!#abs#!#4 +cursor#!#fetch#!#next +cursor#!#fetch#!#first +cursor#!#fetch#!#next +#cursor#!#fetch#!#last +cursor#!#fetch#!#abs#!#4 +cursor#!#fetch#!#next +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +DROP TABLE test_cursors_fetch_next + +CREATE TABLE test_cursors_fetch_next(a FLOAT, b REAL, c MONEY, d SMALLMONEY); +INSERT INTO test_cursors_fetch_next values(0, 0, '$0', '$0') +INSERT INTO test_cursors_fetch_next values(NULL, NULL, NULL, NULL) +INSERT INTO test_cursors_fetch_next values(241.7832, 1214.691236, '62,514.00', '690.817') +INSERT INTO test_cursors_fetch_next values('32546', '980.709', '1,988,232.08', '$86,798') +cursor#!#open#!#SELECT * FROM test_cursors_fetch_next#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +cursor#!#fetch#!#next +cursor#!#fetch#!#abs#!#2 +cursor#!#fetch#!#next +cursor#!#fetch#!#first +cursor#!#fetch#!#next +#cursor#!#fetch#!#last +cursor#!#fetch#!#abs#!#4 +cursor#!#fetch#!#next +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +DROP TABLE test_cursors_fetch_next +EXEC sp_babelfish_configure 'babelfishpg_tsql.escape_hatch_session_settings', 'strict'; diff --git a/test/JDBC/input/jtds/jtds-TestCursorPrepExecFetchNext.txt b/test/JDBC/input/jtds/jtds-TestCursorPrepExecFetchNext.txt new file mode 100644 index 0000000000..dd61e42db0 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestCursorPrepExecFetchNext.txt @@ -0,0 +1,97 @@ +CREATE TABLE test_cursor_prep_exec_fetch_next(a INT, b SMALLINT, c BIGINT, d TINYINT, e BIT); +INSERT INTO test_cursor_prep_exec_fetch_next values(0, 0, 0, 0, 0) +INSERT INTO test_cursor_prep_exec_fetch_next values(NULL, NULL, NULL, NULL, NULL) +INSERT INTO test_cursor_prep_exec_fetch_next values(1, 2, 3, 4, 1) +INSERT INTO test_cursor_prep_exec_fetch_next values(211234, 9780, 891372401, 56, 1) + +# SET escape_hatch_session_settings to ignore CURSOR_CLOSE_ON_COMMIT +EXEC sp_babelfish_configure 'babelfishpg_tsql.escape_hatch_session_settings', 'ignore'; +cursor#!#open#!#prepst#!#SELECT * FROM test_cursor_prep_exec_fetch_next WHERE a > @a #!#INT|-|a|-|-2#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +cursor#!#fetch#!#next +cursor#!#fetch#!#abs#!#2 +cursor#!#fetch#!#next +cursor#!#fetch#!#first +cursor#!#fetch#!#next +cursor#!#close +cursor#!#open#!#prepst#!#exec#!#INT|-|a|-|0#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#HOLD_CURSORS_OVER_COMMIT +#cursor#!#fetch#!#last +cursor#!#fetch#!#next +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +DROP TABLE test_cursor_prep_exec_fetch_next + +CREATE TABLE test_cursor_prep_exec_fetch_next(a CHAR(30), b VARCHAR(30), c NCHAR(30), d NVARCHAR(30)); +INSERT INTO test_cursor_prep_exec_fetch_next values(' ', ' ', ' ', ' ') +INSERT INTO test_cursor_prep_exec_fetch_next values(NULL, NULL, NULL, NULL) +INSERT INTO test_cursor_prep_exec_fetch_next values('hello', 'from the', N'server', N'side 😆') +INSERT INTO test_cursor_prep_exec_fetch_next values('Its', 'always', N'day', N'1') +cursor#!#open#!#prepst#!#SELECT * FROM test_cursor_prep_exec_fetch_next WHERE a <> @a #!#CHAR|-|a|-|hello#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +cursor#!#fetch#!#abs#!#3 +cursor#!#fetch#!#next +cursor#!#fetch#!#first +cursor#!#fetch#!#next +cursor#!#close +cursor#!#open#!#prepst#!#exec#!#CHAR|-|a|-|Its#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +#cursor#!#fetch#!#last +cursor#!#fetch#!#next +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +DROP TABLE test_cursor_prep_exec_fetch_next + +CREATE TABLE test_cursor_prep_exec_fetch_next(a DATE, b DATETIME, c SMALLDATETIME); +INSERT INTO test_cursor_prep_exec_fetch_next values('2000-12-13', '1900-02-28 23:59:59.989', '2000-12-13 12:58:23') +INSERT INTO test_cursor_prep_exec_fetch_next values(NULL, NULL, NULL) +INSERT INTO test_cursor_prep_exec_fetch_next values('1997-05-07', '1900-02-28 11:23:17.895', '2000-12-13 10:23:44') +INSERT INTO test_cursor_prep_exec_fetch_next values('1876-08-07', '1980-02-05 16:11:45.215', '1987-10-01 07:55:24') +cursor#!#open#!#prepst#!#SELECT * FROM test_cursor_prep_exec_fetch_next WHERE b > @b #!#DATETIME|-|b|-|1753-01-01 00:00:00.000#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +cursor#!#fetch#!#first +cursor#!#fetch#!#abs#!#2 +cursor#!#fetch#!#next +cursor#!#fetch#!#first +cursor#!#fetch#!#next +cursor#!#close +cursor#!#open#!#prepst#!#exec#!#DATETIME|-|b|-|1947-01-01 11:23:17.374#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +#cursor#!#fetch#!#last +cursor#!#fetch#!#next +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +DROP TABLE test_cursor_prep_exec_fetch_next + +CREATE TABLE test_cursor_prep_exec_fetch_next(a FLOAT, b REAL, c MONEY, d SMALLMONEY); +INSERT INTO test_cursor_prep_exec_fetch_next values(0, 0, '$0', '$0') +INSERT INTO test_cursor_prep_exec_fetch_next values(NULL, NULL, NULL, NULL) +INSERT INTO test_cursor_prep_exec_fetch_next values(241.7832, 1214.691236, '62,514.00', '690.817') +INSERT INTO test_cursor_prep_exec_fetch_next values('32546', '980.709', '1,988,232.08', '$86,798') +cursor#!#open#!#prepst#!#SELECT * FROM test_cursor_prep_exec_fetch_next WHERE b > @b #!#REAL|-|b|-|12.0834#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +cursor#!#fetch#!#next +cursor#!#fetch#!#abs#!#3 +cursor#!#fetch#!#next +cursor#!#fetch#!#first +cursor#!#fetch#!#next +cursor#!#close +cursor#!#open#!#prepst#!#exec#!#REAL|-|b|-|1000.241#!#TYPE_SCROLL_INSENSITIVE#!#CONCUR_READ_ONLY#!#CLOSE_CURSORS_AT_COMMIT +#cursor#!#fetch#!#last +cursor#!#fetch#!#next +#cursor#!#fetch#!#prev +#cursor#!#fetch#!#next +#cursor#!#fetch#!#beforefirst +#cursor#!#fetch#!#next +#cursor#!#fetch#!#afterlast +#cursor#!#fetch#!#next +cursor#!#close +DROP TABLE test_cursor_prep_exec_fetch_next diff --git a/test/JDBC/input/jtds/jtds-TestDate.txt b/test/JDBC/input/jtds/jtds-TestDate.txt new file mode 100644 index 0000000000..5af2f499b2 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestDate.txt @@ -0,0 +1,14 @@ +CREATE TABLE DATE_dt (a DATE) +prepst#!# INSERT INTO DATE_dt(a) values(@a) #!#DATE|-|a|-|2000-12-13 +prepst#!#exec#!#DATE|-|a|-|2000-02-28 +prepst#!#exec#!#DATE|-|a|-|0001-01-01 +prepst#!#exec#!#DATE|-|a|-|9999-12-31 +prepst#!#exec#!#DATE|-|a|-| +SELECT * FROM DATE_dt; +INSERT INTO DATE_dt(a) values('2000-12-13') +INSERT INTO DATE_dt(a) values('1900-02-28') +INSERT INTO DATE_dt(a) values('0001-01-01') +INSERT INTO DATE_dt(a) values('9999-12-31') +INSERT INTO DATE_dt(a) values(NULL) +SELECT * FROM DATE_dt; +DROP TABLE DATE_dt; \ No newline at end of file diff --git a/test/JDBC/input/jtds/jtds-TestDatetime.txt b/test/JDBC/input/jtds/jtds-TestDatetime.txt new file mode 100644 index 0000000000..0ed515b165 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestDatetime.txt @@ -0,0 +1,83 @@ +CREATE TABLE DATETIME_dt (a DATETIME) +prepst#!# INSERT INTO DATETIME_dt(a) values(@a) #!#DATETIME|-|a|-|2000-12-13 12:58:23.123 +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.989 +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.990 +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.991 +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.992 +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.993 +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.994 +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.995 +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.996 +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.997 +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.998 +prepst#!#exec#!#DATETIME|-|a|-|2000-02-28 23:59:59.999 +prepst#!#exec#!#DATETIME|-|a|-|1900-02-28 23:59:59.989 +prepst#!#exec#!#DATETIME|-|a|-|1753-01-01 00:00:00.000 +prepst#!#exec#!#DATETIME|-|a|-|9999-12-31 23:59:59.997 +prepst#!#exec#!#DATETIME|-|a|-| +SELECT * FROM DATETIME_dt; +INSERT INTO DATETIME_dt(a) values('2000-12-13 12:58:23.123') +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.989') +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.990') +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.991') +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.992') +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.993') +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.994') +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.995') +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.996') +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.997') +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.998') +INSERT INTO DATETIME_dt(a) values('1900-02-28 23:59:59.999') +INSERT INTO DATETIME_dt(a) values('2000-02-28 23:59:59.989') +INSERT INTO DATETIME_dt(a) values('1753-01-01 00:00:00.000') +INSERT INTO DATETIME_dt(a) values('9999-12-31 23:59:59.997') +INSERT INTO DATETIME_dt(a) values(NULL) +SELECT * FROM DATETIME_dt; +DROP TABLE DATETIME_dt; + +select convert(datetime, '2022-11-10 09:15:30.000'); +select convert(datetime, '2022-11-10 09:15:30.001'); +select convert(datetime, '2022-11-10 09:15:30.002'); +select convert(datetime, '2022-11-10 09:15:30.003'); +select convert(datetime, '2022-11-10 09:15:30.004'); +select convert(datetime, '2022-11-10 09:15:30.005'); +select convert(datetime, '2022-11-10 09:15:30.006'); +select convert(datetime, '2022-11-10 09:15:30.007'); +select convert(datetime, '2022-11-10 09:15:30.008'); +select convert(datetime, '2022-11-10 09:15:30.009'); +select convert(datetime, '2022-11-10 09:15:30.999'); + +select convert(datetime, '2022-11-10 21:26:45.120'); +select convert(datetime, '2022-11-10 21:26:45.341'); +select convert(datetime, '2022-11-10 21:26:45.562'); +select convert(datetime, '2022-11-10 21:26:45.783'); +select convert(datetime, '2022-11-10 21:26:45.904'); +select convert(datetime, '2022-11-10 21:26:45.215'); +select convert(datetime, '2022-11-10 21:26:45.436'); +select convert(datetime, '2022-11-10 21:26:45.657'); +select convert(datetime, '2022-11-10 21:26:45.878'); +select convert(datetime, '2022-11-10 21:26:45.909'); + +select convert(datetime, '2000-12-13 12:58:23.123'); +select convert(datetime, '2000-12-13 12:58:23.223'); +select convert(datetime, '2000-12-13 12:58:23.323'); +select convert(datetime, '2000-12-13 12:58:23.423'); +select convert(datetime, '2000-12-13 12:58:23.523'); +select convert(datetime, '2000-12-13 12:58:23.623'); +select convert(datetime, '2000-12-13 12:58:23.723'); +select convert(datetime, '2000-12-13 12:58:23.823'); +select convert(datetime, '2000-12-13 12:58:23.923'); +select convert(datetime, '2000-12-13 12:58:23.023'); + +select convert(datetime, '1753-01-01 23:59:59.997'); +select convert(datetime, '1753-12-31 23:59:59.998'); +select convert(datetime, '1753-12-31 23:59:59.999'); +select convert(datetime, '9999-12-31 23:59:59.998'); +select convert(datetime, '9999-12-31 23:59:59.999'); +select convert(datetime, '1752-12-31 23:59:59.997'); +select convert(datetime, '0000-00-00 00:00:00.000'); +select convert(datetime, NULL); + +select convert(datetime, '1900-01-01 02:18:53.003') +select convert(datetime, '1900-01-02 00:00:00.003') +select convert(datetime, '1900-01-02 01:00:00.003') \ No newline at end of file diff --git a/test/JDBC/input/jtds/jtds-TestDatetime2.txt b/test/JDBC/input/jtds/jtds-TestDatetime2.txt new file mode 100644 index 0000000000..2a6062abb2 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestDatetime2.txt @@ -0,0 +1,15 @@ +Create table TestDatetime2(a Datetime2(6)) + +prepst#!# Insert into TestDatetime2 Values(@a) #!#Datetime2|-|a|-|2016-10-23 12:45:37.123|-|0 +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.123|-|3 +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.12|-|2 +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.1|-|1 +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.1234|-|4 +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.123456|-|6 +prepst#!#exec#!#Datetime2|-|a|-|2016-10-23 12:45:37.123456|-|5 +#prepst#!#exec#!#Datetime2|-|a|-|12:45:37.123456|-|5 +prepst#!#exec#!#Datetime2|-|a|-| + +select * from TestDatetime2 + +Drop table TestDatetime2 \ No newline at end of file diff --git a/test/JDBC/input/jtds/jtds-TestDatetimeoffset-vu-cleanup.sql b/test/JDBC/input/jtds/jtds-TestDatetimeoffset-vu-cleanup.sql new file mode 100644 index 0000000000..b6c273394c --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestDatetimeoffset-vu-cleanup.sql @@ -0,0 +1,9 @@ +-- Clean up +drop table TestDatetimeoffset_vu_prepare_testing; +go +drop table TestDatetimeoffset_vu_prepare_t1; +go +drop procedure TestDatetimeoffset_vu_prepare_cast; +go +drop procedure TestDatetimeoffset_vu_prepare_cmp; +go diff --git a/test/JDBC/input/jtds/jtds-TestDatetimeoffset-vu-prepare.sql b/test/JDBC/input/jtds/jtds-TestDatetimeoffset-vu-prepare.sql new file mode 100644 index 0000000000..203b06e221 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestDatetimeoffset-vu-prepare.sql @@ -0,0 +1,51 @@ +-- Testing inserting into the table +create table TestDatetimeoffset_vu_prepare_testing (df datetimeoffset); +go +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('23:40:29.998'); +go +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('1900-01-01 00:00+0:00'); +go +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('0001-01-01 00:00:00 +0:00'); +go +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('2020-03-15 09:00:00 +8:00'); +go +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('2020-03-15 09:00:00 +9:00'); +go +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('1800-03-15 09:00:00 +12:00'); +go +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('2020-03-15 09:00:00 -8:20'); +go +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('1992-03-15 09:00:00'); +go +-- out of range +INSERT INTO TestDatetimeoffset_vu_prepare_testing VALUES('10000-01-01 00:00:00 +0:00'); +go + +CREATE INDEX TestDatetimeoffset_vu_prepare_idx ON TestDatetimeoffset_vu_prepare_testing (df); +go + +-- Test datetimeoffset default value +create table TestDatetimeoffset_vu_prepare_t1 (a datetimeoffset, b int); +go +insert into TestDatetimeoffset_vu_prepare_t1 (b) values (1); +go + +-- test casting datetimeoffset inside procedure +-- NOTE: This is not supported behavior in tsql and will fail +CREATE PROCEDURE TestDatetimeoffset_vu_prepare_cast (@val datetimeoffset) AS +BEGIN + DECLARE @DF datetimeoffset = @val + PRINT @DF + PRINT cast(@DF as datetimeoffset(5)) +END; +go + +-- test comparing datetimeoffset inside procedure +CREATE PROCEDURE TestDatetimeoffset_vu_prepare_cmp (@val datetimeoffset) AS +BEGIN + IF @val > CAST('2000-01-01 13:39:29.123456 +0:00' AS datetimeoffset) + PRINT @val - make_interval(1) + ELSE + PRINT @val + make_interval(1) +END; +go diff --git a/test/JDBC/input/jtds/jtds-TestDatetimeoffset-vu-verify.sql b/test/JDBC/input/jtds/jtds-TestDatetimeoffset-vu-verify.sql new file mode 100644 index 0000000000..dca494319e --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestDatetimeoffset-vu-verify.sql @@ -0,0 +1,292 @@ +select * from TestDatetimeoffset_vu_prepare_testing; +go + +-- Test comparision with datetime/smalldatetime/date +select * from TestDatetimeoffset_vu_prepare_testing where df >= '2020-03-15 00:00:00'; +go +select * from TestDatetimeoffset_vu_prepare_testing where df >= '2020-03-15 09:00:00 +7'; +go +select * from TestDatetimeoffset_vu_prepare_testing where df >= '2020-03-15 09:00:00 +8' + and df < '2020-03-15 09:00:00'; +go +select * from TestDatetimeoffset_vu_prepare_testing where df < '1992-05-24'; +go + +-- Test datetimeoffset default value +select a from TestDatetimeoffset_vu_prepare_t1 where b = 1; +go + +-- Testing rounding for different typmod +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset); +go +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(0)); +go +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(1)); +go +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(2)); +go +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(3)); +go +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(4)); +go +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(5)); +go +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(6)); +go +-- Testing edge cases +select CAST('1900-06-06 20:00:00.499 +0:00' AS datetimeoffset(0)); +go +select CAST('1900-06-06 20:00:00.500 +0:00' AS datetimeoffset(0)); +go +select CAST('1900-06-06 20:00:00.501 +0:00' AS datetimeoffset(0)); +go +select CAST('2079-06-06 20:00:00.499 +0:00' AS datetimeoffset(0)); +go +select CAST('2079-06-06 20:00:00.500 +0:00' AS datetimeoffset(0)); +go +select CAST('2079-06-06 20:00:00.501 +0:00' AS datetimeoffset(0)); +go +select CAST('1979-06-06 20:00:00.000499 +0:00' AS datetimeoffset(3)); +go +select CAST('1979-06-06 20:00:00.000500 +0:00' AS datetimeoffset(3)); +go +select CAST('1979-06-06 20:00:00.000501 +0:00' AS datetimeoffset(3)); +go +select CAST('2079-06-06 20:00:00.000499 +0:00' AS datetimeoffset(3)); +go +select CAST('2079-06-06 20:00:00.000500 +0:00' AS datetimeoffset(3)); +go +select CAST('2079-06-06 20:00:00.000501 +0:00' AS datetimeoffset(3)); +go +select CAST('1979-06-06 20:00:00.000049 +0:00' AS datetimeoffset(4)); +go +select CAST('1979-06-06 20:00:00.000050 +0:00' AS datetimeoffset(4)); +go +select CAST('1979-06-06 20:00:00.000051 +0:00' AS datetimeoffset(4)); +go +select CAST('2079-06-06 20:00:00.000049 +0:00' AS datetimeoffset(4)); +go +select CAST('2079-06-06 20:00:00.000050 +0:00' AS datetimeoffset(4)); +go +select CAST('2079-06-06 20:00:00.000051 +0:00' AS datetimeoffset(4)); +go +select CAST('1979-06-06 20:00:00.000004 +0:00' AS datetimeoffset(5)); +go +select CAST('1979-06-06 20:00:00.000005 +0:00' AS datetimeoffset(5)); +go +select CAST('2079-06-06 20:00:00.000004 +0:00' AS datetimeoffset(5)); +go +select CAST('2079-06-06 20:00:00.000005 +0:00' AS datetimeoffset(5)); +go +-- out of range +select CAST('2079-06-06 23:59:29.123456 -9:30' AS datetimeoffset(7)); +go + +-- Test type cast to/from other time formats +-- Test datetime/dateime2 +select CAST(CAST('2020-03-15 23:59:29.99' AS datetime) AS datetimeoffset); +go +select CAST(CAST('2079-06-06 23:59:29.998 +8:00' AS datetimeoffset) AS datetime); +go +select CAST(CAST('2079-06-06 23:59:29.998 -9:30' AS datetimeoffset) AS datetime); +go +select CAST(CAST('1920-05-25 00:59:29.99' AS datetime2) AS datetimeoffset); +go +select CAST(CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) AS datetime2); +go + +-- Test date +select CAST(CAST('1999-12-31' AS date) AS datetimeoffset); +go +select CAST(CAST('0001-12-31' AS date) AS datetimeoffset); +go +select CAST(CAST('2000-01-01 23:59:59.999' AS datetimeoffset) AS date); +go +select CAST(CAST('2000-01-01 23:59:59.999+8' AS datetimeoffset) AS date); +go +select CAST(CAST('1900-05-06 23:59:29.998+8:20' AS datetimeoffset) AS date); +go +-- out of range +select CAST(CAST('12000-01-01' AS date) AS datetimeoffset); +go + +-- Test time +select CAST(CAST('23:59:59.999' AS time) AS datetimeoffset); +go +select CAST(CAST('00:30:31' AS time) AS datetimeoffset); +go +select CAST(CAST('1900-05-06 23:59:29.998+8:00' AS datetimeoffset) AS time); +go +select CAST(CAST('1920-05-25 00:59:29.99 +0' AS datetimeoffset) AS time); +go +select CAST(CAST('2050-05-06 00:00:00 +0' AS datetimeoffset) AS time); +go +select CAST(CAST('2050-05-06 12:00:00 +0' AS datetimeoffset) AS time); +go +select CAST(CAST('2050-05-06 15:31:22 +0' AS datetimeoffset) AS time); +go +select CAST(CAST('2050-05-06 23:59:29.998+8:00' AS datetimeoffset) AS time); +go + +-- Test smalldatetime +select CAST(CAST('2000-06-06 23:59:29.998 -9:30' AS datetimeoffset) AS smalldatetime); +go +select CAST(CAST('2079-06-06 23:59:29.998 +8:00' AS datetimeoffset) AS smalldatetime); +go +select CAST(CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) AS smalldatetime); +go +select CAST(CAST('2020-03-15 23:59:29.99' AS smalldatetime) AS datetimeoffset); +go +select CAST(CAST('1920-05-25 00:59:29.99' AS smalldatetime) AS datetimeoffset); +go +-- out of range +select CAST(CAST('8000-05-25 00:59:29.99' AS smalldatetime) AS datetimeoffset); +go + +-- Test datetimeoffset value ranges +select cast('0001-01-01 +0' as datetimeoffset); +go +select cast('0001-01-01 -1' as datetimeoffset); +go +select cast('2079-06-06 23:59:29.998 +0' as datetimeoffset); +go +select cast('9999-12-31 23:59:29.998 +0' as datetimeoffset); +go +-- out of range +select cast('0001-01-01 +0 BC' as datetimeoffset); +go +-- out of range +select cast('0001-01-01 +1' as datetimeoffset); +go +-- out of range +select cast('0001-01-01 +0:20' as datetimeoffset); +go +-- out of range +select cast('9999-12-31 23:59:29.998 -1' as datetimeoffset); +go +-- out of range +select cast('10000-01-01 00:00' as datetimeoffset); +go + +-- Testing arithmetic operators +-- Testing datetimeoffset adding interval +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(1); +go +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0,1); +go +select CAST('1900-01-30 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0,1); +go +select CAST('1900-12-31 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0,1); +go +select CAST('2000-02-29 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(1,0); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0,1,3); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0,0,1); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(1,0,3); +go +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(1, 2, 3, 4, 5, 6, 7); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(1, 2, 3, 4, 5, 6, 7); +go +-- SQL Server does not support named parameters in functions, only in prodecures +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0, 0, 0, 0, 0, 70); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) + make_interval(0, 0, 0, 0, 0, -70); +go +-- Testing interval adding datetimeoffset +select make_interval(1) + CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset); +go +select make_interval(1, 2, 3, 4, 5, 6, 7) + CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) ; +go +select make_interval(0, 0, 0, 0, 0, 70) + CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset); +go +-- Testing datetimeoffset subtracting interval +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1); +go +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0,1); +go +select CAST('1900-01-31 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0,1); +go +select CAST('2000-02-29 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1,0); +go +select CAST('2000-03-31 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1,0); +go +select CAST('2050-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0,1,3); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0,0,1); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1,0,3); +go +select CAST('1900-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1, 2, 3, 4, 5, 6, 7); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(1, 2, 3, 4, 5, 6, 7); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0, 0, 0, 0, 0, 70); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - make_interval(0, 0, 0, 0, 0, -70); +go +-- Testing datetimeoffset subtracting datetimeoffset +select CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) - CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - CAST('2030-05-06 13:59:29.998 +8:20' AS datetimeoffset); +go +select CAST('2030-05-06 13:59:29.998 -8:00' AS datetimeoffset) - CAST('1992-05-06 13:20:29.998 +0:00' AS datetimeoffset); +go +select CAST('0001-05-06 13:59:29.998 -8:00' AS datetimeoffset) - CAST('9950-05-06 13:20:29.998 +0:00' AS datetimeoffset); +go + +-- Test date functions +select ISDATE('2030-05-06 13:59:29.998 -8:00'); +go +-- TODO Fix [BABEL-883] missing TDS support for type regtype (was pg_typeof produces error in sqlcmd) +select pg_typeof(sysdatetimeoffset()); +go + +-- Test data type precedence +select pg_typeof(c1) FROM (SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1 UNION SELECT CAST('2016-12-26 23:30:05' AS datetime) as C1) T; +go +select pg_typeof(c1) FROM (SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1 UNION SELECT CAST('2016-12-26 23:30:05' AS datetime2) as C1) T; +go +select pg_typeof(c1) FROM (SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1 UNION SELECT CAST('2016-12-26 23:30:05' AS smalldatetime) as C1) T; +go +select pg_typeof(c1) FROM (SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1 UNION SELECT CAST('23:30:05' AS time) as C1) T; +go +select pg_typeof(c1) FROM (SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1 UNION SELECT CAST('2016-12-26' AS date) as C1) T; +go +select pg_typeof(c1) FROM (SELECT CAST('2016-12-26 23:30:05' AS datetime) as C1 UNION SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset)as C1) T; +go +select pg_typeof(c1) FROM (SELECT CAST('2016-12-26 23:30:05' AS datetime2) as C1 UNION SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1) T; +go +select pg_typeof(c1) FROM (SELECT CAST('2016-12-26 23:30:05' AS smalldatetime) as C1 UNION SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1) T; +go +select pg_typeof(c1) FROM (SELECT CAST('23:30:05' AS time) as C1 UNION SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1) T; +go +select pg_typeof(c1) FROM (SELECT CAST('2016-12-26' AS date) as C1 UNION SELECT CAST('2030-05-06 13:59:29.998 +0:00' AS datetimeoffset) as C1) T; +go + +-- test casting datetimeoffset inside procedure +-- NOTE: This is not supported behavior in tsql and will fail +DECLARE @dto datetimeoffset = CAST('2030-05-06 13:39:29.123456 +0:00' AS datetimeoffset); +exec TestDatetimeoffset_vu_prepare_cast @dto; +go +DECLARE @dto datetimeoffset = CAST('1920-05-06 13:39:29.123456 +0:00' AS datetimeoffset); +exec TestDatetimeoffset_vu_prepare_cast @dto; +go +-- expect error +DECLARE @dto datetimeoffset = CAST('19200-05-06 13:39:29.123456 +0:00' AS datetimeoffset); +exec TestDatetimeoffset_vu_prepare_cast @dto; +go + +-- test comparing datetimeoffset inside procedure +DECLARE @dto datetimeoffset = CAST('2030-05-06 13:39:29.123456 +0:00' AS datetimeoffset); +exec TestDatetimeoffset_vu_prepare_cmp @dto; +go +DECLARE @dto datetimeoffset = CAST('1930-05-06 13:39:29.123456 +0:00' AS datetimeoffset); +exec TestDatetimeoffset_vu_prepare_cmp @dto; +go diff --git a/test/JDBC/input/jtds/jtds-TestErrorsWithTryCatch.sql b/test/JDBC/input/jtds/jtds-TestErrorsWithTryCatch.sql new file mode 100644 index 0000000000..283269a4da --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestErrorsWithTryCatch.sql @@ -0,0 +1,979 @@ +CREATE TABLE ErrorWithTryCatchTable (a varchar(15) UNIQUE NOT NULL, b nvarchar(25), c int PRIMARY KEY, d char(15) DEFAULT 'Whoops!', e nchar(25), f datetime, g numeric(4,1) CHECK (g >= 103.5)) +GO + +-- setup for "invalid characters found: cannot cast value "%s" to money" error +CREATE TABLE t293_1(a money, b int); +GO + +INSERT INTO t293_1(a, b) values ($100, 1), ($101, 2); +GO + +-- setup for error "column \"%s\" of relation \"%s\" is a generated column" error +CREATE TABLE t1752_2(c1 INT, c2 INT, c3 as c1*c2) +GO + +-- setup for "A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations" error +CREATE TABLE t141_2(c1 int, c2 int); +GO + +-- Error: duplicate key value violates unique constraint +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: duplicate key value violates unique constraint +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: duplicate key value violates unique constraint +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: duplicate key value violates unique constraint +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: duplicate key value violates unique constraint +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: duplicate key value violates unique constraint +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + + + + +-- Error: check constraint violation +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: check constraint violation +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: check constraint violation +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: check constraint violation +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: check constraint violation +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: check constraint violation +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET g = 101.4 WHERE c = 1; + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + + + + + + + +-- Error: not null constraint violation +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: not null constraint violation +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: not null constraint violation +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: not null constraint violation +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: not null constraint violation +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: not null constraint violation +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE ErrorWithTryCatchTable SET c = NULL WHERE c = 1; + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + + + + + + + +-- Error: creating an existing table +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: creating an existing table +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: creating an existing table +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: creating an existing table +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: creating an existing table +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: creating an existing table +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE ErrorWithTryCatchTable (a int); + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + + + + + + + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_2 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + + +-- Error: "A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations" +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_2; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations" +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_2; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: "value for domain tinyint violates check constraint "tinyint_check"" +-- Simple error inside try-catch +BEGIN TRY + SELECT xact_state(); + DECLARE @a tinyint = 1000; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Simple batch with try catch +BEGIN TRY + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;'; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Simple batch with transaction inside try-catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;'; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Simple procedure inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;';; +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Transaction inside try-catch but not inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;'; +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Transaction inside procedure but not inside try-catch +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;'; + COMMIT TRAN +END +GO +BEGIN TRY + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- Transaction inside try-catch and inside procedure +CREATE PROCEDURE errorWithTryCatchProc1 +AS +BEGIN + BEGIN TRAN + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE t293_1 SET a = convert(money, ''string'') WHERE b > 1;'; + COMMIT TRAN +END +GO +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + EXEC errorWithTryCatchProc1; +END TRY +BEGIN CATCH + SELECT xact_state(); +END CATCH; +GO +IF @@trancount > 0 ROLLBACK TRAN; +GO +DROP PROCEDURE errorWithTryCatchProc1 +GO +select * from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- valid INSERT inside catch after an error +-- Simple batch with try catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END TRY +BEGIN CATCH + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Orange', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END CATCH; +GO +select a from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + +-- invalid INSERT inside catch after an error +-- Simple batch with try catch +BEGIN TRY + BEGIN TRAN + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END TRY +BEGIN CATCH + SELECT xact_state(); + INSERT INTO ErrorWithTryCatchTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +END CATCH; +GO +select a from ErrorWithTryCatchTable ORDER BY c +GO +truncate table ErrorWithTryCatchTable +GO + + +DROP TABLE ErrorWithTryCatchTable +GO + +-- cleanup for "invalid characters found: cannot cast value "%s" to money" error +DROP TABLE t293_1; +GO + +-- cleanup for error "column \"%s\" of relation \"%s\" is a generated column" error +DROP TABLE t1752_2 +GO + +-- cleanup for "A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations" error +DROP TABLE t141_2; +GO + +while (@@trancount > 0) commit tran; +GO + diff --git a/test/JDBC/input/jtds/jtds-TestSQLQueries.txt b/test/JDBC/input/jtds/jtds-TestSQLQueries.txt new file mode 100644 index 0000000000..e05f6d742d --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestSQLQueries.txt @@ -0,0 +1,234 @@ +#1 CREATE TABLE with primary and unique keyword +EXEC sp_babelfish_configure 'babelfishpg_tsql.escape_hatch_unique_constraint', 'ignore'; +CREATE TABLE tmp(a int PRIMARY KEY, b int UNIQUE); +INSERT INTO tmp(a,b) values(1,1); +INSERT INTO tmp(a,b) values(2,2); +SELECT * FROM tmp; +DROP TABLE tmp; + +#2 2 table with foreign key relation +#CREATE TABLE tmp1(b int PRIMARY KEY); +#CREATE TABLE tmp2(a int PRIMARY KEY, b int FOREIGN KEY REFERENCES tmp1(b)); +#INSERT INTO tmp1(b) VALUES (1); +#INSERT INTO tmp2(a,b) values(1,1); +#SELECT * FROM tmp1; +#SELECT * FROM tmp2; +#DROP TABLE tmp2; +#DROP TABLE tmp1; + +#3 Repeated #2 with CONSTRAINT keyword +#CREATE TABLE tmp1(b int PRIMARY KEY); +#CREATE TABLE tmp2(a int, b int, PRIMARY KEY(a), CONSTRAINT FK_tmp FOREIGN KEY (b) REFERENCES tmp1(b)); +#INSERT INTO tmp1(b) VALUES (1); +#INSERT INTO tmp2(a,b) values(1,1); +#SELECT * FROM tmp1; +#SELECT * FROM tmp2; +#DROP TABLE tmp2; +#DROP TABLE tmp1; + +#4 CREATE TABLE with NOT NULL column +CREATE TABLE tmp(a int PRIMARY KEY,b int NOT NULL); +INSERT INTO tmp(a,b) values(1,1); +INSERT INTO tmp(a,b) values(2,1); +#INSERT INTO tmp(a,b) values(2,NULL); +SELECT * FROM tmp; +DROP TABLE tmp; + +#5 INSERTION and DELETION +CREATE TABLE tmp(a int PRIMARY KEY); +INSERT INTO tmp(a) VALUES(1); +INSERT INTO tmp(a) VALUES(2); +INSERT INTO tmp(a) VALUES(3); +INSERT INTO tmp(a) VALUES(4); +INSERT INTO tmp(a) VALUES(5); +SELECT * FROM tmp; +DELETE FROM tmp WHERE a>2; +SELECT * FROM tmp; +DROP TABLE tmp; + +#6 IS NOT NULL condition in WHERE clause +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) values(1,1); +INSERT INTO tmp(a,b) values(2,1); +INSERT INTO tmp(a,b) values(3,NULL); +INSERT INTO tmp(a,b) values(4,NULL); +SELECT * FROM tmp WHERE b IS NOT NULL; +DROP TABLE tmp; + +#7 Add new column using ALTER TABLE +CREATE TABLE tmp(a int PRIMARY KEY); +INSERT INTO tmp(a) VALUES(1); +INSERT INTO tmp(a) VALUES(2); +SELECT * FROM tmp; +ALTER TABLE tmp ADD b VARCHAR(20) NULL; +SELECT * FROM tmp; +INSERT INTO tmp(a,b) VALUES(4,'Dipesh'); +INSERT INTO tmp(a,b) VALUES(5,' Dipesh'); +SELECT * FROM tmp; +DROP TABLE tmp; + +#8 Repeated #8 with default value for newly added col +CREATE TABLE tmp(a int PRIMARY KEY); +INSERT INTO tmp(a) VALUES(1); +INSERT INTO tmp(a) VALUES(2); +SELECT * FROM tmp; +ALTER TABLE tmp ADD b VARCHAR(20) DEFAULT 'Dipesj'; +SELECT * FROM tmp; +INSERT INTO tmp(a,b) VALUES(4,'Dipesh'); +INSERT INTO tmp(a,b) VALUES(5,' Dipesh'); +SELECT * FROM tmp; +DROP TABLE tmp; + +#9 Change datatype of existing column using ALTER TABLE +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1); +INSERT INTO tmp(a,b) VALUES(2,2); +SELECT * FROM tmp; +ALTER TABLE tmp ALTER COLUMN b VARCHAR(10); +SELECT * FROM tmp; +INSERT INTO tmp(a,b) VALUES(4,'Dipesh'); +INSERT INTO tmp(a,b) VALUES(5,' Dipesh'); +SELECT * FROM tmp; +DROP TABLE tmp; + +#10 UPDATE TABLE with fancy condition +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1); +INSERT INTO tmp(a,b) VALUES(2,2); +INSERT INTO tmp(a,b) VALUES(3,3); +INSERT INTO tmp(a,b) VALUES(4,4); +INSERT INTO tmp(a,b) VALUES(5,5); +SELECT * FROM tmp; +UPDATE tmp SET b=b+1 WHERE b>2; +SELECT * FROM tmp; +DROP TABLE tmp; + +#11 DROP some column using ALTER TABLE +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1); +INSERT INTO tmp(a,b) VALUES(2,2); +INSERT INTO tmp(a,b) VALUES(3,3); +INSERT INTO tmp(a,b) VALUES(4,4); +INSERT INTO tmp(a,b) VALUES(5,5); +SELECT * FROM tmp; +#ALTER TABLE tmp DROP COLUMN b; +#INSERT INTO tmp(a) values (6); +#SELECT * FROM tmp; +DROP TABLE tmp; + +#12 CREATE TABLE with fancy constraint +CREATE TABLE tmp(a int PRIMARY KEY CHECK (a>10),b int); +INSERT INTO tmp(a,b) VALUES(11,1); +INSERT INTO tmp(a,b) VALUES(12,2); +INSERT INTO tmp(a,b) VALUES(13,3); +INSERT INTO tmp(a,b) VALUES(14,4); +INSERT INTO tmp(a,b) VALUES(15,5); +SELECT * FROM tmp; +DROP TABLE tmp; + +#CREATE PROCEDURE tmp AS +#BEGIN +# CREATE TABLE dip(a int PRIMARY KEY CHECK (a>10),b int); +# INSERT INTO dip(a,b) VALUES(11,1); +# INSERT INTO dip(a,b) VALUES(12,2); +# INSERT INTO dip(a,b) VALUES(13,3); +# INSERT INTO dip(a,b) VALUES(14,4); +# INSERT INTO dip(a,b) VALUES(15,5); +# SELECT * FROM dip; +# DROP TABLE dip; +#END; + +#13 invoke simple stored procedure using EXECUTE +EXECUTE tmp; + +#14 invoke simple stored procedure using EXEC +EXEC tmp; + +#DROP PROCEDURE tmp; + +#15 UPDATE rows in existing table +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1),(2,2),(3,3),(4,4),(5,5); +SELECT * FROM tmp; +UPDATE tmp SET b=b*2+1 WHERE (a>2); +SELECT * FROM tmp; +DROP TABLE tmp; + +#16 TRUNCATE table +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1),(2,2),(3,3),(4,4),(5,5); +SELECT * FROM tmp; +TRUNCATE TABLE tmp; +SELECT * FROM tmp; +DROP TABLE tmp; + +CREATE TABLE temp1 (i INT,j INT,t TEXT); + +CREATE TABLE temp2 ( i INT,k INT); + +INSERT INTO temp1 VALUES (1, 4, 'one'); +INSERT INTO temp1 VALUES (2, 3, 'two'); +INSERT INTO temp1 VALUES (3, 2, 'three'); +INSERT INTO temp1 VALUES (4, 1, 'four'); +INSERT INTO temp1 VALUES (5, 0, 'five'); +INSERT INTO temp1 VALUES (6, 6, 'six'); +INSERT INTO temp1 VALUES (7, 7, 'seven'); +INSERT INTO temp1 VALUES (8, 8, 'eight'); +INSERT INTO temp1 VALUES (0, NULL, 'zero'); +INSERT INTO temp1 VALUES (NULL, NULL, NULL); +INSERT INTO temp1 VALUES (NULL, 0, 'zero'); + +INSERT INTO temp2 VALUES (1, -1); +INSERT INTO temp2 VALUES (2, 2); +INSERT INTO temp2 VALUES (3, -3); +INSERT INTO temp2 VALUES (2, 4); +INSERT INTO temp2 VALUES (5, -5); +INSERT INTO temp2 VALUES (5, -5); +INSERT INTO temp2 VALUES (0, NULL); +INSERT INTO temp2 VALUES (NULL, NULL); +INSERT INTO temp2 VALUES (NULL, 0); + +#17 CROSS JOIN +SELECT * FROM temp1 CROSS JOIN temp2; + +#18 INNER JOIN +SELECT temp1.i, temp1.j, temp1.t, temp2.k FROM temp1 INNER JOIN temp2 ON temp1.i=temp2.i ORDER BY temp1.i; +SELECT temp1.i, temp1.j, temp1.t, temp2.k FROM temp1 JOIN temp2 ON temp1.i=temp2.i ORDER BY temp1.i; + +#19 LEFT JOIN +SELECT * FROM temp1 LEFT OUTER JOIN temp2 ON temp1.i=temp2.k ORDER BY temp1.i; + +#20 RIGHT JOIN +SELECT * FROM temp1 RIGHT OUTER JOIN temp2 ON temp1.i=temp2.i ORDER BY temp1.i, temp2.k; + +#21 FULL OUTER JOIN +SELECT * FROM temp1,temp2; + +DROP TABLE temp1; +DROP TABLE temp2; + +#22 dropping all columns +CREATE TABLE tmp(a int PRIMARY KEY,b int); +INSERT INTO tmp(a,b) VALUES(1,1); +INSERT INTO tmp(a,b) VALUES(2,2); +INSERT INTO tmp(a,b) VALUES(3,3); +INSERT INTO tmp(a,b) VALUES(4,4); +INSERT INTO tmp(a,b) VALUES(5,5); +SELECT * FROM tmp; +#ALTER TABLE tmp DROP COLUMN b; +#ALTER TABLE tmp DROP COLUMN a; +#SELECT * FROM tmp; +DROP TABLE tmp; + +#23 +CREATE TABLE DATE_dt (a DATE); +INSERT INTO DATE_dt(a) values('2000-12-13'); +INSERT INTO DATE_dt(a) values('1900-02-28'); +INSERT INTO DATE_dt(a) values('0001-01-01'); +INSERT INTO DATE_dt(a) values('9999-12-31'); +INSERT INTO DATE_dt(a) values(NULL); +SELECT * FROM DATE_dt; +ALTER TABLE DATE_dt ALTER COLUMN a DATETIME; +SELECT * FROM DATE_dt; +DROP TABLE DATE_dt; +EXEC sp_babelfish_configure 'babelfishpg_tsql.escape_hatch_unique_constraint', 'strict'; diff --git a/test/JDBC/input/jtds/jtds-TestSQLVariant-vu-cleanup.sql b/test/JDBC/input/jtds/jtds-TestSQLVariant-vu-cleanup.sql new file mode 100644 index 0000000000..3e78704b93 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestSQLVariant-vu-cleanup.sql @@ -0,0 +1,78 @@ +drop table testsqlvariant_sourceTable1; +go + +drop table testsqlvariant_sourceTable2; +go + + +drop table testsqlvariant_sourceTable3; +go + +drop table testsqlvariant_sourceTable4; +go + +drop table testsqlvariant_sourceTable5; +go + +drop table testsqlvariant_sourceTable6; +go + +drop table testsqlvariant_sourceTable7; +go + + +DROP TABLE testsqlvariant_money_dt; +go + +drop table testsqlvariant_sourceTable8; +go + + +drop table testsqlvariant_sourceTable9; +go + + +drop table testsqlvariant_sourceTable10; +go + +drop table testsqlvariant_sourceTable11; +go + +drop table testsqlvariant_sourceTable12; +go + +drop table testsqlvariant_sourceTable13; +go + +drop table testsqlvariant_sourceTable14; +go + +drop table testsqlvariant_sourceTable15; +go + +drop table testsqlvariant_sourceTable16; +go + +drop table testsqlvariant_sourceTable17; +go + +drop table testsqlvariant_sourceTable18; +go + +drop table testsqlvariant_sourceTable19; +go + +drop table testsqlvariant_sourceTable20; +go + +drop table testsqlvariant_sourceTable21; +go + +drop view testsqlvariant_vu_prepare_view1; +go + +drop view testsqlvariant_vu_prepare_view2; +go + +drop table testsqlvariant_sourceTable22; +go diff --git a/test/JDBC/input/jtds/jtds-TestSQLVariant-vu-prepare.sql b/test/JDBC/input/jtds/jtds-TestSQLVariant-vu-prepare.sql new file mode 100644 index 0000000000..26fd486261 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestSQLVariant-vu-prepare.sql @@ -0,0 +1,271 @@ + +--[BABEL-582]Checking all base datatypes for sql_variant +--The following list of base datatypes cannot be stored by using sql_variant: +--[datetimeoffset(SQL server 2012), geography, geometry, hierarchyid, image, ntext, nvarchar(max), +--rowversion (timestamp), text, varchar(max), varbinary(max), User-defined types, xml] + +Create table testsqlvariant_sourceTable1(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable1 values (cast (1 as BIT),cast (1 as BIT)); +go +Insert into testsqlvariant_sourceTable1 values (cast (NULL as BIT), cast (0 as BIT)); +go + +Create table testsqlvariant_sourceTable2(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable2 values (cast (0 as TINYINT),cast (10 as TINYINT)); +go +Insert into testsqlvariant_sourceTable2 values (cast (002 as TINYINT),cast (029 as TINYINT)); +go +Insert into testsqlvariant_sourceTable2 values (cast (004 as TINYINT),cast (87 as TINYINT)); +go +Insert into testsqlvariant_sourceTable2 values (cast (255 as TINYINT),cast (1000 as TINYINT)); +go +Insert into testsqlvariant_sourceTable2 values (cast (NULL as TINYINT), cast (100 as TINYINT)); +go + +Create table testsqlvariant_sourceTable3(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable3 values (cast (0 as SMALLINT),cast (-10 as SMALLINT)); +go +Insert into testsqlvariant_sourceTable3 values (cast (002 as SMALLINT),cast (-029 as SMALLINT)); +go +Insert into testsqlvariant_sourceTable3 values (cast (876 as SMALLINT),cast (-1234 as SMALLINT)); +go +Insert into testsqlvariant_sourceTable3 values (cast (-32768 as SMALLINT),cast (32767 as SMALLINT)); +go +Insert into testsqlvariant_sourceTable3 values (cast (NULL as SMALLINT), cast (100 as SMALLINT)); +go + +Create table testsqlvariant_sourceTable4(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable4 values (cast (0 as INT),cast (-10 as INT)); +go +Insert into testsqlvariant_sourceTable4 values (cast (-12345 as INT),cast (10 as INT)); +go +Insert into testsqlvariant_sourceTable4 values (cast (004 as INT),cast (224466 as INT)); +go +Insert into testsqlvariant_sourceTable4 values (cast (-2147483648 as INT),cast (2147483647 as INT)); +go +Insert into testsqlvariant_sourceTable4 values (cast (NULL as INT), cast (100 as INT)); +go + + +Create table testsqlvariant_sourceTable5(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable5 values (cast (0 as BIGINT),cast (-120 as BIGINT)); +go +Insert into testsqlvariant_sourceTable5 values (cast (-12345 as BIGINT),cast (00100 as BIGINT)); +go +Insert into testsqlvariant_sourceTable5 values (cast (-12245532534 as BIGINT),cast (00000000000000086 as BIGINT)); +go +Insert into testsqlvariant_sourceTable5 values (cast (-9223372036854775808 as BIGINT),cast (9223372036854775807 as BIGINT)); +go +Insert into testsqlvariant_sourceTable5 values (cast (NULL as BIGINT), cast (-004 as BIGINT)); +go + +Create table testsqlvariant_sourceTable6(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable6 values (cast (0 as REAL),cast (1.050 as REAL)); +go +Insert into testsqlvariant_sourceTable6 values (cast (-004 as REAL),cast (01.05 as REAL)); +go +Insert into testsqlvariant_sourceTable6 values (cast (00000000000000086 as REAL),cast (-0122455324.5 as REAL)); +go +Insert into testsqlvariant_sourceTable6 values (cast (3.40E+38 as REAL),cast (-3.40E+38 as REAL)); +go +Insert into testsqlvariant_sourceTable6 values (cast (NULL as REAL), cast (-000002 as REAL)); +go + +Create table testsqlvariant_sourceTable7(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable7 values (cast (0 as FLOAT),cast (1.050 as FLOAT)); +go +Insert into testsqlvariant_sourceTable7 values (cast (-0012345234.5 as FLOAT),cast (01.05 as FLOAT)); +go +Insert into testsqlvariant_sourceTable7 values (cast (00000000000086 as FLOAT),cast (-00000002 as FLOAT)); +go +Insert into testsqlvariant_sourceTable7 values (cast (-1.79E+308 as FLOAT),cast (1.79E+308 as FLOAT)); +go +Insert into testsqlvariant_sourceTable7 values (cast (NULL as FLOAT), cast (100 as FLOAT)); +go + +CREATE TABLE testsqlvariant_money_dt(a sql_variant, b sql_variant); +go +prepst#!#INSERT INTO testsqlvariant_money_dt(a, b) VALUES (@a, @b) #!#smallmoney|-|a|-|100.5#!#money|-|b|-|10.05 +go +prepst#!#exec#!#smallmoney|-|a|-|10#!#money|-|b|-|10 +go +prepst#!#exec#!#smallmoney|-|a|-|-10.05 #!#money|-|b|-|-10.0 +go +prepst#!#exec#!#smallmoney|-|a|-|-214748.3648#!#money|-|b|-|-922337203685477.5808 +go +prepst#!#exec#!#smallmoney|-|a|-|214748.3647#!#money|-|b|-|22337203685477.5807 +go +prepst#!#exec#!#smallmoney|-|a|-|214748.3647#!#money|-|b|-|22337203685477.5807 +go +prepst#!#exec#!#smallmoney|-|a|-|-214,748.3648#!#money|-|b|-|-922,337,203,685,477.5808 +go +prepst#!#exec#!#smallmoney|-|a|-|214,748.3647#!#money|-|b|-|922,337,203,685,477.5807 +go +prepst#!#exec#!#smallmoney|-|a|-|214,748.3647#!#money|-|b|-|922,337,203,685,477.5807 +go +prepst#!#exec#!#smallmoney|-|a|-|#!#money|-|b|-| +go + +Create table testsqlvariant_sourceTable8(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable8 values (cast (0 as MONEY),cast ('$1050' as MONEY)); +go +Insert into testsqlvariant_sourceTable8 values (cast (NULL as MONEY), cast (-000002 as MONEY)); +go + +Create table testsqlvariant_sourceTable9(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable9 values (cast (0 as SMALLMONEY),cast ('$1050' as SMALLMONEY)); +go +Insert into testsqlvariant_sourceTable9 values (cast (NULL as SMALLMONEY), cast (-000002 as SMALLMONEY)); +go + +Create table testsqlvariant_sourceTable10(a sql_variant, b sql_variant not null); +go +INSERT INTO testsqlvariant_sourceTable10 values(CAST('2000-12-13' as DATE), CAST('1900-02-28' as DATE)) +go +INSERT INTO testsqlvariant_sourceTable10 values(CAST(NULL as DATE), CAST('0001-01-01' as DATE)) +go + + +Create table testsqlvariant_sourceTable11(a sql_variant, b sql_variant not null); +go +INSERT INTO testsqlvariant_sourceTable11 values(CAST('2007-05-08 12:35:29' as SMALLDATETIME), CAST('2007-05-08 12:35:30' as SMALLDATETIME)) +go +INSERT INTO testsqlvariant_sourceTable11 values(CAST('2007-05-08 12:59:59.998' as SMALLDATETIME), CAST('2000-02-28 23:59:59.999' as SMALLDATETIME)) +go +INSERT INTO testsqlvariant_sourceTable11 values(CAST('1900-02-28 23:59:59.999' as SMALLDATETIME), CAST('2000-02-28 23:45:29.999' as SMALLDATETIME)) +go +INSERT INTO testsqlvariant_sourceTable11 values(CAST(NULL as SMALLDATETIME), CAST('1900-01-01 00:00:00' as SMALLDATETIME)) +go + +Create table testsqlvariant_sourceTable12(a sql_variant, b sql_variant not null); +go +INSERT INTO testsqlvariant_sourceTable12 values(CAST('2000-12-13 12:58:23.123' as DATETIME), CAST('1900-02-28 23:59:59.989' as DATETIME)) +go +INSERT INTO testsqlvariant_sourceTable12 values(CAST('1900-02-28 23:59:59.990' as DATETIME), CAST('1900-02-28 23:59:59.992' as DATETIME)) +go +INSERT INTO testsqlvariant_sourceTable12 values(CAST('1900-02-28 23:59:59.994' as DATETIME), CAST('1900-02-28 23:59:59.996' as DATETIME)) +go +INSERT INTO testsqlvariant_sourceTable12 values(CAST('1900-02-28 23:59:59.998' as DATETIME), CAST('1753-01-01 00:00:00.000' as DATETIME)) +go +INSERT INTO testsqlvariant_sourceTable12 values(CAST(NULL as DATETIME), CAST('9999-12-31 23:59:59.997' as DATETIME)) +go + + +Create table testsqlvariant_sourceTable13(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable13 values (cast ('Satarupa' as CHAR(24)),cast (' Satarupa' as CHAR(24))); +go +Insert into testsqlvariant_sourceTable13 values (cast ('' as CHAR(24)),cast (' S,B' as CHAR(24))); +go +Insert into testsqlvariant_sourceTable13 values (cast (NULL as CHAR(24)), cast (' ' as CHAR(24))); +go + +Create table testsqlvariant_sourceTable14(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable14 values (cast ('Satarupa' as NCHAR(24)),cast (' Satarupa' as NCHAR(24))); +go +Insert into testsqlvariant_sourceTable14 values (cast ('' as NCHAR(24)),cast (' S,B' as NCHAR(24))); +go +INSERT INTO testsqlvariant_sourceTable14 values(cast (' dthdcjdfjwf dwfw fgegegeg' as NCHAR(24)), cast ('😊😋😎😍😅😆' as NCHAR(24))) +go +Insert into testsqlvariant_sourceTable14 values (cast (NULL as NCHAR(24)), cast (' ' as NCHAR(24))); +go + + +Create table testsqlvariant_sourceTable15(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable15 values (cast ('Satarupa' as NVARCHAR(24)),cast (' Satarupa' as NVARCHAR(24))); +go +Insert into testsqlvariant_sourceTable15 values (cast ('' as NVARCHAR(24)),cast (' S,B' as NVARCHAR(24))); +go +INSERT INTO testsqlvariant_sourceTable15 values(cast (' dthdcjdfjwf dwfw fgegegeg' as NVARCHAR(24)), cast ('😊😋😎😍😅😆' as NVARCHAR(24))) +go +Insert into testsqlvariant_sourceTable15 values (cast (NULL as NVARCHAR(24)), cast (' ' as NVARCHAR(24))); +go + +Create table testsqlvariant_sourceTable16(a sql_variant, b sql_variant not null); +go +INSERT INTO testsqlvariant_sourceTable16 values(CAST('51f178a6-53c7-472c-9be1-1c08942342d7' as uniqueidentifier), CAST('bab96bc8-60b9-40dd-b0de-c90a80f5739e' as uniqueidentifier)) +go +INSERT INTO testsqlvariant_sourceTable16 values(CAST('dba2726c-2131-409f-aefa-5c8079571623' as uniqueidentifier), CAST('51f178a6-53c7-472c-9be1-1c08942342d7thisIsTooLong' as uniqueidentifier)) +go +INSERT INTO testsqlvariant_sourceTable16 values(NULL, CAST('60aeaa5c-e272-4b17-bad0-c25710fd7a60' as uniqueidentifier)) +go + + +Create table testsqlvariant_sourceTable17(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable17 values (cast ('Delhi' as VARCHAR(24)),cast (' Surat' as VARCHAR(24))); +go +Insert into testsqlvariant_sourceTable17 values (cast ('' as VARCHAR(24)),cast (' S,B' as VARCHAR(24))); +go +Insert into testsqlvariant_sourceTable17 values (cast (NULL as VARCHAR(24)), cast (' ' as VARCHAR(24))); +go + +Create table testsqlvariant_sourceTable18(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable18 values (cast ('Delhi' as char(24)),cast (' Surat' as char(24))); +go +Insert into testsqlvariant_sourceTable18 values (cast ('' as char(24)),cast (' S,B' as char(24))); +go +Insert into testsqlvariant_sourceTable18 values (cast (NULL as char(24)), cast (' ' as char(24))); +go + +Create table testsqlvariant_sourceTable19(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable19 values (cast (123.456 as numeric(5,2)), cast (123.4 as numeric(5,2))); +go +Insert into testsqlvariant_sourceTable19 values (cast (NULL as numeric(5,2)), cast (123 as numeric(5,2))); +go +Insert into testsqlvariant_sourceTable19 values (cast (-123.456 as numeric(5,2)), cast (-123 as numeric(5,2))); +go + +Create table testsqlvariant_sourceTable20(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable20 values (cast (123.456 as decimal(5,2)), cast (123.4 as decimal(5,2))); +go +Insert into testsqlvariant_sourceTable20 values (cast (NULL as decimal(5,2)), cast (123 as decimal(5,2))); +go +Insert into testsqlvariant_sourceTable20 values (cast (-123.456 as decimal(5,2)), cast (-123 as decimal(5,2))); +go + + +Create table testsqlvariant_sourceTable21(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable21 values (cast ('12:45:37.123' as time(0)), cast ('12:45:37.123' as time(1))); +go +Insert into testsqlvariant_sourceTable21 values (cast (NULL as time(3)), cast ('12:45:37.123' as time(2))); +go +Insert into testsqlvariant_sourceTable21 values (cast ('12:45:37.123' as time(3)), cast ('12:45:37.1234' as time(4))); +go +Insert into testsqlvariant_sourceTable21 values (cast ('12:45:37.12345' as time(5)), cast ('12:45:37.123456' as time(6))); +go + + +Create table testsqlvariant_sourceTable22(a sql_variant, b sql_variant not null); +go +Insert into testsqlvariant_sourceTable22 values (cast ('2016-10-23 12:45:37.123' as datetime2(0)), cast ('2016-10-23 12:45:37.123' as datetime2(1))); +go +Insert into testsqlvariant_sourceTable22 values (cast (NULL as datetime2(3)), cast ('2016-10-23 12:45:37.123' as datetime2(2))); +go +Insert into testsqlvariant_sourceTable22 values (cast ('2016-10-23 12:45:37.123' as datetime2(3)), cast ('2016-10-23 12:45:37.1234' as datetime2(4))); +go +Insert into testsqlvariant_sourceTable22 values (cast ('2016-10-23 12:45:37.12345' as datetime2(5)), cast ('2016-10-23 12:45:37.123456' as datetime2(6))); +go + +-- Test sql_variant cast (Test for BABEL-3404) +CREATE VIEW testsqlvariant_vu_prepare_view1 AS SELECT CAST('abc' AS sql_variant) AS col; +go + +-- Test sql_variant comparison function +CREATE VIEW testsqlvariant_vu_prepare_view2 AS SELECT CASE WHEN a > b THEN a ELSE b END AS val FROM testsqlvariant_sourceTable22; +go diff --git a/test/JDBC/input/jtds/jtds-TestSQLVariant-vu-verify.sql b/test/JDBC/input/jtds/jtds-TestSQLVariant-vu-verify.sql new file mode 100644 index 0000000000..1b0b392dd4 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestSQLVariant-vu-verify.sql @@ -0,0 +1,93 @@ + +--[BABEL-582]Checking all base datatypes for sql_variant +--The following list of base datatypes cannot be stored by using sql_variant: +--[datetimeoffset(SQL server 2012), geography, geometry, hierarchyid, image, ntext, nvarchar(max), +--rowversion (timestamp), text, varchar(max), varbinary(max), User-defined types, xml] + +Select * from testsqlvariant_sourceTable1; +go + +Select * from testsqlvariant_sourceTable2; +go + + +Select * from testsqlvariant_sourceTable3; +go + + +Select * from testsqlvariant_sourceTable4; +go + + +Select * from testsqlvariant_sourceTable5; +go + +Select * from testsqlvariant_sourceTable6; +go + + +Select * from testsqlvariant_sourceTable7; +go + + +SELECT * FROM testsqlvariant_money_dt; +go + +Select * from testsqlvariant_sourceTable8; +go + + +Select * from testsqlvariant_sourceTable9; +go + + +Select * from testsqlvariant_sourceTable10; +go + + +Select * from testsqlvariant_sourceTable11; +go + + +Select * from testsqlvariant_sourceTable12; +go + + +Select * from testsqlvariant_sourceTable13; +go + + +Select * from testsqlvariant_sourceTable14; +go + + +Select * from testsqlvariant_sourceTable15; +go + + +Select * from testsqlvariant_sourceTable16; +go + +Select * from testsqlvariant_sourceTable17; +go + +Select * from testsqlvariant_sourceTable18; +go + +Select * from testsqlvariant_sourceTable19; +go + +Select * from testsqlvariant_sourceTable20; +go + +Select * from testsqlvariant_sourceTable21; +go + +Select * from testsqlvariant_sourceTable22; +go + +Select * from testsqlvariant_vu_prepare_view1; +go + +Select * from testsqlvariant_vu_prepare_view2; +go diff --git a/test/JDBC/input/jtds/jtds-TestSimpleErrors.sql b/test/JDBC/input/jtds/jtds-TestSimpleErrors.sql new file mode 100644 index 0000000000..8d103d4f0e --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestSimpleErrors.sql @@ -0,0 +1,2533 @@ +-- sla_for_parallel_query_enforced 100000 +CREATE TABLE simpleErrorTable (a varchar(15) UNIQUE NOT NULL, b nvarchar(25), c int PRIMARY KEY, d char(15) DEFAULT 'Whoops!', e nchar(25), f datetime, g numeric(4,1) CHECK (g >= 103.5)) +GO + +-- setup for "data out of range for datetime" error +CREATE TABLE t517_1(a datetime); +GO + +-- setup for "A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations" error +CREATE TABLE t141_1(c1 int, c2 int); +GO + +-- setup for "column \"%s\" of relation \"%s\" is a generated column" +CREATE TABLE t1752_1(c1 INT, c2 INT, c3 as c1*c2) +GO + +if @@trancount > 0 commit tran; +GO + +-- Error: duplicate key value violates unique constraint +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +select * from simpleErrorTable ORDER BY c +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + declare @err int = @@error; if @err = 0 select 0 else select 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + declare @err int = @@error; if @err = 0 select 0 else select 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + declare @err int = @@error; if @err = 0 select 0 else select 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran sp1 +rollback tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +commit tran +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: duplicate key value violates unique constraint +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO simpleErrorTable VALUES ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +select * from simpleErrorTable ORDER BY c +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran sp1; +rollback tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + declare @err int = @@error; if @err = 0 select 0 else select 1; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +commit tran +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: data out of range for datetime +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + INSERT INTO t517_1 VALUES (DATEADD(YY,-300,getdate())); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +UPDATE simpleErrorTable SET c = NULL WHERE c = 1; +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +select * from simpleErrorTable ORDER BY c +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + declare @err int = @@error; if @err = 0 select 0 else select 1; +commit tran; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + declare @err int = @@error; if @err = 0 select 0 else select 1; +rollback tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + declare @err int = @@error; if @err = 0 select 0 else select 1; + rollback tran sp1; +rollback tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + declare @err int = @@error; if @err = 0 select 0 else select 1; +commit tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +commit tran +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: not null constraint violation +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + UPDATE simpleErrorTable SET c = NULL WHERE c = 1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + + +-- Error: creating an existing table +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +CREATE TABLE simpleErrorTable (a int); +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +commit tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +rollback tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +rollback tran sp1; +GO +rollback tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + CREATE TABLE simpleErrorTable (a int); +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +commit tran; +GO +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +commit tran; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + CREATE TABLE simpleErrorTable (a int); + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +commit tran +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: creating an existing table +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + CREATE TABLE simpleErrorTable (a int); + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +GO +select * from simpleErrorTable ORDER BY c +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran sp1; +rollback tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +commit tran +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: "column \"%s\" of relation \"%s\" is a generated column" +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + ALTER TABLE t1752_1 ADD CONSTRAINT constraint1752 DEFAULT 'test' FOR c3; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +select * from simpleErrorTable ORDER BY c +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran sp1; +GO +rollback tran; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +DECLARE @a tinyint = 1000; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +DECLARE @a tinyint = 1000; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +commit tran +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a tinyint = 1000; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a tinyint = 1000; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc3 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a tinyint = 1000; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: "A SELECT statement that assigns a value to a variable must not be +-- combined with data-retrieval operations" +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a int; SELECT @a = c1, c2 FROM t141_1; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + DECLARE @a tinyint = 1000; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +select @@trancount; +GO + +if @@trancount > 0 commit tran; +GO + +-- Error: value for domain tinyint violates check constraint "tinyint_check" +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +DECLARE @a tinyint = 1000; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple batch +INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple batch with commit transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; +GO +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +commit tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple batch with rollback transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; +GO +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple batch with rollback transaction and rollback to savepoint +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + save tran sp1; + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; +GO +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +rollback tran sp1; +GO +rollback tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple procedure +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple batch with nested transaction +begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; +GO +commit tran; +INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +GO +commit tran; +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple procedure with transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + begin tran; + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + commit tran; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple procedure with transaction started inside procedure but ended outside procedure +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +commit tran +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple procedure with transaction started outside procedure but ended inside procedure through commit +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- simple procedure with transaction started outside procedure but ended inside procedure through rollback +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +begin tran +GO +exec simpleErrorProc1 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- nested procedure (level 2) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- nested procedure (level 3) +create procedure simpleErrorProc1 +as +begin + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +end +GO +create procedure simpleErrorProc2 +as +begin + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +end +GO +create procedure simpleErrorProc3 +as +begin + SELECT 1; + exec simpleErrorProc2; + SELECT 2; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +drop procedure simpleErrorProc3 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- nested procedure with commit transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + commit tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + commit tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- Error: conversion error and executing stored procedure using sp_executesql +-- nested procedure with rollback transaction +create procedure simpleErrorProc1 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + EXECUTE sp_executesql N'UPDATE simpleErrorTable SET a = convert(int, ''abc'') WHERE c = 1;'; + INSERT INTO simpleErrorTable(a, b, c, e, f, g) VALUES ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); + rollback tran; +end +GO +create procedure simpleErrorProc2 +as +begin + begin tran; + INSERT INTO simpleErrorTable VALUES ('Pineapple', N'pink', 7, 'Surat', N'Frown😠', '2000-12-13 12:58:23.123', 123.1); + exec simpleErrorProc1; + INSERT INTO simpleErrorTable VALUES ('Cherry', N'indigo', 8, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); + rollback tran; +end +GO +exec simpleErrorProc2 +GO +declare @err int = @@error; if @err = 0 select 0 else select 1; +GO +select * from simpleErrorTable ORDER BY c +GO +select @@trancount +GO +drop procedure simpleErrorProc1 +GO +drop procedure simpleErrorProc2 +GO +truncate table simpleErrorTable +GO + +-- cleanup for "data out of range for datetime" error +DROP TABLE t517_1; +GO + +-- clean up for "A SELECT statement that assigns a value to a variable must not +-- be combined with data-retrieval operations" error +DROP TABLE t141_1; +GO + +-- setup for "column \"%s\" of relation \"%s\" is a generated column" +DROP TABLE t1752_1; +GO + +drop table simpleErrorTable +GO + +while (@@trancount > 0) commit tran; +GO + diff --git a/test/JDBC/input/jtds/jtds-TestStoredProcedures.txt b/test/JDBC/input/jtds/jtds-TestStoredProcedures.txt new file mode 100644 index 0000000000..aeecbfcf66 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestStoredProcedures.txt @@ -0,0 +1,182 @@ +# PROCEDURE WITH NO BODY +#create procedure sp_test AS BEGIN END; +# PROCEDURE WITH NO PARAMS +create table temp_sp2(a int); +CREATE PROCEDURE sp_test AS BEGIN insert into temp_sp2 values(1); END; +storedproc#!#prep#!#sp_test#!# +SELECT * FROM temp_sp2; +drop table temp_sp2; +drop Procedure sp_test; +# PROCEDURE WITH INPUT PARAMETER +#drop table temp_sp; +create table temp_sp(a int); +Create Procedure stored_proc1 (@a int) As Begin insert into temp_sp values(@a) End; +# NOT WORKING FOR BABEL,RAISED JIRA 444 +storedproc#!#prep#!#stored_proc1#!#int|-|a|-|-100|-|input +# MISMATCH IN RETURN VALUES +exec stored_proc1 -200 +exec stored_proc1 0 +exec stored_proc1 -1 +exec stored_proc1 2 +# filed Jira on this, doesnt work for babel +#exec stored_proc1 2.2 +SELECT * FROM temp_sp; +DROP table temp_sp; +DROP Procedure stored_proc1 +# input parameter +CREATE PROCEDURE sp_test1 (@a INT) AS BEGIN SET @a=100; Select @a as a; END; +exec sp_test1 2 +Declare @a int;Set @a=1; exec sp_test1 @a;select @a as a; +storedproc#!#prep#!#sp_test1#!#int|-|a|-|1|-|input +storedproc#!#prep#!#sp_test1#!#int|-|a|-|10|-|input +DROP PROCEDURE sp_test1 +# TESTING OUT PARAMETERS FOR ALL THE DATATYPES +# int +CREATE PROCEDURE sp_test1 (@a INT OUTPUT) AS BEGIN SET @a=100; Select @a as a; END; +#Declare @a int;Set @a=1; exec sp_test1 @a;select @a as a; +storedproc#!#prep#!#sp_test1#!#int|-|a|-|1|-|output +storedproc#!#prep#!#sp_test1#!#int|-|a|-|1|-|inputoutput +DROP PROCEDURE sp_test1 +# smallint +CREATE PROCEDURE sp_test2 (@a SMALLINT OUTPUT) AS BEGIN SET @a=100; Select @a as a; END; +#Declare @a smallint;Set @a=1; exec sp_test2 @a;select @a as a; +storedproc#!#prep#!#sp_test2#!#smallint|-|a|-|10|-|output +storedproc#!#prep#!#sp_test2#!#smallint|-|a|-|10|-|inputoutput +DROP PROCEDURE sp_test2 +# bigint +CREATE PROCEDURE sp_test3 (@a BIGINT OUTPUT) AS BEGIN SET @a=100; Select @a as a; END; +storedproc#!#prep#!#sp_test3#!#bigint|-|a|-|10|-|output +storedproc#!#prep#!#sp_test3#!#bigint|-|a|-|10|-|inputoutput +DROP PROCEDURE sp_test3 +# tinyint +#CREATE PROCEDURE sp_test4 (@a tinyint OUTPUT) AS BEGIN SET @a=100; Select @a as a; END; +#storedproc#!#prep#!#sp_test4#!#tinyint|-|a|-|10|-|output +#storedproc#!#prep#!#sp_test4#!#tinyint|-|a|-|10|-|inputoutput +#DROP PROCEDURE sp_test4 +# float +CREATE PROCEDURE sp_test5 (@a float OUTPUT) AS BEGIN SET @a=100.12; Select @a as a; END; +#Declare @a float;Set @a=1.1; exec sp_test5 @a;select @a as a; +storedproc#!#prep#!#sp_test5#!#float|-|a|-|10.1|-|output +storedproc#!#prep#!#sp_test5#!#float|-|a|-|10.1|-|inputoutput +DROP PROCEDURE sp_test5 +# varchar +#CREATE PROCEDURE sp_test6 (@a varchar OUTPUT) AS BEGIN SET @a='helloworld'; Select @a as a; END; +#storedproc#!#prep#!#sp_test6#!#varchar|-|a|-|hello|-|output +#storedproc#!#prep#!#sp_test6#!#varchar|-|a|-|hello|-|inputoutput +#DROP PROCEDURE sp_test6 +# char BABEL-705 +#CREATE PROCEDURE sp_test7 (@a char OUTPUT) AS BEGIN SET @a='b'; Select @a as a; END; +#Declare @a varchar;Set @a='h'; exec sp_test7 @a;select @a as a; +#storedproc#!#prep#!#sp_test7#!#char|-|a|-|t|-|output +#storedproc#!#prep#!#sp_test7#!#char|-|a|-|t|-|inputoutput +#DROP PROCEDURE sp_test7 +# nvarchar +#CREATE PROCEDURE sp_test9 (@a nvarchar OUTPUT) AS BEGIN SET @a='helloworld'; Select @a as a; END; +#Declare @a nvarchar;Set @a='hello'; exec sp_test9 @a;select @a as a; +#storedproc#!#prep#!#sp_test9#!#varchar|-|a|-|hello|-|output +#storedproc#!#prep#!#sp_test9#!#varchar|-|a|-|hello|-|inputoutput +#DROP PROCEDURE sp_test9 +# numeric +CREATE PROCEDURE sp_test10 (@a numeric(10,4) OUTPUT) AS BEGIN SET @a=100.41; Select @a as a; END; +#Declare @a numeric(10,4);Set @a=10.04; exec sp_test10 @a;select @a as a; +#storedproc#!#prep#!#sp_test10#!#numeric|-|a|-|123|-|10|-|3|-|output +#storedproc#!#prep#!#sp_test10#!#numeric|-|a|-|123|-|10|-|2|-|inputoutput +DROP PROCEDURE sp_test10 +# decimal +CREATE PROCEDURE sp_test11 (@a decimal(10,4) OUTPUT) AS BEGIN SET @a=100.41; Select @a as a; END; +#Declare @a decimal(10,4);Set @a=10.04; exec sp_test11 @a;select @a as a; +#storedproc#!#prep#!#sp_test11#!#decimal|-|a|-|123|-|10|-|3|-|output +#storedproc#!#prep#!#sp_test11#!#decimal|-|a|-|123|-|10|-|2|-|inputoutput +DROP PROCEDURE sp_test11 +# binary +#CREATE PROCEDURE sp_test12 (@a binary OUTPUT) AS BEGIN SET @a=0x121; Select @a as a; END; +#exec sp_test12 0x122 +#Declare @a binary;Set @a=0x121; exec sp_test12 @a;select @a as a; +#storedproc#!#prep#!#sp_test12#!#binary|-|a|-|0x122|-|output +#storedproc#!#prep#!#sp_test12#!#binary|-|a|-|0x122|-|inputoutput +#DROP PROCEDURE sp_test12 +# varbinary BABEL-701 +#CREATE PROCEDURE sp_test13 (@a varbinary OUTPUT) AS BEGIN SET @a=0x121; Select @a as a; END; +#exec sp_test13 0x122 +#Declare @a varbinary;Set @a=0x122; exec sp_test13 @a;select @a as a; +#storedproc#!#prep#!#sp_test13#!#varbinary|-|a|-|0x122|-|output +#storedproc#!#prep#!#sp_test13#!#varbinary|-|a|-|0x122|-|inputoutput +#DROP PROCEDURE sp_test13 +# date +CREATE PROCEDURE sp_test14 (@a date output) AS BEGIN SET @a='1999-1-3'; Select @a as a; END; +#Declare @a DATE;Set @a='9999-12-31'; exec sp_test14 @a;select @a as a; +storedproc#!#prep#!#sp_test14#!#DATE|-|a|-|9999-12-31|-|output +storedproc#!#prep#!#sp_test14#!#DATE|-|a|-|9999-12-31|-|inputoutput +DROP PROCEDURE sp_test14 +# time +#CREATE PROCEDURE sp_test15 (@a time(4) OUTPUT) AS BEGIN SET @a='11:25:07.123'; Select @a as a; END; +#Declare @a Time;Set @a='12:45:37.123'; exec sp_test15 @a;select @a as a; +#storedproc#!#prep#!#sp_test15#!#Time|-|a|-|12:45:37.123|-|3|-|output +#storedproc#!#prep#!#sp_test15#!#Time|-|a|-|12:45:37.123|-|3|-|inputoutput +#DROP PROCEDURE sp_test15 +# dateime BABEL-694 +#CREATE PROCEDURE sp_test16 (@a datetime output) AS BEGIN SET @a='2004-05-18 13:59:59.995'; Select @a as a; END; +#Declare @a DATETIME;Set @a='2000-02-28 23:59:59.995'; exec sp_test16 @a;select @a as a; +#storedproc#!#prep#!#sp_test16#!#DATETIME|-|a|-|2000-02-28 23:59:59.995|-|output +#storedproc#!#prep#!#sp_test16#!#DATETIME|-|a|-|2000-02-28 23:59:59.995|-|inputoutput +#DROP PROCEDURE sp_test16 +# datetime2 +#CREATE PROCEDURE sp_test17 (@a datetime2(5) OUTPUT) AS BEGIN SET @a='2014-10-2 1:45:37.123456'; Select @a as a; END; +#Declare @a Datetime2;Set @a='2016-10-23 12:45:37.123456'; exec sp_test17 @a;select @a as a; +#storedproc#!#prep#!#sp_test17#!#Datetime2|-|a|-|2016-10-23 12:45:37.123456|-|5|-|output +#storedproc#!#prep#!#sp_test17#!#Datetime2|-|a|-|2016-10-23 12:45:37.123456|-|5|-|inputoutput +#DROP PROCEDURE sp_test17 +# smalldatetime BABEL-694 +#CREATE PROCEDURE sp_test18 (@a smalldatetime output) AS BEGIN SET @a='2010-02-03 12:58:23'; Select @a as a; END; +#Declare @a SMALLDATETIME;Set @a='2000-12-13 12:58:23'; exec sp_test18 @a;select @a as a; +#storedproc#!#prep#!#sp_test18#!#SMALLDATETIME|-|a|-|2000-12-13 12:58:23|-|output +#storedproc#!#prep#!#sp_test18#!#SMALLDATETIME|-|a|-|2000-12-13 12:58:23|-|inputoutput +#DROP PROCEDURE sp_test18 +# UID +#CREATE PROCEDURE sp_test19 (@a uniqueidentifier OUTPUT) AS BEGIN SET @a='ce8af10a-2709-43b0-9e4e-a02753929d17'; Select @a as a; END; +#Declare @a uniqueidentifier;Set @a='5b7c2e8d-6d90-411d-8e19-9a81067e6f6c'; exec sp_test19 @a;select @a as a; +#storedproc#!#prep#!#sp_test19#!#uniqueidentifier|-|a|-|5b7c2e8d-6d90-411d-8e19-9a81067e6f6c|-|output +#storedproc#!#prep#!#sp_test19#!#uniqueidentifier|-|a|-|5b7c2e8d-6d90-411d-8e19-9a81067e6f6c|-|inputoutput +#DROP PROCEDURE sp_test19 + +CREATE PROCEDURE sp_test20 (@a INT, @b INT OUTPUT) AS BEGIN SET @b=100; SET @a=1000; Select @a as a, @b as b; END; +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @b=@b OUT, @a=@a;select @a as a, @b as b; +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @b=@b, @a=@a OUT;select @a as a, @b as b; +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @b=@b OUT, @a=@a OUT;select @a as a, @b as b; +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @b=@b, @a=@a;select @a as a, @b as b; +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @a=@a, @b=@b;select @a as a, @b as b; +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @a=@a, @b=@b OUT;select @a as a, @b as b; +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @a=@a OUT, @b=@b;select @a as a, @b as b; +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @a=@a OUT, @b=@b OUT;select @a as a, @b as b; +Declare @a int;Declare @b int;Set @a=20;Set @b=10; exec sp_test20 @a OUT, @b OUT;select @a as a, @b as b; +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|output +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|output#!#int|-|b|-|10|-|input +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|input +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|output#!#int|-|b|-|10|-|output +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|inputoutput#!#int|-|b|-|10|-|inputoutput +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|inputoutput +storedproc#!#prep#!#sp_test20#!#int|-|a|-|20|-|inputoutput#!#int|-|b|-|10|-|input +DROP PROCEDURE sp_test20 + +CREATE PROCEDURE sp_test21 (@a INT, @b INT OUTPUT, @d INT, @c INT OUTPUT) AS BEGIN SET @a=100; SET @b=200; SET @c=300; SET @d=400; Select @a as a, @b as b, @c as c, @d as d; END; +Declare @a int;Declare @b int;Declare @c int;Declare @d int;Set @a=20;Set @b=10;Set @c=5;Set @d=30; exec sp_test21 @b=@b OUT, @c=@c OUT, @a=@a, @d=@d; Select @a as a, @b as b, @c as c, @d as d; +Declare @a int;Declare @b int;Declare @c int;Declare @d int;Set @a=20;Set @b=10;Set @c=5;Set @d=30; exec sp_test21 @b=@b, @c=@c, @a=@a, @d=@d; Select @a as a, @b as b, @c as c, @d as d; +Declare @a int;Declare @b int;Declare @c int;Declare @d int;Set @a=20;Set @b=10;Set @c=5;Set @d=30; exec sp_test21 @c=@c OUT, @b=@b OUT, @a=@a, @d=@d; Select @a as a, @b as b, @c as c, @d as d; +Declare @a int;Declare @b int;Declare @c int;Declare @d int;Set @a=20;Set @b=10;Set @c=5;Set @d=30; exec sp_test21 @c=@c, @b=@b, @a=@a OUT, @d=@d OUT; Select @a as a, @b as b, @c as c, @d as d; +storedproc#!#prep#!#sp_test21#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|inputoutput#!#int|-|c|-|10|-|input#!#int|-|d|-|10|-|inputoutput +storedproc#!#prep#!#sp_test21#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|output#!#int|-|c|-|10|-|input#!#int|-|d|-|10|-|output +storedproc#!#prep#!#sp_test21#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|output#!#int|-|c|-|10|-|input#!#int|-|d|-|10|-|inputoutput +storedproc#!#prep#!#sp_test21#!#int|-|a|-|20|-|input#!#int|-|b|-|10|-|inputoutput#!#int|-|c|-|10|-|input#!#int|-|d|-|10|-|output +DROP PROCEDURE sp_test21 + +CREATE PROCEDURE sp_test22 (@MixedCaseArg_1 INT, @MixedCaseArg_2 INT OUTPUT) AS BEGIN SET @MixedCaseArg_2=100; SET @MixedCaseArg_1=1000; Select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; END; +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_2=@MixedCaseArg_2 OUT, @MixedCaseArg_1=@MixedCaseArg_1;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_2=@MixedCaseArg_2, @MixedCaseArg_1=@MixedCaseArg_1 OUT;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_2=@MixedCaseArg_2 OUT, @MixedCaseArg_1=@MixedCaseArg_1 OUT;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_2=@MixedCaseArg_2, @MixedCaseArg_1=@MixedCaseArg_1;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_1=@MixedCaseArg_1, @MixedCaseArg_2=@MixedCaseArg_2;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_1=@MixedCaseArg_1, @MixedCaseArg_2=@MixedCaseArg_2 OUT;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_1=@MixedCaseArg_1 OUT, @MixedCaseArg_2=@MixedCaseArg_2;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_1=@MixedCaseArg_1 OUT, @MixedCaseArg_2=@MixedCaseArg_2 OUT;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +Declare @MixedCaseArg_1 int;Declare @MixedCaseArg_2 int;Set @MixedCaseArg_1=20;Set @MixedCaseArg_2=10; exec sp_test22 @MixedCaseArg_1 OUT, @MixedCaseArg_2 OUT;select @MixedCaseArg_1 as MixedCaseArg_1, @MixedCaseArg_2 as MixedCaseArg_2; +DROP PROCEDURE sp_test22 diff --git a/test/JDBC/input/jtds/jtds-TestTableType-vu-cleanup.sql b/test/JDBC/input/jtds/jtds-TestTableType-vu-cleanup.sql new file mode 100644 index 0000000000..caf249aa1c --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestTableType-vu-cleanup.sql @@ -0,0 +1,12 @@ +drop procedure TestTableType_vu_prepare_proc1 +go + +drop function TestTableType_vu_prepare_func1 +go + + +drop type TestTableType_vu_prepare_t1 +drop type TestTableType_vu_prepare_t2 +drop type TestTableType_vu_prepare_t3 +drop type TestTableType_vu_prepare_t4 +go \ No newline at end of file diff --git a/test/JDBC/input/jtds/jtds-TestTableType-vu-prepare.sql b/test/JDBC/input/jtds/jtds-TestTableType-vu-prepare.sql new file mode 100644 index 0000000000..deefd24841 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestTableType-vu-prepare.sql @@ -0,0 +1,25 @@ +create type TestTableType_vu_prepare_t1 as table (c1 int, c2 int); +go + +create type TestTableType_vu_prepare_t2 as table (c1 int, c2 varchar(30), check (c1 < 5)); +go + +create type TestTableType_vu_prepare_t3 as table (a varchar(15) UNIQUE NOT NULL, b nvarchar(25), c int PRIMARY KEY, d char(15) DEFAULT 'Whoops!', e nchar(25), f datetime, g numeric(4,1) CHECK (g >= 103.5)) +go + +create type TestTableType_vu_prepare_t4 as table(a text not null, b int primary key, c int); +go + +create function TestTableType_vu_prepare_func1 (@number int, @tv TestTableType_vu_prepare_t4 READONLY) returns table as return ( +select *, @number from @tv +); +go + +create procedure TestTableType_vu_prepare_proc1 as +begin + declare @tv TestTableType_vu_prepare_t4 + insert into @tv values('hello1', 1, 1001) + insert into @tv values('hello2', 2, 1002) + select * from TestTableType_vu_prepare_func1(1004, @tv) +end; +go diff --git a/test/JDBC/input/jtds/jtds-TestTableType-vu-verify.sql b/test/JDBC/input/jtds/jtds-TestTableType-vu-verify.sql new file mode 100644 index 0000000000..fb3da9a58f --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestTableType-vu-verify.sql @@ -0,0 +1,30 @@ +declare @tv TestTableType_vu_prepare_t1; +insert @tv values (1,1); +insert @tv values (2,2); +select * from @tv; +go + +declare @tv TestTableType_vu_prepare_t2; +insert @tv values(1,'one'); +insert @tv values(2,'two'); +insert @tv values(3,'three'); +select * from @tv; +insert @tv values(6,'six'); +go + +declare @tv TestTableType_vu_prepare_t3; +insert @tv values ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +insert @tv (a, b, c, e, f, g) values ('Orange', NULL, 3, N'Happy😀', '1900-02-28 23:59:59.989', 342.5); +select * from @tv; +go + + +declare @tv TestTableType_vu_prepare_t3; +insert @tv values ('Apple', N'red', 1, 'Delhi', N'Sad😞', '2000-12-13 12:58:23.123', 123.1); +insert @tv values ('Apple', N'blue', 2, 'Chennai', N'Neutral😐', '2006-11-11 22:47:23.128', 512.4); +select * from @tv; + +go + +exec TestTableType_vu_prepare_proc1; +go \ No newline at end of file diff --git a/test/JDBC/input/jtds/jtds-TestTime.txt b/test/JDBC/input/jtds/jtds-TestTime.txt new file mode 100644 index 0000000000..fcb6805a48 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestTime.txt @@ -0,0 +1,104 @@ +Create table TestTime(a time(6)) + +prepst#!# Insert into TestTime Values(@a) #!#Time|-|a|-|12:45:37.123|-|0 +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +prepst#!#exec#!#Time|-|a|-| + +select * from TestTime + +Drop table TestTime + +Create table TestTime(a time(5)) + +prepst#!# Insert into TestTime Values(@a) #!#Time|-|a|-|12:45:37.123|-|0 +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +prepst#!#exec#!#Time|-|a|-| + +select * from TestTime + +Drop table TestTime + +Create table TestTime(a time(4)) + +prepst#!# Insert into TestTime Values(@a) #!#Time|-|a|-|12:45:37.123|-|0 +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +prepst#!#exec#!#Time|-|a|-| + +select * from TestTime + +Drop table TestTime + +Create table TestTime(a time(3)) + +prepst#!# Insert into TestTime Values(@a) #!#Time|-|a|-|12:45:37.123|-|0 +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +prepst#!#exec#!#Time|-|a|-| + +select * from TestTime + +Drop table TestTime + +Create table TestTime(a time(2)) + +prepst#!# Insert into TestTime Values(@a) #!#Time|-|a|-|12:45:37.123|-|0 +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +prepst#!#exec#!#Time|-|a|-| + +select * from TestTime + +Drop table TestTime + +Create table TestTime(a time(1)) + +prepst#!# Insert into TestTime Values(@a) #!#Time|-|a|-|12:45:37.123|-|0 +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +prepst#!#exec#!#Time|-|a|-| + +select * from TestTime + +Drop table TestTime + +Create table TestTime(a time(0)) + +prepst#!# Insert into TestTime Values(@a) #!#Time|-|a|-|12:45:37.123|-|0 +prepst#!#exec#!#Time|-|a|-|12:45:37.123|-|3 +prepst#!#exec#!#Time|-|a|-|12:45:37.12|-|2 +prepst#!#exec#!#Time|-|a|-|12:45:37.1|-|1 +prepst#!#exec#!#Time|-|a|-|12:45:37.1234|-|4 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|6 +prepst#!#exec#!#Time|-|a|-|12:45:37.123456|-|5 +prepst#!#exec#!#Time|-|a|-| + +select * from TestTime + +Drop table TestTime \ No newline at end of file diff --git a/test/JDBC/input/jtds/jtds-TestTransactionSupportForProcedure.txt b/test/JDBC/input/jtds/jtds-TestTransactionSupportForProcedure.txt new file mode 100644 index 0000000000..a9a997b1c7 --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestTransactionSupportForProcedure.txt @@ -0,0 +1,260 @@ +#setup +create table txnproctable (c1 int not null, c2 varchar(100)) + +# PROC +# BEGIN TRAN +# SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +create procedure txnproc1 as begin tran; insert into txnproctable values (1, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; commit tran; +select @@trancount; +select * from txnproctable order by c1; +exec txnproc1; +select @@trancount; +select * from txnproctable order by c1; + + +# PROC +# BEGIN TRAN +# SAVEPOINT +# ROLLBACK SAVEPOINT +# ROLLBACK +drop procedure txnproc1; +create procedure txnproc1 as begin tran; insert into txnproctable values(2, 'xyz'); save tran sp1; delete from txnproctable; rollback tran sp1; rollback tran; +select @@trancount; +select * from txnproctable order by c1; +exec txnproc1; +select @@trancount; +select * from txnproctable order by c1; + + +# PROC +# BEGIN TRAN +# SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +drop procedure txnproc1 +create procedure txnproc1 as begin tran; insert into txnproctable values(3, 'dbd'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; +select @@trancount +select * from txnproctable order by c1; +exec txnproc1; +select @@trancount +select * from txnproctable order by c1; +commit tran; +select @@trancount +select * from txnproctable order by c1; + + +# PROC +# BEGIN TRAN +# SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +drop procedure txnproc1 +create procedure txnproc1 as begin tran; insert into txnproctable values(4, 'sbd'); save tran sp1; update txnproctable set c1 = c1 + 1; +select @@trancount +select * from txnproctable order by c1; +exec txnproc1; +select @@trancount +select * from txnproctable order by c1; +rollback tran sp1; +select @@trancount +select * from txnproctable order by c1; +commit tran; +select @@trancount +select * from txnproctable order by c1; + + +# BEGIN TRAN +# PROC +# SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +begin tran; +select @@trancount +select * from txnproctable order by c1; +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(5, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; +select @@trancount +select * from txnproctable order by c1; +exec txnproc1; +select @@trancount +select * from txnproctable order by c1; +commit tran; +select @@trancount +select * from txnproctable order by c1; + + +# BEGIN TRAN +# PROC +# SAVEPOINT +# ROLLBACK SAVEPOINT +# ROLLBACK +begin tran; +select @@trancount +select * from txnproctable order by c1; +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(6, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; +select @@trancount +select * from txnproctable order by c1; +exec txnproc1; +select @@trancount +select * from txnproctable order by c1; +commit tran; +select @@trancount +select * from txnproctable order by c1; + +# BEGIN TRAN +# PROC +# SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +begin tran; +select @@trancount +select * from txnproctable order by c1; +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(7, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; update txnproctable set c1 = c1 + 1; commit tran; +select @@trancount +select * from txnproctable order by c1; +exec txnproc1; +select @@trancount +select * from txnproctable order by c1; + +# BEGIN TRAN +# PROC +# SAVEPOINT +# ROLLBACK SAVEPOINT +# ROLLBACK +begin tran; +select @@trancount +select * from txnproctable order by c1; +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(8, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; update txnproctable set c1 = c1 + 1; rollback tran; +select @@trancount +select * from txnproctable order by c1; +exec txnproc1; +select @@trancount +select * from txnproctable order by c1; + +# BEGIN TRAN +# START SAVEPOINT +# PROC +# ROLLBACK SAVEPOINT +# ROLLBACK +begin tran; +select @@trancount +select * from txnproctable order by c1; +save tran sp1; +select @@trancount +select * from txnproctable order by c1; +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(9, 'abc'); update txnproctable set c1 = c1 + 1; +select @@trancount +select * from txnproctable order by c1; +exec txnproc1; +rollback tran sp1; +select @@trancount +select * from txnproctable order by c1; +rollback tran; +select @@trancount +select * from txnproctable order by c1; + +# BEGIN TRAN +# START SAVEPOINT +# PROC +# ROLLBACK SAVEPOINT +# ROLLBACK +begin tran; +select @@trancount +select * from txnproctable order by c1; +save tran sp1; +select @@trancount +select * from txnproctable order by c1; +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(10, 'abc'); update txnproctable set c1 = c1 + 1; +select @@trancount +select * from txnproctable order by c1; +exec txnproc1; +rollback tran sp1; +select @@trancount +select * from txnproctable order by c1; +commit tran; +select @@trancount +select * from txnproctable order by c1; + +# BEGIN TRAN +# START SAVEPOINT +# PROC +# ROLLBACK SAVEPOINT +# ROLLBACK +begin tran; +select @@trancount +select * from txnproctable order by c1; +save tran sp1; +select @@trancount +select * from txnproctable order by c1; +drop procedure txnproc1 +create procedure txnproc1 as insert into txnproctable values(11, 'abc'); rollback tran sp1; update txnproctable set c1 = c1 + 1; +select @@trancount +select * from txnproctable order by c1; +exec txnproc1; +commit tran; +select @@trancount +select * from txnproctable order by c1; + +# PROC1 +# BEGIN TRAN +# PROC2 +# PROC3 +# BEGIN TRAN +# START SAVEPOINT +# ROLLBACK SAVEPOINT +# COMMIT +# COMMIT +create procedure txnProc3 as begin tran; insert into txnproctable values (16, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; +select @@trancount +select * from txnproctable order by c1; +create procedure txnProc2 as update txnproctable set c1 = c1 + 1; exec txnProc3; commit tran; +select @@trancount +select * from txnproctable order by c1; +drop procedure txnproc1 +create procedure txnproc1 as delete from txnproctable; begin tran; exec txnProc2; +select @@trancount +select * from txnproctable order by c1; +exec txnproc1; +select @@trancount +select * from txnproctable order by c1; +commit tran; +select @@trancount +select * from txnproctable order by c1; + +# PROC1 +# BEGIN TRAN +# PROC2 +# PROC3 +# BEGIN TRAN +# START SAVEPOINT +# ROLLBACK SAVEPOINT +# ROLLBACK TRAN +# COMMIT +drop procedure txnproc3 +create procedure txnProc3 as begin tran; insert into txnproctable values (20, 'abc'); save tran sp1; update txnproctable set c1 = c1 + 1; rollback tran sp1; +select @@trancount +select * from txnproctable order by c1; +drop procedure txnproc2 +create procedure txnProc2 as update txnproctable set c1 = c1 + 1; exec txnProc3; rollback tran; +select @@trancount +select * from txnproctable order by c1; +drop procedure txnproc1 +create procedure txnproc1 as delete from txnproctable; begin tran; exec txnProc2; +select @@trancount +select * from txnproctable order by c1; +exec txnproc1; +select @@trancount +select * from txnproctable order by c1; + +#cleanup +drop procedure txnproc3 +drop procedure txnproc2 +drop procedure txnproc1 +drop table txnproctable \ No newline at end of file diff --git a/test/JDBC/input/jtds/jtds-TestVarChar.txt b/test/JDBC/input/jtds/jtds-TestVarChar.txt new file mode 100644 index 0000000000..c5337b3aba --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestVarChar.txt @@ -0,0 +1,48 @@ +CREATE TABLE VARCHAR_dt (a VARCHAR(20), b NVARCHAR(24)) +prepst#!# INSERT INTO VARCHAR_dt(a, b) values(@a, @b) #!#VARCHAR|-|a|-|Dipesh#!#NVARCHAR|-|b|-|Dhameliya +prepst#!#exec#!#VARCHAR|-|a|-| Dipesh #!#NVARCHAR|-|b|-| Dhameliya +prepst#!#exec#!#VARCHAR|-|a|-| D#!#NVARCHAR|-|b|-| 🤣😃 +prepst#!#exec#!#VARCHAR|-|a|-| #!#NVARCHAR|-|b|-| +prepst#!#exec#!#VARCHAR|-|a|-|#!#NVARCHAR|-|b|-| +prepst#!#exec#!#VARCHAR|-|a|-|d#!#NVARCHAR|-|b|-|D +prepst#!#exec#!#VARCHAR|-|a|-|abcdefghijklmnopqrst#!#NVARCHAR|-|b|-|abcdefghijklmnopqrstuvwx +prepst#!#exec#!#VARCHAR|-|a|-|abcdefghijklmnopqrstu#!#NVARCHAR|-|b|-|abcdefghijklmnopqrstuvwxy +prepst#!#exec#!#VARCHAR|-|a|-| #!#NVARCHAR|-|b|-|😊😋😎😍😅😆 +prepst#!#exec#!#VARCHAR|-|a|-|#!#NVARCHAR|-|b|-| +SELECT * FROM VARCHAR_dt; +INSERT INTO VARCHAR_dt(a,b) values('Dipesh','Dhameliya') +INSERT INTO VARCHAR_dt(a,b) values(' Dipesh',' Dhameliya') +INSERT INTO VARCHAR_dt(a,b) values(' D',N' 🤣😃') +INSERT INTO VARCHAR_dt(a,b) values(' ',' ') +INSERT INTO VARCHAR_dt(a,b) values(' ',N'😊😋😎😍😅😆') +INSERT INTO VARCHAR_dt(a,b) values('','') +INSERT INTO VARCHAR_dt(a,b) values('d','D') +INSERT INTO VARCHAR_dt(a,b) values('abcdefghijklmnopqrst','abcdefghijklmnopqrstuvwx') +#INSERT INTO VARCHAR_dt(a,b) values('abcdefghijklmnopqrstu','abcdefghijklmnopqrstuvwxy') -- for this case, BABEL and SQL both will throw an error +INSERT INTO VARCHAR_dt(a,b) values(NULL,NULL) +SELECT * FROM VARCHAR_dt; +DROP TABLE VARCHAR_dt; + +CREATE TABLE VARCHAR_dt (a varchar(max), b nvarchar(max)); +INSERT INTO VARCHAR_dt values ('hello', N'hello😃'); + +#checking with string of length > 65535 +INSERT INTO VARCHAR_dt values ('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', N'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😃'); +INSERT INTO VARCHAR_dt values (NULL, NULL); +prepst#!#INSERT INTO VARCHAR_dt values(@a, @b)#!#varchar|-|a|-|hello#!#nvarchar|-|b|-|hello😃 + +#checking with string of length > 65535 via prep-exec +prepst#!#exec#!#varchar|-|a|-|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#!#nvarchar|-|b|-|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😃 +prepst#!#exec#!#varchar|-|a|-|#!#nvarchar|-|b|-| +select * from VARCHAR_dt +drop table VARCHAR_dt; + +create table VARCHAR_dt (a varchar(max), b int, c int, d int, e int ,f int, g int, h int, i int); +insert into VARCHAR_dt (a,b,c,d,e,f,g,h,i) values (NULL,1,2,3,4,5,6,7,8); +select * from VARCHAR_dt; +drop table VARCHAR_dt; + +create table VARCHAR_dt (a varchar(10), b int, c int, d int, e int ,f int, g int, h int, i int); +insert into VARCHAR_dt (a,b,c,d,e,f,g,h,i) values (NULL,1,2,3,4,5,6,7,8); +select * from VARCHAR_dt; +drop table VARCHAR_dt; diff --git a/test/JDBC/input/jtds/jtds-TestXML.txt b/test/JDBC/input/jtds/jtds-TestXML.txt new file mode 100644 index 0000000000..89898fee9a --- /dev/null +++ b/test/JDBC/input/jtds/jtds-TestXML.txt @@ -0,0 +1,22 @@ +CREATE TABLE XML_dt (a XML) +#prepst#!# INSERT INTO XML_dt values(@a) #!#XML|-|a|-| +#prepst#!# INSERT INTO XML_dt values(@a) #!#XML|-|a|-|Contact Name 2YYY-YYY-YYYY +#prepst#!#exec#!#XML|-|a|-| +SELECT * FROM XML_dt; +INSERT INTO XML_dt values('Contact Name 2YYY-YYY-YYYY') +INSERT INTO XML_dt values(NULL) +#INSERT INTO XML_dt values('') +INSERT INTO XML_dt values(Contact Name 2YYY-YYY-YYYY) +SELECT * FROM XML_dt; +DROP TABLE XML_dt; + +CREATE TABLE [dbo].[notification_definition]([id] [bigint] NOT NULL,[name_tx] [nvarchar](200) NOT NULL,[description_tx] [nvarchar](max) NULL,[schedule_xml] [xml] NULL,[default_sender_tx] [nvarchar](200) NULL,[lock_id] [tinyint] NOT NULL,[settings_xml] [xml] NULL,[agency_id] [bigint] NULL) +INSERT [dbo].[NOTIFICATION_DEFINITION] VALUES (13, N'INTRA_MSG', N'Intra-System Message', NULL, N'donotreply_OPMQA@ospreycompliancesuite.com', 63,N'NTF_SUB_INTRA_MSGNTF_MSG_INTRA_MSGPolicyDocumentTemplateVars11', 1) +SELECT ID,NAME_TX,LOCK_ID,DESCRIPTION_TX,N'' as emptystring, SCHEDULE_XML,DEFAULT_SENDER_TX,SETTINGS_XML,AGENCY_ID FROM NOTIFICATION_DEFINITION +DROP TABLE [dbo].[notification_definition]; + +CREATE TABLE [dbo].[notification_definition]([id] [bigint] NOT NULL,[name_tx] [nvarchar](200) NOT NULL,[description_tx] [nvarchar](max) NULL,[schedule_xml] [xml] NULL,[default_sender_tx] [nvarchar](200) NULL,[lock_id] [tinyint] NOT NULL,[settings_xml] [xml] NULL,[agency_id] [bigint] NULL) +prepst#!# INSERT [dbo].[NOTIFICATION_DEFINITION] VALUES(@a, @b, @c, @d, @e, @f, @g, @h) #!#bigint|-|a|-|13#!#nvarchar|-|b|-|INTRA_MSG#!#nvarchar|-|c|-|Intra-System Message#!#XML|-|d|-|NULL#!#nvarchar|-|e|-|donotreply_OPMQA#!#tinyint|-|f|-|63#!#XML|-|g|-|NTF_SUB_INTRA_MSGNTF_MSG_INTRA_MSGPolicyDocumentTemplateVars11#!#bigint|-|h|-|1 +#INSERT [dbo].[NOTIFICATION_DEFINITION] VALUES (13, N'INTRA_MSG', N'Intra-System Message', NULL, N'donotreply_OPMQA@ospreycompliancesuite.com', 63,N'NTF_SUB_INTRA_MSGNTF_MSG_INTRA_MSGPolicyDocumentTemplateVars11', 1) +SELECT ID,NAME_TX,LOCK_ID,DESCRIPTION_TX,N'' as emptystring, SCHEDULE_XML,DEFAULT_SENDER_TX,SETTINGS_XML,AGENCY_ID FROM NOTIFICATION_DEFINITION +DROP TABLE [dbo].[notification_definition]; diff --git a/test/JDBC/jdbc_schedule b/test/JDBC/jdbc_schedule index a7a3538c57..bc49c38bec 100644 --- a/test/JDBC/jdbc_schedule +++ b/test/JDBC/jdbc_schedule @@ -305,6 +305,30 @@ ignore#!#babel_4328_datetime2-before-16_3-vu-cleanup ignore#!#babel_4328_datetimeoffset-before-16_3-vu-prepare ignore#!#babel_4328_datetimeoffset-before-16_3-vu-verify ignore#!#babel_4328_datetimeoffset-before-16_3-vu-cleanup - ignore#!#BABEL-3513_before_15_8_or_16_4-vu-prepare ignore#!#BABEL-3513_before_15_8_or_16_4-vu-verify + +# These tests are for jTDS driver +ignore#!#jtds-TestBinary +ignore#!#jtds-TestCursorFetchNext +ignore#!#jtds-TestCursorPrepExecFetchNext +ignore#!#jtds-TestDate +ignore#!#jtds-TestDatetime +ignore#!#jtds-TestDatetime2 +ignore#!#jtds-TestDatetimeoffset-vu-prepare +ignore#!#jtds-TestDatetimeoffset-vu-verify +ignore#!#jtds-TestDatetimeoffset-vu-cleanup +ignore#!#jtds-TestErrorsWithTryCatch +ignore#!#jtds-TestSimpleErrors +ignore#!#jtds-TestSQLQueries +ignore#!#jtds-TestSQLVariant-vu-prepare +ignore#!#jtds-TestSQLVariant-vu-verify +ignore#!#jtds-TestSQLVariant-vu-cleanup +ignore#!#jtds-TestStoredProcedures +ignore#!#jtds-TestTableType-vu-cleanup +ignore#!#jtds-TestTableType-vu-prepare +ignore#!#jtds-TestTableType-vu-verify +ignore#!#jtds-TestTime +ignore#!#jtds-TestTransactionSupportForProcedure +ignore#!#jtds-TestVarChar +ignore#!#jtds-TestXML diff --git a/test/JDBC/jtds_jdbc_schedule b/test/JDBC/jtds_jdbc_schedule new file mode 100644 index 0000000000..25d1f59ac3 --- /dev/null +++ b/test/JDBC/jtds_jdbc_schedule @@ -0,0 +1,94 @@ +# Schedule file for JDBC Test Framework running with jTDS driver instead of +# mssql-jdbc driver. When 'useJTDSInsteadOfMSSQLJDBC' config option is set to +# 'true' this file is used instead of 'jdbc_schedule' file. + +# About the test that were copied with "jtds-prefix": +# +# jTDS has different behaviour from mssql-jdbc when error happens in a batch with multiple statements. +# If a batch contains multiple DML statements and one of them is causing an error (like constraint violation), +# then with mssql-jdbc stmt.execute() returns successfully, number of updated rows can be read from +# stmt.getUpdateCount() and the Exception is thrown on stmt.getMoreResults() only after all successful +# update counts are read. +# +# With jTDS, if none of the statements return a result set (no selects in batch, only DML), then the Exception +# is thrown on stmt.execute(). If this exception is caught and handled, then update counts from successul +# DML statements can be read with stmt.getUpdateCount(). +# And if the successful batch statements return one or more result sets, then stmt.execute() succeeds, +# and update counts and result sets can be read successfully up to the errored one. And the Exception +# is thrown on rs.next() after the last successfull result set is exhausted. +# +# This jTDS behaviour is the same with both Babelfish and MSSQL. + +# datatypes +TestInt +TestSmallInt +TestTinyInt +TestBigInt +TestBIT +TestDecimal +TestNumeric +TestMoney +TestFloat +TestReal +# jTDS reports out of range error on stmt.execute() instead of rs.next() +# thus columns headers are not printed on error. +jtds-TestDatetime +# jTDS date handling differs with mssql-jdbc, behavior on MSSQL and Babelfish is the same +jtds-TestDate +# In TDS v7.1 datetime2 is inserted as datetime (so 3 is a max scale for fractional seconds) +# and returned as nvarchar. +jtds-TestDatetime2 +TestSmallDatetime +# Nvarchar column type is returned for time columns on both MSSQL and Babelfish. +jtds-TestTime +# Nvarchar column type is returned for datetimeoffset/time/datetime2 columns on both MSSQL and Babelfish. +jtds-TestDatetimeoffset-vu-prepare +jtds-TestDatetimeoffset-vu-verify +jtds-TestDatetimeoffset-vu-cleanup +# Varchar(max) column type is reported as text and nvarchar(max) - as ntext, +# this behaviour is consistent on both MSSQL and Babelfish. +jtds-TestVarChar +TestText +TestChar +# Image column type is returned for varbinary(max) on both MSSQL and Babelfish +jtds-TestBinary +TestImage-vu-prepare +TestImage-vu-verify +TestImage-vu-cleanup +# There are two discrepancies with output: bit base type is returned by jTDS as "1", and datetime2 +# type is printed with fractional seconds having all trailing zeros according to scale (BTW scale is +# currently always set incorrectly to max value 7 - see #2638). With mssql-jdbs traling zeros are +# not printed because resulting value is returned as java.sql.Timestamp, but with jTDS datetime2 +# value converted to nvarchar on server because of this trailing zero are preserved up to scale. +# jTDS behaviour with both bit and datetime2 types are consistent between Babelfish and MSSQL. +jtds-TestSQLVariant-vu-prepare +jtds-TestSQLVariant-vu-verify +jtds-TestSQLVariant-vu-cleanup +# jTDS reports XML column as ntext in ResultSetMetaData, this behaviour is the same +# with both MSSQL and Babelfish +jtds-TestXML +jtds-TestTableType-vu-prepare +jtds-TestTableType-vu-verify +jtds-TestTableType-vu-cleanup +TestUniqueIdentifier + +# sqlBatch +# jTDS reports column type as nvarchar instead of date, behavior on MSSQL and Babelfish is the same +jtds-TestSQLQueries + +# errorHandling +jtds-TestSimpleErrors +jtds-TestErrorsWithTryCatch + +# storedProcedures +# jTDS reports column type as nvarchar instead of date, behavior on MSSQL and Babelfish is the same +jtds-TestStoredProcedures + +# cursors +# cursor.last() is not supported in jTDS - it relies on cursor 'nrows' that is not available in Postgres +jtds-TestCursorFetchNext +jtds-TestCursorPrepExecFetchNext + +# transactions +TestTransactionsSQLBatch +jtds-TestTransactionSupportForProcedure diff --git a/test/JDBC/pom.xml b/test/JDBC/pom.xml index 57599c87ee..059122b7e7 100644 --- a/test/JDBC/pom.xml +++ b/test/JDBC/pom.xml @@ -55,6 +55,11 @@ postgresql 42.4.4 + + net.sourceforge.jtds + jtds + 1.3.1 + diff --git a/test/JDBC/src/main/java/com/sqlsamples/CompareResults.java b/test/JDBC/src/main/java/com/sqlsamples/CompareResults.java index 639c98f05f..84648eb014 100644 --- a/test/JDBC/src/main/java/com/sqlsamples/CompareResults.java +++ b/test/JDBC/src/main/java/com/sqlsamples/CompareResults.java @@ -1,7 +1,5 @@ package com.sqlsamples; -import org.junit.jupiter.api.Assertions; -import org.opentest4j.AssertionFailedError; import microsoft.sql.DateTimeOffset; import org.apache.logging.log4j.Logger; @@ -138,10 +136,14 @@ public static void writeWarningToFile(BufferedWriter bw, SQLWarning sqlwarn, Log static void processResults(Statement stmt, BufferedWriter bw, int resultsProcessed, boolean resultSetExist, boolean warningExist, Logger logger) { int updateCount = -9; // initialize to impossible value - while (true) { + outer: while (true) { boolean exceptionOccurred = true; do { try { + if (stmt.getConnection().isClosed()) { + // prevent infinite loop if connection was closed + break outer; + } if (resultsProcessed > 0) { resultSetExist = stmt.getMoreResults(); } @@ -169,6 +171,12 @@ static void processResults(Statement stmt, BufferedWriter bw, int resultsProcess writeResultSetToFile(bw, rs, logger); } catch (SQLException e) { handleSQLExceptionWithFile(e, bw, logger); + } catch (StringIndexOutOfBoundsException e) { + // can be thrown by JtdsResultSet.next() + logger.error("StringIndexOutOfBoundsException: " + e.getMessage(), e); + handleSQLExceptionWithFile(new SQLException(e), bw, logger); + // need to go out of the loop, as result set cannot be read + break; } } else { if (updateCount > 0) { @@ -249,6 +257,15 @@ static int SQLtoJDBCDataTypeMapping(String sqlDataType) { } else return 0; } + static int remapSQLTypeForJTDS(int type) { + switch (type) { + case NCHAR: return CHAR; + case NVARCHAR: return VARCHAR; + case LONGNVARCHAR: return LONGVARCHAR; + default: return type; + } + } + // function to parse SQL data type to Java data type static Object parse_data(String result, String datatype, Logger logger) { diff --git a/test/JDBC/src/main/java/com/sqlsamples/Config.java b/test/JDBC/src/main/java/com/sqlsamples/Config.java index faf89334f7..218b452924 100644 --- a/test/JDBC/src/main/java/com/sqlsamples/Config.java +++ b/test/JDBC/src/main/java/com/sqlsamples/Config.java @@ -29,6 +29,8 @@ public class Config { static String serverCollationName = properties.getProperty("serverCollationName"); static String parallelQueryTestIgnoreFileName = "./parallel_query_jdbc_schedule"; static boolean checkParallelQueryExpected = false; + static boolean useJTDSInsteadOfMSSQLJDBC = Boolean.parseBoolean(properties.getProperty("useJTDSInsteadOfMSSQLJDBC")); + static String jTDSScheduleFileName = "./jtds_jdbc_schedule"; static String testFileRoot = properties.getProperty("testFileRoot"); static boolean isUpgradeTestMode = Boolean.parseBoolean(properties.getProperty("isUpgradeTestMode")); static long defaultSLA = Long.parseLong(properties.getProperty("defaultSLA")); @@ -119,14 +121,27 @@ public static void configureSummaryLogger(String logFileName, Logger summaryLogg } static String createSQLServerConnectionString(String URL, String port, String databaseName, String user, String password) { - return "jdbc:sqlserver://" + URL + ":" + port + ";" + "databaseName=" - + databaseName + ";" + "user=" + user + ";" + "password=" + password; + if (useJTDSInsteadOfMSSQLJDBC) { + return "jdbc:jtds:sqlserver://" + URL + ":" + port + "/" + + databaseName + ";" + "user=" + user + ";" + "password=" + password; + } else { + return "jdbc:sqlserver://" + URL + ":" + port + ";" + "databaseName=" + + databaseName + ";" + "user=" + user + ";" + "password=" + password; + } } static String createPostgreSQLConnectionString(String URL, String port, String databaseName, String user, String password) { return "jdbc:postgresql://" + URL + ":" + port + "/" + databaseName + "?" + "user=" + user + "&" + "password=" + password; } + + static String tdsConnectionDriverClassName() { + if (useJTDSInsteadOfMSSQLJDBC) { + return "net.sourceforge.jtds.jdbc.Driver"; + } else { + return "com.microsoft.sqlserver.jdbc.SQLServerDriver"; + } + } private static String constructConnectionString() { diff --git a/test/JDBC/src/main/java/com/sqlsamples/HandleException.java b/test/JDBC/src/main/java/com/sqlsamples/HandleException.java index d975c0b267..87b66e341c 100644 --- a/test/JDBC/src/main/java/com/sqlsamples/HandleException.java +++ b/test/JDBC/src/main/java/com/sqlsamples/HandleException.java @@ -4,6 +4,7 @@ import java.io.BufferedWriter; import java.io.IOException; +import java.sql.DataTruncation; import java.sql.SQLException; import org.postgresql.util.PSQLException; @@ -19,6 +20,12 @@ public class HandleException { static void handleSQLExceptionWithFile(SQLException e, BufferedWriter bw, Logger logger) { try { if (outputErrorCode) { + + // DataTruncation is used by jTDS for error code 220 + if (e instanceof DataTruncation && e.getNextException() != null) { + e = e.getNextException(); + } + bw.write("~~ERROR (Code: " + e.getErrorCode() + ")~~"); bw.newLine(); bw.newLine(); diff --git a/test/JDBC/src/main/java/com/sqlsamples/JDBCAuthentication.java b/test/JDBC/src/main/java/com/sqlsamples/JDBCAuthentication.java index cee103f14b..5faf9b392a 100644 --- a/test/JDBC/src/main/java/com/sqlsamples/JDBCAuthentication.java +++ b/test/JDBC/src/main/java/com/sqlsamples/JDBCAuthentication.java @@ -44,7 +44,11 @@ void javaAuthentication(String strLine, BufferedWriter bw, Logger logger) { port = properties.getProperty("psql_port"); } - connectionPropertiesBabel.put("url", "jdbc:sqlserver://" + properties.getProperty("URL") + ":" + port); + if (useJTDSInsteadOfMSSQLJDBC) { + connectionPropertiesBabel.put("url", "jdbc:jtds:sqlserver://" + properties.getProperty("URL") + ":" + port); + } else { + connectionPropertiesBabel.put("url", "jdbc:sqlserver://" + properties.getProperty("URL") + ":" + port); + } String other_prop = ""; @@ -79,10 +83,18 @@ private String createConnectionString(String[] result, Properties connectionProp } } - return connectionPropertiesBabel.get("url") - + ";" + "databaseName=" + connectionPropertiesBabel.get("database") - + ";" + "user=" + connectionPropertiesBabel.get("user") - + ";" + "password=" + connectionPropertiesBabel.get("password") - + ";" + other_prop; + if (useJTDSInsteadOfMSSQLJDBC) { + return connectionPropertiesBabel.get("url") + + "/" + connectionPropertiesBabel.get("database") + + ";" + "user=" + connectionPropertiesBabel.get("user") + + ";" + "password=" + connectionPropertiesBabel.get("password") + + ";" + other_prop; + } else { + return connectionPropertiesBabel.get("url") + + ";" + "databaseName=" + connectionPropertiesBabel.get("database") + + ";" + "user=" + connectionPropertiesBabel.get("user") + + ";" + "password=" + connectionPropertiesBabel.get("password") + + ";" + other_prop; + } } } diff --git a/test/JDBC/src/main/java/com/sqlsamples/JDBCBulkCopy.java b/test/JDBC/src/main/java/com/sqlsamples/JDBCBulkCopy.java index 5b12c00176..ccc2a3cc5d 100644 --- a/test/JDBC/src/main/java/com/sqlsamples/JDBCBulkCopy.java +++ b/test/JDBC/src/main/java/com/sqlsamples/JDBCBulkCopy.java @@ -1,7 +1,6 @@ package com.sqlsamples; import com.microsoft.sqlserver.jdbc.SQLServerBulkCopy; -import com.microsoft.sqlserver.jdbc.SQLServerException; import org.apache.logging.log4j.Logger; import java.io.BufferedWriter; diff --git a/test/JDBC/src/main/java/com/sqlsamples/JDBCCrossDialect.java b/test/JDBC/src/main/java/com/sqlsamples/JDBCCrossDialect.java index a58db0bba3..4ca6f7a1e7 100644 --- a/test/JDBC/src/main/java/com/sqlsamples/JDBCCrossDialect.java +++ b/test/JDBC/src/main/java/com/sqlsamples/JDBCCrossDialect.java @@ -95,7 +95,7 @@ Connection getTsqlConnection (String strLine, BufferedWriter bw, Logger logger) try { // Use sqlserver JDBC driver - Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver"); + Class.forName(tdsConnectionDriverClassName()); if (newPort == null) newPort = tsql_port; diff --git a/test/JDBC/src/main/java/com/sqlsamples/JDBCCursor.java b/test/JDBC/src/main/java/com/sqlsamples/JDBCCursor.java index c54aa353b2..ad7bfe3489 100644 --- a/test/JDBC/src/main/java/com/sqlsamples/JDBCCursor.java +++ b/test/JDBC/src/main/java/com/sqlsamples/JDBCCursor.java @@ -49,7 +49,16 @@ int[] setCursorOptions(int i, String[] result, Logger logger) { return new int[]{type, concur, holdability}; } - + + void setHoldabilityOnConnection(Connection conn, int holdability) throws SQLException { + if ("JtdsConnection".equals(conn.getClass().getSimpleName()) && + ResultSet.CLOSE_CURSORS_AT_COMMIT == holdability) { + // CLOSE_CURSORS_AT_COMMIT option not supported in jTDS + return; + } + conn.setHoldability(holdability); + } + void openCursor(Connection con_bbl, Logger logger, String[] result, String strLine, BufferedWriter bw) { logger.info("Opening Cursor"); @@ -85,7 +94,7 @@ void openCursorOnPreparedStatement(Connection con_bbl, Logger logger, String[] r String SQL = contentsArray[1]; try { - con_bbl.setHoldability(holdability); + setHoldabilityOnConnection(con_bbl, holdability); if (!result[3].toLowerCase().startsWith("exec")) { if (pstmt_bbl != null) pstmt_bbl.close(); pstmt_bbl = con_bbl.prepareStatement(SQL, type, concur); @@ -99,6 +108,8 @@ void openCursorOnPreparedStatement(Connection con_bbl, Logger logger, String[] r handleSQLExceptionWithFile(e, bw, logger); } catch (IOException ioe) { logger.error("IO Exception: " + ioe.getMessage(), ioe); + } catch (NullPointerException e) { + logger.error("Null Pointer Exception: " + e.getMessage(), e); } } @@ -113,7 +124,7 @@ void openCursorOnStatement(Connection con_bbl, BufferedWriter bw, Logger logger, Statement stmt_sql = null, stmt_bbl = null; try { - con_bbl.setHoldability(holdability); + setHoldabilityOnConnection(con_bbl, holdability); stmt_bbl = con_bbl.createStatement(type, concur); cursor_bbl = stmt_bbl.executeQuery(SQL); bw.write("~~SUCCESS~~"); diff --git a/test/JDBC/src/main/java/com/sqlsamples/JDBCPreparedStatement.java b/test/JDBC/src/main/java/com/sqlsamples/JDBCPreparedStatement.java index 33d7d80662..80207a8227 100644 --- a/test/JDBC/src/main/java/com/sqlsamples/JDBCPreparedStatement.java +++ b/test/JDBC/src/main/java/com/sqlsamples/JDBCPreparedStatement.java @@ -11,11 +11,13 @@ import java.awt.image.BufferedImage; import java.io.*; import java.math.BigDecimal; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; import java.sql.*; import java.text.DecimalFormat; import java.text.NumberFormat; import java.text.ParseException; -import java.time.LocalDateTime; import java.time.LocalTime; import java.time.ZoneOffset; import java.util.ArrayList; @@ -78,7 +80,11 @@ static void set_bind_values(String[] result, PreparedStatement pstmt, BufferedWr try{ /* TODO: Add more data types here as we support them */ if(parameter[2].equalsIgnoreCase("")){ - pstmt.setNull(j - 1, CompareResults.SQLtoJDBCDataTypeMapping(parameter[0])); + int sqlType = CompareResults.SQLtoJDBCDataTypeMapping(parameter[0]); + if ("JtdsPreparedStatement".equals(pstmt.getClass().getSimpleName())) { + sqlType = CompareResults.remapSQLTypeForJTDS(sqlType); + } + pstmt.setNull(j - 1, sqlType); } else if (parameter[0].equalsIgnoreCase("int")) { // if there is decimal point, remove everything after the point if (parameter[2].indexOf('.') != -1) parameter[2] = parameter[2].substring(0, parameter[2].indexOf('.') - 1); @@ -142,8 +148,12 @@ static void set_bind_values(String[] result, PreparedStatement pstmt, BufferedWr pstmt = ssPstmt; } else if (parameter[0].equalsIgnoreCase("text") || parameter[0].equalsIgnoreCase("ntext")) { - Reader r = new FileReader(parameter[2]); - pstmt.setCharacterStream(j - 1, r); + Path path = Paths.get(parameter[2]); + byte[] bytes = Files.readAllBytes(path); + String text = new String(bytes, StandardCharsets.UTF_8); + Reader reader = new StringReader(text); + // jTDS only suports older version of setCharacterStream() that requires int length + pstmt.setCharacterStream(j - 1, reader, text.length()); } else if (parameter[0].equalsIgnoreCase("image")) { File file = new File(parameter[2]); BufferedImage bImage = ImageIO.read(file); @@ -152,9 +162,13 @@ static void set_bind_values(String[] result, PreparedStatement pstmt, BufferedWr byte [] byteArray = bos.toByteArray(); pstmt.setBytes(j - 1, byteArray); } else if (parameter[0].equalsIgnoreCase("xml")) { - SQLXML sqlxml = pstmt.getConnection().createSQLXML(); - sqlxml.setString(parameter[2]); - pstmt.setSQLXML(j - 1, sqlxml); + if ("JtdsPreparedStatement".equals(pstmt.getClass().getSimpleName())) { + pstmt.setString(j - 1, parameter[2]); + } else { + SQLXML sqlxml = pstmt.getConnection().createSQLXML(); + sqlxml.setString(parameter[2]); + pstmt.setSQLXML(j - 1, sqlxml); + } } else if (parameter[0].equalsIgnoreCase("tvp")) { FileInputStream fstream = new FileInputStream(Paths.get(Paths.get("").toAbsolutePath().toString(), parameter[2]).toString()); DataInputStream in = new DataInputStream(fstream); @@ -223,6 +237,10 @@ static void set_bind_values(String[] result, PreparedStatement pstmt, BufferedWr logger.error("Parse Exception: " + e.getMessage(), e); } catch (NumberFormatException e) { logger.error("Number Format Exception: " + e.getMessage(), e); + } catch (AbstractMethodError e) { + logger.error("Abstract Method Error: " + e.getMessage(), e); + } catch (NullPointerException e) { + logger.error("Null Pointer Exception: " + e.getMessage(), e); } } } diff --git a/test/JDBC/src/main/java/com/sqlsamples/JDBCStatement.java b/test/JDBC/src/main/java/com/sqlsamples/JDBCStatement.java index 903d920d3e..267f72ea86 100644 --- a/test/JDBC/src/main/java/com/sqlsamples/JDBCStatement.java +++ b/test/JDBC/src/main/java/com/sqlsamples/JDBCStatement.java @@ -5,7 +5,6 @@ import java.io.BufferedWriter; import java.io.IOException; import java.sql.Connection; -import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.sql.SQLWarning; @@ -37,6 +36,10 @@ void testStatementWithFile(String SQL, BufferedWriter bw, String strLine, Logger bw.write(strLine); bw.newLine(); + if (SQL.isEmpty()) { + return; + } + SQLWarning sqlwarn = null; boolean resultSetExist = false; boolean warningExist = false; @@ -49,9 +52,11 @@ void testStatementWithFile(String SQL, BufferedWriter bw, String strLine, Logger handleSQLExceptionWithFile(e, bw, logger); resultsProcessed++; } - CompareResults.processResults(stmt_bbl, bw, resultsProcessed, resultSetExist, warningExist,logger); + CompareResults.processResults(stmt_bbl, bw, resultsProcessed, resultSetExist, warningExist, logger); } catch (IOException ioe) { logger.error("IO Exception: " + ioe.getMessage(), ioe); + } catch (IllegalStateException e) { + logger.error("Illegal State Exception: " + e.getMessage(), e); } } } diff --git a/test/JDBC/src/main/resources/config.txt b/test/JDBC/src/main/resources/config.txt index 476f76fc51..42688a1182 100644 --- a/test/JDBC/src/main/resources/config.txt +++ b/test/JDBC/src/main/resources/config.txt @@ -42,6 +42,9 @@ isParallelQueryMode = false # WHETHER TEST MODE HAS NON-DEFAULT-SERVER-COLLATION-NAME serverCollationName = default +# WHETHER TO USE JTDS DRIVER FOR TDS CONNECTIONS +useJTDSInsteadOfMSSQLJDBC = false + # Where to find the input, output, expected, etc. testFileRoot = ./ diff --git a/test/JDBC/src/test/java/com/sqlsamples/TestQueryFile.java b/test/JDBC/src/test/java/com/sqlsamples/TestQueryFile.java index 1a2abf7907..9b2e587a5a 100644 --- a/test/JDBC/src/test/java/com/sqlsamples/TestQueryFile.java +++ b/test/JDBC/src/test/java/com/sqlsamples/TestQueryFile.java @@ -126,7 +126,7 @@ public static void execCommand(String cmd) throws ClassNotFoundException { if (command[1].equalsIgnoreCase("sqlserver")) { /* if are trying to execute a t-sql command but we are using postgres driver */ if(JDBCDriver.equalsIgnoreCase("postgresql")) { - Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver"); //use sql server driver + Class.forName(tdsConnectionDriverClassName()); //use sql server driver } connectionString = createSQLServerConnectionString(URL, tsql_port, databaseName, user, password); summaryLogger.info("Execute T-SQL Command: " + command[2]); @@ -156,14 +156,15 @@ static void selectDriver() throws ClassNotFoundException { if (JDBCDriver.equalsIgnoreCase("postgresql")) { Class.forName("org.postgresql.Driver"); } else if (JDBCDriver.equalsIgnoreCase("sqlserver")) { - Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver"); + Class.forName(tdsConnectionDriverClassName()); } else throw new ClassNotFoundException("Driver not found for: " + JDBCDriver +". Choose from either 'sqlserver' or 'postgresql'"); } // test data is seeded from here static Stream inputFileNames() { File dir = new File(inputFilesDirectoryPath); - File scheduleFile = new File(scheduleFileName); + String scheduleFileNameToUse = useJTDSInsteadOfMSSQLJDBC ? jTDSScheduleFileName : scheduleFileName; + File scheduleFile = new File(scheduleFileNameToUse); File parallelQueryTestIgnoreFile = new File(parallelQueryTestIgnoreFileName); try (BufferedReader br = new BufferedReader(new FileReader(scheduleFile))) {