diff --git a/.github/actions/prepare_vm/action.yaml b/.github/actions/prepare_vm/action.yaml index da8dacbc21b..0ab6bc5f41f 100644 --- a/.github/actions/prepare_vm/action.yaml +++ b/.github/actions/prepare_vm/action.yaml @@ -21,10 +21,11 @@ runs: if [[ '${{ inputs.mode }}' == 'build' ]]; then sudo apt-get -y install \ ccache clang g++ gcc git libidn11-dev libssl-dev lld ninja-build \ - pkg-config python3 ragel yasm + pkg-config python3 ragel unixodbc-dev yasm ccache --set-config=base_dir="$(realpath ..)" ccache --set-config=cache_dir="$HOME/.ccache" ccache --zero-stats else - sudo apt-get -y install libidn12 libssl3 libstdc++6 + # unixODBC loads libodbccr.so through the development package's symlink. + sudo apt-get -y install libidn12 libodbc2 libodbcinst2 libssl3 libstdc++6 unixodbc-dev fi diff --git a/.github/scripts/run_iam_integration_tests.sh b/.github/scripts/run_iam_integration_tests.sh index 43cf89f56c8..3cbf99d90ac 100755 --- a/.github/scripts/run_iam_integration_tests.sh +++ b/.github/scripts/run_iam_integration_tests.sh @@ -2,7 +2,7 @@ set -euo pipefail -IAM_REGEX='^(DriverAuth|TMetadataFixture|TJwtIamFixture|TOAuthIamFixture|OAuth_WithFacility)\.' +IAM_REGEX='^(DriverAuth|TMetadataFixture|TJwtIamFixture|TOAuthIamFixture|OAuth_WithFacility|OdbcAuthentication)\.' IAM_CONTAINER_NAME="${IAM_CONTAINER_NAME:-ydb-iam}" IAM_CTEST_JOBS="${IAM_CTEST_JOBS:-2}" IAM_READY_ATTEMPTS="${IAM_READY_ATTEMPTS:-60}" @@ -15,10 +15,8 @@ cleanup_iam() { wait_for_iam_ydb() { for _ in $(seq 1 "${IAM_READY_ATTEMPTS}"); do - if docker exec -e "YDB_TOKEN=${IAM_TOKEN}" "${IAM_CONTAINER_NAME}" /ydb \ - --endpoint grpc://localhost:2136 \ - --database /local \ - sql -s 'select 1' >/dev/null 2>&1; then + if docker exec -e "YDB_TOKEN=${IAM_TOKEN}" "${IAM_CONTAINER_NAME}" \ + bash /health_check --readiness >/dev/null 2>&1; then return 0 fi sleep "${IAM_READY_SLEEP_SECONDS}" @@ -29,19 +27,31 @@ wait_for_iam_ydb() { return 1 } +provision_odbc_static_user() { + docker exec -e "YDB_TOKEN=${IAM_TOKEN}" "${IAM_CONTAINER_NAME}" /ydb \ + --endpoint grpc://localhost:2236 \ + --database /local \ + sql -s "CREATE USER odbcauth PASSWORD '12345678'" +} + trap cleanup_iam EXIT cleanup_iam docker run -d --name "${IAM_CONTAINER_NAME}" --hostname localhost \ - -p 2235:2135 -p 2236:2136 -p 28765:8765 \ + -p 2235:2235 -p 2236:2236 -p 28765:28765 \ -v /tmp/ydb_iam_certs:/ydb_certs \ + -e GRPC_TLS_PORT=2235 \ + -e GRPC_PORT=2236 \ + -e MON_PORT=28765 \ -e YDB_USE_IN_MEMORY_PDISKS=true \ -e YDB_TABLE_ENABLE_PREPARED_DDL=true \ -e YDB_ENFORCE_USER_TOKEN_REQUIREMENT=true \ -e YDB_DEFAULT_CLUSTERADMIN=root@builtin \ - ghcr.io/ydb-platform/local-ydb:trunk + "${IAM_YDB_IMAGE:-ghcr.io/ydb-platform/local-ydb:trunk}" wait_for_iam_ydb +provision_odbc_static_user YDB_ENDPOINT=localhost:2236 YDB_DATABASE=/local \ +YDB_ODBC_STATIC_USER=odbcauth YDB_ODBC_STATIC_PASSWORD=12345678 \ ctest -j"${IAM_CTEST_JOBS}" --test-dir build -R "${IAM_REGEX}" --output-on-failure diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index 64b8c66cfb7..a72c50f136c 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -71,7 +71,7 @@ jobs: run: | set -euo pipefail - IAM_REGEX='^(DriverAuth|TMetadataFixture|TJwtIamFixture|TOAuthIamFixture|OAuth_WithFacility)\.' + IAM_REGEX='^(DriverAuth|TMetadataFixture|TJwtIamFixture|TOAuthIamFixture|OAuth_WithFacility|OdbcAuthentication)\.' FLAKY_REGEX='(ManyMessages|DiscoveryHang|DescribeHang)' EXCLUDE_REGEX="${IAM_REGEX}|${FLAKY_REGEX}" diff --git a/.github/workflows/odbc-integration.yaml b/.github/workflows/odbc-integration.yaml new file mode 100644 index 00000000000..41f6ee6c95b --- /dev/null +++ b/.github/workflows/odbc-integration.yaml @@ -0,0 +1,227 @@ +name: ODBC consumer integration +on: + pull_request: + branches: [odbc-driver-feature] + types: [labeled, synchronize, reopened, ready_for_review, closed] +permissions: {contents: read} +concurrency: {group: "odbc-integration-${{ github.event.pull_request.number }}-${{ github.event.action == 'closed' && 'merged' || 'pr' }}", cancel-in-progress: true} +jobs: + build: + timeout-minutes: 60 + name: Build and validate ydb-odbc package + if: >- + (github.event.action == 'closed' && github.event.pull_request.merged == true) || + (github.event.action != 'closed' && + contains(github.event.pull_request.labels.*.name, 'ODBC full matrix')) + runs-on: ubuntu-24.04 + outputs: + matrix: ${{ steps.registry.outputs.matrix }} + config: ${{ steps.registry.outputs.config }} + target_sha: ${{ steps.target.outputs.sha }} + package_sha256: ${{ steps.package.outputs.sha256 }} + env: + CPM_SOURCE_CACHE: ${{ github.workspace }}/.cache/cpm + CCACHE_DIR: ${{ github.workspace }}/.cache/ccache + steps: + - name: Resolve tested commit + id: target + run: echo 'sha=${{ github.event.action == 'closed' && github.event.pull_request.merge_commit_sha || github.event.pull_request.head.sha }}' >> "$GITHUB_OUTPUT" + - uses: actions/checkout@v4 + with: + ref: ${{ steps.target.outputs.sha }} + - name: Validate harness and create matrix + id: registry + run: | + python3 -m pip install --user --break-system-packages 'PyYAML==6.0.2' + harness=odbc/tests/frameworks/harness.py + python3 "$harness" registry + python3 -m unittest odbc.tests.test_integration_harness + echo "matrix=$(python3 "$harness" registry --matrix)" >> "$GITHUB_OUTPUT" + echo "config=$(python3 "$harness" registry --config)" >> "$GITHUB_OUTPUT" + - name: Restore dependency and compiler caches + uses: actions/cache@v4 + with: + path: | + .cache/cpm + .cache/ccache + key: deb-ubuntu-24.04-${{ hashFiles('cmake/CPM.cmake', 'cmake/dependencies.cmake') }}-${{ github.run_id }} + restore-keys: | + deb-ubuntu-24.04-${{ hashFiles('cmake/CPM.cmake', 'cmake/dependencies.cmake') }}- + - name: Build ODBC package component + env: + YDB_DEB_COMPONENTS: ydb-odbc + run: ./scripts/build_cpack_deb_packages.sh build-odbc/packages + - name: Validate and upload package + id: package + shell: bash + run: | + shopt -s nullglob + packages=(build-odbc/packages/ydb-odbc_*.deb) + test "${#packages[@]}" -eq 1 + sha256sum "${packages[0]}" > build-odbc/packages/ydb-odbc.sha256 + dpkg-deb -f "${packages[0]}" > build-odbc/packages/ydb-odbc.control + echo "sha256=$(sha256sum "${packages[0]}" | cut -d ' ' -f1)" >> "$GITHUB_OUTPUT" + - uses: actions/upload-artifact@v4 + with: + name: ydb-odbc-package + path: build-odbc/packages/ydb-odbc* + if-no-files-found: error + retention-days: 3 + - name: Run package contract + continue-on-error: true + env: + DRIVER_COMMIT: ${{ steps.target.outputs.sha }} + YDB_TEST_IMAGE: ${{ fromJSON(steps.registry.outputs.config).ydb.image }} + YDB_ENDPOINT: ${{ fromJSON(steps.registry.outputs.config).ydb.endpoint }} + YDB_DATABASE: ${{ fromJSON(steps.registry.outputs.config).ydb.database }} + run: >- + python3 odbc/tests/frameworks/harness.py launch --consumer package-contract + --runtime-image '${{ fromJSON(steps.registry.outputs.config).package_runtime_image }}' + --package build-odbc/packages/ydb-odbc_*.deb --results results/package-contract + - uses: actions/upload-artifact@v4 + if: always() + with: + name: odbc-results-package-contract + path: results/package-contract + if-no-files-found: warn + retention-days: 14 + consumers: + timeout-minutes: 40 + name: ${{ matrix.display_name }} (${{ matrix.mode }}) + needs: build + runs-on: ubuntu-24.04 + strategy: + fail-fast: false + matrix: ${{ fromJSON(needs.build.outputs.matrix) }} + services: + ydb: + image: ${{ fromJSON(needs.build.outputs.config).ydb.image }} + ports: [2136:2136] + env: {YDB_USE_IN_MEMORY_PDISKS: true, YDB_TABLE_ENABLE_PREPARED_DDL: true, YDB_READINESS_ENABLE_DDL: 'false'} + options: --hostname localhost + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ needs.build.outputs.target_sha }} + - uses: actions/download-artifact@v4 + with: + name: ydb-odbc-package + path: package + - name: Wait for YDB + shell: bash + run: | + for attempt in $(seq 1 60); do + docker exec -e YDB_READINESS_ENABLE_DDL=true '${{ job.services.ydb.id }}' \ + bash /health_check --readiness >/dev/null 2>&1 && exit 0 + sleep 2 + done + docker logs '${{ job.services.ydb.id }}' || true + exit 1 + - name: Run consumer + env: + DRIVER_COMMIT: ${{ needs.build.outputs.target_sha }} + YDB_TEST_IMAGE: ${{ fromJSON(needs.build.outputs.config).ydb.image }} + YDB_ENDPOINT: ${{ fromJSON(needs.build.outputs.config).ydb.endpoint }} + YDB_DATABASE: ${{ fromJSON(needs.build.outputs.config).ydb.database }} + run: >- + python3 odbc/tests/frameworks/harness.py launch --consumer '${{ matrix.consumer }}' + --mode '${{ matrix.mode }}' + --runtime-image '${{ matrix.runtime_image }}' --package package/ydb-odbc_*.deb + --results 'results/${{ matrix.run_id }}' + - uses: actions/upload-artifact@v4 + if: always() + with: + name: odbc-results-${{ matrix.run_id }} + path: results/${{ matrix.run_id }} + if-no-files-found: warn + retention-days: 14 + aggregate: + name: Aggregate ODBC reports + if: always() && needs.build.result == 'success' + needs: [build, consumers] + runs-on: ubuntu-24.04 + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ needs.build.outputs.target_sha }} + - run: python3 -m pip install --user --break-system-packages 'PyYAML==6.0.2' + - uses: actions/download-artifact@v4 + continue-on-error: true + with: + pattern: odbc-results-* + path: collected-results + - name: Aggregate and validate results + env: + DRIVER_COMMIT: ${{ needs.build.outputs.target_sha }} + ODBC_PACKAGE_SHA256: ${{ needs.build.outputs.package_sha256 }} + id: aggregate + continue-on-error: true + run: >- + set -o pipefail; python3 odbc/tests/frameworks/harness.py aggregate --input collected-results + --output aggregated-results | tee -a "$GITHUB_STEP_SUMMARY" + - uses: actions/setup-node@v4 + if: always() + with: {node-version: '22'} + - name: Generate browser report + id: allure + if: always() + continue-on-error: true + run: npx -y allure@3.14.3 generate aggregated-results/allure-results --output aggregated-results/html + - uses: actions/upload-artifact@v4 + if: always() + with: + name: odbc-integration-report + path: aggregated-results + if-no-files-found: warn + retention-days: 14 + - name: Enforce integration result + if: always() + run: test '${{ steps.aggregate.outcome }}' = success && test '${{ steps.allure.outcome }}' = success + publish: + name: Publish ODBC HTML report + if: always() && needs.build.result == 'success' && needs.aggregate.result != 'cancelled' && github.event.pull_request.head.repo.full_name == github.repository + needs: [build, aggregate] + runs-on: ubuntu-24.04 + concurrency: {group: odbc-pages, cancel-in-progress: false} + permissions: {contents: write, pull-requests: write} + steps: + - uses: actions/checkout@v4 + with: {ref: gh-pages, path: pages} + - uses: actions/download-artifact@v4 + with: {name: odbc-integration-report, path: report} + - name: Publish report to GitHub Pages + id: pages + working-directory: pages + env: {DESTINATION: 'reports/odbc/pr-${{ github.event.pull_request.number }}'} + run: | + if test -d "$GITHUB_WORKSPACE/report/html"; then + rm -rf "$DESTINATION" && mkdir -p "$DESTINATION" + cp -a "$GITHUB_WORKSPACE/report/html/." "$DESTINATION/" + git add "$DESTINATION" + if ! git diff --cached --quiet; then + git -c user.name=github-actions[bot] -c user.email=41898282+github-actions[bot]@users.noreply.github.com commit -m "Publish ODBC report for PR #${{ github.event.pull_request.number }}" + git push + fi + echo available=true >> "$GITHUB_OUTPUT" + fi + - name: Add report link to pull request + continue-on-error: true + uses: actions/github-script@v7 + env: + REPORT_URL: https://${{ github.repository_owner }}.github.io/${{ github.event.repository.name }}/reports/odbc/pr-${{ github.event.pull_request.number }}/index.html + REPORT_RESULT: ${{ needs.aggregate.result }} + REPORT_SHA: ${{ needs.build.outputs.target_sha }} + REPORT_AVAILABLE: ${{ steps.pages.outputs.available }} + with: + script: | + const marker = '' + const artifacts = await github.paginate(github.rest.actions.listWorkflowRunArtifacts, {...context.repo, run_id: context.runId, per_page: 100}) + const artifact = artifacts.find(item => item.name === 'odbc-integration-report') + const download = artifact ? `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}/artifacts/${artifact.id}` : `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}` + const browser = process.env.REPORT_AVAILABLE === 'true' ? `✨ [Open the interactive Allure report](${process.env.REPORT_URL})` : '⚠️ The browser report could not be generated.' + const body = `${marker}\n### ODBC integration report\n${browser} Β· πŸ“¦ [Download the report bundle](${download})\n\nCommit: \`${process.env.REPORT_SHA}\`; result: **${process.env.REPORT_RESULT}**; updated by each run.` + const request = {...context.repo, issue_number: context.issue.number, per_page: 100} + const comments = await github.paginate(github.rest.issues.listComments, request) + const previous = comments.find(comment => comment.body?.includes(marker)) + if (previous) await github.rest.issues.updateComment({...context.repo, comment_id: previous.id, body}) + else await github.rest.issues.createComment({...context.repo, issue_number: context.issue.number, body}) diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml index f0afb7e2ddd..a0d1991ff95 100644 --- a/.github/workflows/tests.yaml +++ b/.github/workflows/tests.yaml @@ -8,6 +8,7 @@ on: types: [opened, synchronize, reopened, ready_for_review] branches: - main + - odbc-driver-feature concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number }} cancel-in-progress: true @@ -56,9 +57,15 @@ jobs: with: compiler: ${{ matrix.compiler }} - name: Test + if: github.event_name != 'pull_request' || github.base_ref == 'main' shell: bash run: | ctest -j$(nproc) --preset unit + - name: Test ODBC + if: github.event_name == 'pull_request' && github.base_ref == 'odbc-driver-feature' + shell: bash + run: | + ctest --test-dir build/odbc/tests/unit -j$(nproc) --output-on-failure - name: Package integration build shell: bash run: | @@ -88,7 +95,7 @@ jobs: strategy: fail-fast: false matrix: - ydb-version: [24.1, 24.2, 24.3, 24.4, 25.1, trunk] + ydb-version: ${{ fromJSON(github.event_name == 'pull_request' && github.base_ref == 'odbc-driver-feature' && '["latest"]' || '[24.1, 24.2, 24.3, 24.4, 25.1, "trunk"]') }} compiler: [clang, gcc] services: ydb: @@ -128,9 +135,10 @@ jobs: mkdir -p build tar -C build -xzf "integration-build-${{ matrix.compiler }}.tar.gz" - name: Test + if: github.event_name != 'pull_request' || github.base_ref == 'main' shell: bash run: | - IAM_REGEX='^(DriverAuth|TMetadataFixture|TJwtIamFixture|TOAuthIamFixture|OAuth_WithFacility)\.' + IAM_REGEX='^(DriverAuth|TMetadataFixture|TJwtIamFixture|TOAuthIamFixture|OAuth_WithFacility|OdbcAuthentication)\.' YDB_VERSION=${{ matrix.ydb-version }} ctest -j2 --preset integration \ -E "${IAM_REGEX}" --output-on-failure @@ -140,8 +148,20 @@ jobs: ./.github/scripts/run_iam_integration_tests.sh ;; esac + - name: Test ODBC + if: github.event_name == 'pull_request' && github.base_ref == 'odbc-driver-feature' + shell: bash + env: + IAM_YDB_IMAGE: ydbplatform/local-ydb:latest + run: | + YDB_VERSION=${{ matrix.ydb-version }} \ + ctest --test-dir build/odbc/tests/integration -j2 \ + -E '^OdbcAuthentication\.' --output-on-failure + + ./.github/scripts/run_iam_integration_tests.sh test-install: + if: github.event_name != 'pull_request' || github.base_ref == 'main' name: "Test CMake Install" concurrency: group: test-install-${{ github.ref }}-${{ matrix.compiler }} diff --git a/.gitignore b/.gitignore index 297b3bc31ec..07c67fab064 100644 --- a/.gitignore +++ b/.gitignore @@ -22,6 +22,8 @@ _deps !*/canondata/* # Unignore all files inside .github dir !*/.github/* +# Integration adapter entrypoints +!odbc/tests/frameworks/*/run-tests # C libraries *.so *.a diff --git a/CMakeLists.txt b/CMakeLists.txt index e28d30dca43..560c2ceeb62 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -13,6 +13,11 @@ option(YDB_SDK_EXAMPLES "Build YDB C++ SDK examples" On) option(YDB_SDK_ENABLE_OTEL_METRICS "Build the OpenTelemetry metrics plugin" Off) option(YDB_SDK_ENABLE_OTEL_TRACE "Build the OpenTelemetry tracing plugin" Off) option(YDB_CPP_SDK_SLO_USE_INSTALLED_SDK "Build only SLO workloads against one installed SDK prefix" Off) +option(YDB_SDK_ODBC "Build YDB ODBC driver" Off) +if(YDB_SDK_ODBC) + # ODBC is a shared library; static archives linked into it must be PIC. + set(CMAKE_POSITION_INDEPENDENT_CODE ON CACHE BOOL "" FORCE) +endif() set(YDB_SDK_DEPENDENCY_MODE "CPM" CACHE STRING "Dependency provider: CPM (default, pinned sources) or SYSTEM (Ubuntu DEB builds)") set_property(CACHE YDB_SDK_DEPENDENCY_MODE PROPERTY STRINGS CPM SYSTEM) @@ -118,6 +123,10 @@ unset(_ydb_sdk_tests) #_ydb_sdk_validate_public_headers() +if (YDB_SDK_ODBC) + add_subdirectory(odbc) +endif() + if (YDB_SDK_EXAMPLES) add_subdirectory(examples) endif() diff --git a/CMakePresets.json b/CMakePresets.json index 74a2bdf5517..5bb1a0aa6df 100644 --- a/CMakePresets.json +++ b/CMakePresets.json @@ -55,6 +55,7 @@ "cacheVariables": { "YDB_SDK_TESTS": "TRUE", "YDB_SDK_EXAMPLES": "TRUE", + "YDB_SDK_ODBC": "TRUE", "ARCADIA_ROOT": "..", "ARCADIA_BUILD_ROOT": "." } diff --git a/README.md b/README.md index d89af4311a3..5c76a6b7987 100644 --- a/README.md +++ b/README.md @@ -27,23 +27,29 @@ Ubuntu 24.04: ```bash sudo apt-get -y update sudo apt-get -y install build-essential ca-certificates ccache clang cmake git \ - libidn11-dev libssl-dev lld ninja-build pkg-config python3 ragel yasm + libidn11-dev libssl-dev lld ninja-build odbcinst pkg-config python3 ragel \ + unixodbc-dev yasm ``` +`unixodbc-dev` is only required when configuring with `YDB_SDK_ODBC=ON`. + Fedora 43: ```bash sudo dnf install -y ccache cmake gcc gcc-c++ git libidn-devel \ - ninja-build openssl-devel openssl-devel-engine pkgconf-pkg-config python3 ragel yasm + ninja-build openssl-devel openssl-devel-engine pkgconf-pkg-config python3 ragel \ + unixODBC-devel yasm ``` macOS 14: ```bash xcode-select --install # if the Command Line Tools are not installed yet -brew install ccache cmake git libidn ninja openssl@3 python ragel yasm +brew install ccache cmake git libidn libiodbc ninja openssl@3 python ragel yasm ``` +`libiodbc` is only required when configuring with `YDB_SDK_ODBC=ON`. + ### Clone the ydb-cpp-sdk repository ```bash @@ -82,18 +88,21 @@ The SDK can be packaged as Debian development packages with CPack. The complete - `libydb-cpp-iam-dev` β€” IAM credentials plugin; - `libydb-cpp-otel-metrics-dev` β€” OpenTelemetry metrics plugin; - `libydb-cpp-otel-tracing-dev` β€” OpenTelemetry tracing plugin (requires `libydb-cpp-otel-metrics-dev` for OTel headers/libs). +- `ydb-odbc` β€” YDB ODBC driver and unixODBC registration template. The CPack-only packaging flow is intended for Ubuntu 24.04. It builds and -installs the Google common-protos package before packaging the four SDK -components, so all five packages use the distro protobuf ABI: +installs the Google common-protos package before packaging the SDK components, +so all six packages use the distro protobuf ABI: ```bash ./scripts/build_cpack_deb_packages.sh build-deb/packages ``` -The generated `.deb` files are placed into `build-deb/packages/` and install -under `/usr/share/yandex`. The IAM and OTel packages require the matching core -version; tracing additionally requires the matching metrics package. +The generated `.deb` files are placed into `build-deb/packages/`. SDK files +install under `/usr/share/yandex`; the ODBC driver installs under the system +multiarch library directory with its template under `/usr/share/ydb-odbc`. +The IAM and OTel packages require the matching core version; tracing +additionally requires the matching metrics package. To smoke-test generated `.deb` packages with the sample consumer project: @@ -117,12 +126,17 @@ wget "${BASE}/libydb-cpp-dev_${TAG#v}_amd64.deb" wget "${BASE}/libydb-cpp-iam-dev_${TAG#v}_amd64.deb" wget "${BASE}/libydb-cpp-otel-metrics-dev_${TAG#v}_amd64.deb" wget "${BASE}/libydb-cpp-otel-tracing-dev_${TAG#v}_amd64.deb" +# Optional ODBC driver: +wget "${BASE}/ydb-odbc_${TAG#v}_amd64.deb" sudo apt-get update sudo apt-get install -y \ ./yandex-googleapis-api-common-protos_*.deb \ ./libydb-cpp-dev_*.deb ./libydb-cpp-iam-dev_*.deb \ - ./libydb-cpp-otel-metrics-dev_*.deb ./libydb-cpp-otel-tracing-dev_*.deb + ./libydb-cpp-otel-metrics-dev_*.deb ./libydb-cpp-otel-tracing-dev_*.deb \ + ./ydb-odbc_*.deb + +odbcinst -q -d -n YDB ``` After installation, use the SDK in your CMake project: diff --git a/cmake/PackSDK.cmake b/cmake/PackSDK.cmake index 5d41d0b26b0..6dcaa202e3b 100644 --- a/cmake/PackSDK.cmake +++ b/cmake/PackSDK.cmake @@ -18,6 +18,9 @@ set(CPACK_RESOURCE_FILE_LICENSE "${YDB_SDK_SOURCE_DIR}/LICENSE") set(CPACK_DEB_COMPONENT_INSTALL ON) set(CPACK_COMPONENTS_ALL libydb-cpp libydb-cpp-iam libydb-cpp-otel-metrics libydb-cpp-otel-tracing) +if (YDB_SDK_ODBC) + list(APPEND CPACK_COMPONENTS_ALL ydb-odbc) +endif() set(CPACK_DEBIAN_LIBYDB_CPP_PACKAGE_NAME "libydb-cpp-dev") set(CPACK_DEBIAN_LIBYDB_CPP_PACKAGE_DEPENDS @@ -34,6 +37,18 @@ set(CPACK_DEBIAN_LIBYDB_CPP_OTEL_TRACING_PACKAGE_NAME "libydb-cpp-otel-tracing-d set(CPACK_DEBIAN_LIBYDB_CPP_OTEL_TRACING_PACKAGE_DEPENDS "libydb-cpp-dev (= ${YDB_SDK_VERSION}), libydb-cpp-otel-metrics-dev (= ${YDB_SDK_VERSION})") +if (YDB_SDK_ODBC) + set("CPACK_DEBIAN_YDB-ODBC_PACKAGE_NAME" "ydb-odbc") + set("CPACK_DEBIAN_YDB-ODBC_PACKAGE_DEPENDS" "odbcinst") + set("CPACK_DEBIAN_YDB-ODBC_PACKAGE_SHLIBDEPS" ON) + set("CPACK_DEBIAN_YDB-ODBC_PACKAGE_CONTROL_EXTRA" + "${YDB_ODBC_DEBIAN_CONTROL_EXTRA}") + set("CPACK_DEBIAN_YDB-ODBC_PACKAGE_CONTROL_STRICT_PERMISSION" ON) + set("CPACK_DEBIAN_YDB-ODBC_PACKAGE_SECTION" "database") + set("CPACK_DEBIAN_YDB-ODBC_DESCRIPTION" + "YDB ODBC driver\n Shared ODBC driver and unixODBC registration for YDB.") +endif() + foreach(component IN ITEMS libydb-cpp libydb-cpp-iam libydb-cpp-otel-metrics libydb-cpp-otel-tracing) string(TOUPPER "${component}" component_upper) string(REPLACE "-" "_" component_var "${component_upper}") diff --git a/cmake/common.cmake b/cmake/common.cmake index e32407e16cb..e0597ea44f9 100644 --- a/cmake/common.cmake +++ b/cmake/common.cmake @@ -149,6 +149,7 @@ function(vcs_info Tgt) DEPENDS ${YDB_SDK_SOURCE_DIR}/scripts/vcs_info.py ${YDB_SDK_SOURCE_DIR}/scripts/c_templates/svn_interface.c ${CMAKE_CURRENT_BINARY_DIR}/vcs_info.json ) target_sources(${Tgt} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/__vcs_version__.c) + target_include_directories(${Tgt} PRIVATE ${YDB_SDK_SOURCE_DIR}) endfunction() function(resources Tgt Output) @@ -222,7 +223,7 @@ function(_ydb_sdk_add_library Tgt) set(libraryMode "INTERFACE") set(includeMode "INTERFACE") endif() - + add_library(${Tgt} ${libraryMode}) target_include_directories(${Tgt} ${includeMode} $ diff --git a/cmake/dependencies.cmake b/cmake/dependencies.cmake index 90c90d83eab..d566e6b662f 100644 --- a/cmake/dependencies.cmake +++ b/cmake/dependencies.cmake @@ -404,13 +404,11 @@ else() NAME RapidJSON GITHUB_REPOSITORY Tencent/rapidjson GIT_TAG v${YDB_SDK_RAPIDJSON_VERSION} - EXCLUDE_FROM_ALL YES - OPTIONS - "RAPIDJSON_BUILD_DOC OFF" - "RAPIDJSON_BUILD_EXAMPLES OFF" - "RAPIDJSON_BUILD_TESTS OFF" - "RAPIDJSON_BUILD_THIRDPARTY_GTEST OFF" + DOWNLOAD_ONLY YES ) + # RapidJSON is header-only. Adding its CMake project would globally set + # RULE_LAUNCH_COMPILE and RULE_LAUNCH_LINK when ccache is installed, + # duplicating our compiler launcher and wrapping non-compiler commands. if(NOT TARGET RapidJSON::RapidJSON) add_library(RapidJSON::RapidJSON INTERFACE IMPORTED GLOBAL) target_include_directories(RapidJSON::RapidJSON INTERFACE diff --git a/cmake/external_libs.cmake b/cmake/external_libs.cmake index 1e6120bc3cd..3062ba83dd1 100644 --- a/cmake/external_libs.cmake +++ b/cmake/external_libs.cmake @@ -29,6 +29,10 @@ if(YDB_SDK_ENABLE_OTEL_METRICS OR YDB_SDK_ENABLE_OTEL_TRACE OR YDB_SDK_TESTS) endif() endif() +if(YDB_SDK_ODBC) + find_package(ODBC REQUIRED) +endif() + # Google API common protos remain independently packageable for Ubuntu, while # CPM builds generate the same library directly from the pinned source tree. if(YDB_SDK_GOOGLE_COMMON_PROTOS_TARGET) diff --git a/cmake/testing.cmake b/cmake/testing.cmake index ae5a96d516b..553f7130a9f 100644 --- a/cmake/testing.cmake +++ b/cmake/testing.cmake @@ -4,7 +4,7 @@ include(GoogleTest) function(add_ydb_test) set(opts GTEST) - set(oneval_args NAME WORKING_DIRECTORY OUTPUT_DIRECTORY) + set(oneval_args NAME WORKING_DIRECTORY OUTPUT_DIRECTORY TIMEOUT) set(multival_args INCLUDE_DIRS SOURCES LINK_LIBRARIES LABELS TEST_ARG ENV) cmake_parse_arguments(YDB_TEST "${opts}" @@ -48,21 +48,38 @@ function(add_ydb_test) endif() if (YDB_TEST_GTEST) + set(timeout_property "") + if (YDB_TEST_TIMEOUT) + set(timeout_property TIMEOUT ${YDB_TEST_TIMEOUT}) + endif() set(env_vars "") - foreach(env_var ${YDB_TEST_ENV}) + foreach(env_var IN LISTS YDB_TEST_ENV) list(APPEND env_vars "ENVIRONMENT") - list(APPEND env_vars ${env_var}) + list(APPEND env_vars "${env_var}") endforeach() - gtest_discover_tests(${YDB_TEST_NAME} EXTRA_ARGS ${YDB_TEST_TEST_ARG} WORKING_DIRECTORY ${YDB_TEST_WORKING_DIRECTORY} PROPERTIES - LABELS ${YDB_TEST_LABELS} ENVIRONMENT "YDB_TEST_ROOT=sdk_tests" + ${timeout_property} ${env_vars} ) + # Discovered tests only exist when CTest loads this directory. Assign + # labels from a second include so a semicolon-separated label list stays a + # single property value rather than becoming extra property/value pairs. + if (YDB_TEST_LABELS) + set(test_labels_file + "${CMAKE_CURRENT_BINARY_DIR}/${YDB_TEST_NAME}_labels.cmake") + string(CONCAT test_labels_content + "if(DEFINED ${YDB_TEST_NAME}_TESTS)\n" + " set_tests_properties(\${${YDB_TEST_NAME}_TESTS} PROPERTIES LABELS \"${YDB_TEST_LABELS}\")\n" + "endif()\n") + file(GENERATE OUTPUT "${test_labels_file}" CONTENT "${test_labels_content}") + set_property(DIRECTORY APPEND PROPERTY TEST_INCLUDE_FILES "${test_labels_file}") + endif() + target_link_libraries(${YDB_TEST_NAME} PRIVATE GTest::gtest_main GTest::gmock_main @@ -83,7 +100,7 @@ function(add_ydb_test) cpp-testing-unittest_main ) - set_tests_properties(${YDB_TEST_NAME} PROPERTIES LABELS ${YDB_TEST_LABELS}) + set_tests_properties(${YDB_TEST_NAME} PROPERTIES LABELS "${YDB_TEST_LABELS}") set_tests_properties(${YDB_TEST_NAME} PROPERTIES ENVIRONMENT "YDB_TEST_ROOT=sdk_tests") if (YDB_TEST_ENV) set_tests_properties(${YDB_TEST_NAME} PROPERTIES ENVIRONMENT ${YDB_TEST_ENV}) @@ -92,3 +109,41 @@ function(add_ydb_test) vcs_info(${YDB_TEST_NAME}) endfunction() + +if (YDB_SDK_ODBC) + function(add_odbc_test) + set(opts "") + set(oneval_args NAME WORKING_DIRECTORY OUTPUT_DIRECTORY) + set(multival_args SOURCES LINK_LIBRARIES LABELS) + cmake_parse_arguments(ODBC_TEST + "${opts}" + "${oneval_args}" + "${multival_args}" + ${ARGN} + ) + + add_ydb_test(GTEST + NAME ${ODBC_TEST_NAME} + SOURCES ${ODBC_TEST_SOURCES} + LINK_LIBRARIES + ${ODBC_TEST_LINK_LIBRARIES} + ODBC::ODBC + LABELS + integration + ${ODBC_TEST_LABELS} + ) + + target_compile_definitions(${ODBC_TEST_NAME} + PRIVATE + ODBC_DRIVER_PATH="$" + ODBC_DRIVER_VERSION="${YDB_SDK_VERSION}" + ODBC_TEST_ODBCINI="${YDB_ODBC_TEST_INI}" + ODBC_TEST_ODBCSYSINI="${CMAKE_BINARY_DIR}/odbc" + ) + if (ODBC_LIBRARY MATCHES "[iI][oO][dD][bB][cC]") + target_compile_definitions(${ODBC_TEST_NAME} PRIVATE ODBC_TEST_IODBC=1) + endif() + + add_dependencies(${ODBC_TEST_NAME} ydb-odbc) + endfunction() +endif() diff --git a/odbc/CMakeLists.txt b/odbc/CMakeLists.txt new file mode 100644 index 00000000000..123cae44c3c --- /dev/null +++ b/odbc/CMakeLists.txt @@ -0,0 +1,180 @@ +add_library(ydb-odbc SHARED + src/utils/escape.cpp + src/utils/sql_type_map.cpp + src/utils/cursor.cpp + src/utils/types.cpp + src/utils/util.cpp + src/utils/status_util.cpp + src/utils/convert.cpp + src/utils/error_manager.cpp + src/utils/handle.cpp + src/odbc_driver.cpp + src/connection_attr.cpp + src/connection_config.cpp + src/connection.cpp + src/statement.cpp + src/statement_metadata.cpp + src/environment.cpp + src/metadata.cpp + src/descriptor.cpp +) + +get_filename_component(_ydb_odbc_library_dir "${ODBC_LIBRARY}" DIRECTORY) +get_filename_component(_ydb_odbc_library_name "${ODBC_LIBRARY}" NAME) +if (WIN32) + set(_ydb_odbcinst_names odbccp32) +elseif (_ydb_odbc_library_name MATCHES "[iI][oO][dD][bB][cC]") + set(_ydb_odbcinst_names iodbcinst) +else() + set(_ydb_odbcinst_names odbcinst) +endif() +find_library(YDB_ODBCINST_LIBRARY + NAMES ${_ydb_odbcinst_names} + HINTS "${_ydb_odbc_library_dir}" + REQUIRED +) +unset(_ydb_odbc_library_dir) +unset(_ydb_odbc_library_name) +unset(_ydb_odbcinst_names) + +target_include_directories(ydb-odbc + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/include + ${CMAKE_CURRENT_SOURCE_DIR}/src + ${ODBC_INCLUDE_DIRS} +) + +target_compile_definitions(ydb-odbc + PRIVATE + YDB_ODBC_DRIVER_VERSION="${YDB_SDK_VERSION}" +) + +target_link_libraries(ydb-odbc + PRIVATE + YDB-CPP-SDK::Query + YDB-CPP-SDK::Table + YDB-CPP-SDK::Scheme + YDB-CPP-SDK::Driver + YDB-CPP-SDK::Credentials + YDB-CPP-SDK::Helpers + YDB-CPP-SDK::Iam + ${YDB_ODBCINST_LIBRARY} +) + +if (APPLE) + add_executable(ydb-odbc-register-macos + packaging/register_macos.cpp + ) + target_include_directories(ydb-odbc-register-macos + PRIVATE + ${ODBC_INCLUDE_DIRS} + ) + target_link_libraries(ydb-odbc-register-macos + PRIVATE + ${YDB_ODBCINST_LIBRARY} + ) + add_dependencies(ydb-odbc ydb-odbc-register-macos) +endif() + +set_target_properties(ydb-odbc PROPERTIES + POSITION_INDEPENDENT_CODE ON +) + +include(GNUInstallDirs) + +if (YDB_SDK_DEPENDENCY_MODE STREQUAL "SYSTEM" AND CMAKE_LIBRARY_ARCHITECTURE) + set(_ydb_odbc_default_libdir "/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}") + set(_ydb_odbc_default_datadir "/usr/share/ydb-odbc") +else() + set(_ydb_odbc_default_libdir "${CMAKE_INSTALL_LIBDIR}") + set(_ydb_odbc_default_datadir "${CMAKE_INSTALL_DATAROOTDIR}/ydb-odbc") +endif() + +set(YDB_ODBC_INSTALL_LIBDIR "${_ydb_odbc_default_libdir}" CACHE STRING + "Directory where the YDB ODBC shared library is installed") +set(YDB_ODBC_INSTALL_DATADIR "${_ydb_odbc_default_datadir}" CACHE STRING + "Directory where the YDB ODBC driver registration template is installed") +unset(_ydb_odbc_default_libdir) +unset(_ydb_odbc_default_datadir) + +if (IS_ABSOLUTE "${YDB_ODBC_INSTALL_LIBDIR}") + set(YDB_ODBC_DRIVER_INSTALL_DIR "${YDB_ODBC_INSTALL_LIBDIR}") +else() + set(YDB_ODBC_DRIVER_INSTALL_DIR + "${CMAKE_INSTALL_PREFIX}/${YDB_ODBC_INSTALL_LIBDIR}") +endif() + +if (IS_ABSOLUTE "${YDB_ODBC_INSTALL_DATADIR}") + set(YDB_ODBC_DRIVER_TEMPLATE_DIR "${YDB_ODBC_INSTALL_DATADIR}") +else() + set(YDB_ODBC_DRIVER_TEMPLATE_DIR + "${CMAKE_INSTALL_PREFIX}/${YDB_ODBC_INSTALL_DATADIR}") +endif() + +file(GENERATE + OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/odbcinst.ini" + CONTENT "[YDB] +Description=YDB ODBC Driver +Driver=$ +Setup=$ +" +) + +set(YDB_ODBC_DRIVER_PATH + "${YDB_ODBC_DRIVER_INSTALL_DIR}/libydb-odbc${CMAKE_SHARED_LIBRARY_SUFFIX}") +configure_file( + "${CMAKE_CURRENT_SOURCE_DIR}/odbcinst.ini.in" + "${CMAKE_CURRENT_BINARY_DIR}/ydb-odbc-odbcinst.ini" + @ONLY +) + +set(YDB_ODBC_DRIVER_TEMPLATE_PATH + "${YDB_ODBC_DRIVER_TEMPLATE_DIR}/odbcinst.ini") +file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/debian") +configure_file( + "${CMAKE_CURRENT_SOURCE_DIR}/packaging/postinst.in" + "${CMAKE_CURRENT_BINARY_DIR}/debian/postinst" + @ONLY +) +configure_file( + "${CMAKE_CURRENT_SOURCE_DIR}/packaging/prerm.in" + "${CMAKE_CURRENT_BINARY_DIR}/debian/prerm" + @ONLY +) +set(YDB_ODBC_DEBIAN_CONTROL_EXTRA + "${CMAKE_CURRENT_BINARY_DIR}/debian/postinst;${CMAKE_CURRENT_BINARY_DIR}/debian/prerm" + CACHE INTERNAL "Debian control scripts for the ydb-odbc package") + +install(FILES "${CMAKE_CURRENT_BINARY_DIR}/ydb-odbc-odbcinst.ini" + DESTINATION "${YDB_ODBC_INSTALL_DATADIR}" + RENAME odbcinst.ini + COMPONENT ydb-odbc +) + +install(TARGETS ydb-odbc + LIBRARY DESTINATION "${YDB_ODBC_INSTALL_LIBDIR}" + COMPONENT ydb-odbc +) + +if (APPLE) + install(CODE " + if (\"\$ENV{DESTDIR}\" STREQUAL \"\") + execute_process( + COMMAND \"$\" + \"${YDB_ODBC_DRIVER_PATH}\" + RESULT_VARIABLE _ydb_odbc_register_result + ) + if (NOT _ydb_odbc_register_result EQUAL 0) + message(FATAL_ERROR \"Failed to register the YDB ODBC driver with iODBC\") + endif() + endif() + " COMPONENT ydb-odbc) +endif() + +if (YDB_SDK_EXAMPLES) + add_subdirectory(examples) +endif() + +if (YDB_SDK_TESTS) + add_subdirectory(tests) +endif() diff --git a/odbc/README.md b/odbc/README.md new file mode 100644 index 00000000000..8cc47930f3c --- /dev/null +++ b/odbc/README.md @@ -0,0 +1,274 @@ +# YDB ODBC Driver + +ODBC driver for YDB. + +## Concurrency + +Different connections and autocommit statements can execute concurrently. Calls +on one handle are ordered, except cross-thread `SQLCancel`, which requests +cancellation without waiting for execution. Explicit-transaction statements +share one session and execute in order; connection reconfiguration, transaction +completion and disconnect wait for active calls. + +Cancellation is local: it discards pending results and stops subsequent query +attempts without interrupting an RPC already in flight. That RPC may finish or +reach its configured timeout, and writes may still commit. Execution diagnostics +are preserved. `SQLCancel` does not abort the shared explicit transaction or +invalidate its session; session cleanup remains with the SDK. +`SQLCancel` returning success means the local request was processed. + +Applications must keep bound buffers alive and avoid concurrent access to the +same buffer during calls. Descriptor changes apply to subsequent calls, not to +an operation's existing binding snapshot. Freeing a handle retires it while +keeping already pinned calls safe. Applications must not reuse freed handles. +`SQLFreeHandle` waits for an in-flight execution on that handle to finish. + +## Requirements + +- CMake 3.22 or higher +- C/C++ compiler with C11 and C++20 support +- YDB C++ SDK (build with `YDB_SDK_ODBC=ON`) +- Linux: unixODBC development packages and `odbcinst` +- macOS: iODBC development headers and the OpenLink iODBC SDK frameworks + +Dependencies are fetched at the versions pinned by the standalone SDK build. + +## Supported platforms + +| Platform | Driver manager | Status | +| --- | --- | --- | +| Linux | unixODBC | Source build; Ubuntu 24.04 amd64 package and automated API/consumer tests | +| macOS | iODBC 3.52.16 | Source build matching the application architecture; verified on arm64 | +| Windows | β€” | Not currently packaged or validated | + +## Build + +```bash +cmake --preset release-clang -DYDB_SDK_ODBC=ON -DYDB_SDK_EXAMPLES=OFF +cmake --build build --target ydb-odbc --parallel +``` + +The shared library is `build/odbc/libydb-odbc.so` on Linux and +`build/odbc/libydb-odbc.dylib` on macOS. + +## Linux installation + +```bash +cmake --preset release-clang -DYDB_SDK_ODBC=ON -DYDB_SDK_EXAMPLES=OFF \ + -DCMAKE_INSTALL_PREFIX=/usr/local +cmake --build build --target ydb-odbc --parallel +sudo cmake --install build --component ydb-odbc +sudo odbcinst -i -d -f /usr/local/share/ydb-odbc/odbcinst.ini +``` + +This installs `libydb-odbc` and its unixODBC registration template. The +`ydb-odbc` Debian package runs `odbcinst` automatically during installation +and unregisters the driver when the package is removed. `odbc.ini` is not +installed or modified β€” create your own DSN (see below). + +## macOS installation + +Use Homebrew iODBC to build the driver. Also install the current +[OpenLink iODBC SDK](https://www.iodbc.org/dataspace/doc/iodbc/wiki/iodbcWiki/Downloads), +which supplies the universal `iODBC.framework` and `iODBCinst.framework` under +`/Library/Frameworks`. The driver itself must contain the architecture used by +the client process. + +Pin all ODBC paths so CMake cannot mix unixODBC libraries with iODBC headers. +The static installer, IDN, and OpenSSL libraries keep the installed driver free +of Homebrew runtime paths: + +```bash +brew install libidn libiodbc openssl@3 +IODBC_ROOT="$(brew --prefix libiodbc)" +IDN_ROOT="$(brew --prefix libidn)" +OPENSSL_ROOT="$(brew --prefix openssl@3)" +cmake --preset release-clang \ + -DYDB_SDK_ODBC=ON \ + -DYDB_SDK_EXAMPLES=OFF \ + -DODBC_CONFIG="${IODBC_ROOT}/bin/iodbc-config" \ + -DODBC_INCLUDE_DIR="${IODBC_ROOT}/include" \ + -DODBC_LIBRARY="${IODBC_ROOT}/lib/libiodbc.dylib" \ + -DYDB_ODBCINST_LIBRARY="${IODBC_ROOT}/lib/libiodbcinst.a" \ + -DIDN_LIBRARIES="${IDN_ROOT}/lib/libidn.a" \ + -DOPENSSL_ROOT_DIR="${OPENSSL_ROOT}" \ + -DOPENSSL_USE_STATIC_LIBS=ON \ + -DYDB_ODBC_INSTALL_LIBDIR=/Library/ODBC/YDB \ + -DYDB_ODBC_INSTALL_DATADIR=/Library/ODBC/YDB +cmake --build build --target ydb-odbc --parallel +sudo cmake --install build --component ydb-odbc +otool -L /Library/ODBC/YDB/libydb-odbc.dylib +``` + +The install command registers the driver and a local `YDB` system DSN in +`/Library/ODBC/odbcinst.ini` and `/Library/ODBC/odbc.ini`. Existing sections +for other drivers and data sources are preserved. The final `otool` output +must not contain build-directory or Homebrew paths. + +## Configuration + +For `SQLConnect("YDB", ...)`, `isql -v YDB`, or `Driver=YDB`. + +**`odbcinst.ini`** β€” driver registration template (generated on build/install). +Section `[YDB]` is the driver name used as `Driver=YDB` in connection strings +and DSNs. `Driver` and `Setup` are the full path to the platform driver library. +Register the template with `odbcinst -i -d -f`; the Debian package does this +for you. + +```ini +[YDB] +Description=YDB ODBC Driver +Driver=/path/to/libydb-odbc.so +Setup=/path/to/libydb-odbc.so +``` + +**`odbc.ini`** β€” DSN named `YDB`. In section `[YDB]`, `Driver` is the +registered driver name or an absolute driver-library path, `Endpoint` (or its +`Server` alias) is the YDB endpoint, and `Database` is the database path. On +Linux use `~/.odbc.ini` or `/etc/odbc.ini`; `ODBCINI` can override the path. + +```ini +[ODBC Data Sources] +YDB=YDB ODBC Driver + +[YDB] +Driver=YDB +Server=localhost:2136 +Database=/local +AuthMode=Anonymous +``` + +On macOS, `sudo cmake --install build --component ydb-odbc` writes the +following sections to `/Library/ODBC/odbcinst.ini` and +`/Library/ODBC/odbc.ini`. They are shown here for reference and for manual +registration of an already-built driver. + +```ini +; /Library/ODBC/odbcinst.ini +[ODBC Drivers] +YDB ODBC Driver=Installed + +[YDB ODBC Driver] +Description=YDB ODBC Driver +Driver=/Library/ODBC/YDB/libydb-odbc.dylib +Setup=/Library/ODBC/YDB/libydb-odbc.dylib +``` + +```ini +; /Library/ODBC/odbc.ini +[ODBC Data Sources] +YDB=YDB ODBC Driver + +[YDB] +Driver=/Library/ODBC/YDB/libydb-odbc.dylib +Endpoint=grpc://localhost:2136 +Database=/local +AuthMode=Anonymous +``` + +For a non-sandboxed per-user setup, the equivalent macOS files live under +`~/Library/ODBC`. Verify the DSN with +`"$(brew --prefix libiodbc)/bin/iodbctest" "DSN=YDB"`. + +`SQLDriverConnect` may also combine a DSN with explicit attributes. Values in +the connection string take precedence over values from the DSN. The user name +and password passed to `SQLConnect` take precedence over `User` and `Password` +in the DSN. + +### Connection attributes + +| Attribute | Meaning | +| --- | --- | +| `Endpoint` | YDB endpoint. `Server` is an alias. A `grpc://` prefix forces a plaintext connection; `grpcs://` enables TLS. | +| `Database` | YDB database path. | +| `DSN` | DSN section to load before applying the remaining connection-string attributes. | +| `AuthMode` | `Anonymous`, `Token`, `Static`, `Metadata`, `ServiceAccount`, `OAuth2`, or `Environment`. Values are case-insensitive. | +| `AnsiSQL` | `1` enables YDB's ANSI lexer and Unicode string literals for SQL-generating clients. `SQLNativeSql` includes the `--!ansi_lexer` / `PRAGMA UnicodeLiterals;` prologue. Defaults to `0` (native YQL). | +| `Token` | Access token for `Token` mode. `AccessToken` is an alias. | +| `User`, `Password` | Credentials for `Static` mode. `UID` and `PWD` are aliases. | +| `MetadataHost`, `MetadataPort` | Optional metadata service address for `Metadata` mode. | +| `ServiceAccountKeyFile` | Path to a service-account JSON key for `ServiceAccount` mode. `SaFile` is an alias. | +| `OAuth2KeyFile` | Path to an OAuth 2.0 token-exchange configuration file for `OAuth2` mode. | +| `IamEndpoint` | IAM gRPC endpoint for service-account authentication, or HTTP token endpoint override for OAuth 2.0 token exchange. | +| `RootCertificate` | Path to a PEM root-certificate file. `CaFile` is an alias. | +| `ClientCertificate`, `ClientPrivateKey` | Paths to the PEM client certificate and private key. They must be specified together. | + +If `AuthMode` is omitted, the driver infers it from exactly one credential +family (`Token`, static user/password, metadata settings, service-account key, +or OAuth 2.0 key). With no credential attributes it uses `Anonymous`. Conflicting +families and incomplete credentials are rejected with SQLSTATE `28000`. +`Environment` uses the SDK's standard `YDB_*_CREDENTIALS` variables. + +Unrecognized connection-string attributes are ignored after reporting SQLSTATE +`01S00`; `SQLDriverConnect` completes with `SQL_SUCCESS_WITH_INFO`. This allows +ODBC applications to supply tool-specific attributes such as `APP` or `WSID`. + +Certificate attributes contain file paths, not inline PEM. The driver reads the +files while establishing the ODBC connection. Supplying certificates enables +TLS; certificates cannot be combined with an explicitly plaintext `grpc://` +endpoint. + +Examples: + +```text +Driver=YDB;Endpoint=grpcs://ydb.example.net:2135;Database=/production;AuthMode=Token;Token=... +DSN=YDB;AuthMode=Static;UID=app;PWD=secret +Driver=YDB;Endpoint=localhost:2136;Database=/local;AuthMode=ServiceAccount;SaFile=/run/secrets/sa.json;IamEndpoint=grpc://localhost:4284 +``` + +## Usage + +Example of connecting via isql: +```bash +isql -v YDB +``` + +Example usage in C: +```c +SQLHENV env; +SQLHDBC dbc; +SQLHSTMT stmt; + +// Initialize environment +SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env); +SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); + +// Connect +SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc); +SQLConnect(dbc, (SQLCHAR*)"YDB", SQL_NTS, + (SQLCHAR*)"", SQL_NTS, + (SQLCHAR*)"", SQL_NTS); + +// Execute query +SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt); +SQLExecDirect(stmt, (SQLCHAR*)"SELECT * FROM mytable", SQL_NTS); + +// Cleanup +SQLFreeHandle(SQL_HANDLE_STMT, stmt); +SQLDisconnect(dbc); +SQLFreeHandle(SQL_HANDLE_DBC, dbc); +SQLFreeHandle(SQL_HANDLE_ENV, env); +``` + +Alternatively, use `SQLDriverConnect` with a connection string (does not require DSN in odbc.ini): +```c +SQLCHAR connStr[] = "Driver=YDB;Endpoint=localhost:2136;Database=/local"; +SQLDriverConnect(dbc, NULL, connStr, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT); +``` + +For `INSERT`, `UPDATE`, `DELETE`, `UPSERT`, and `REPLACE`, `SQLRowCount` +returns the affected-row count reported by YDB query statistics. Counts from +executed parameter-array entries are summed; ignored entries are not counted. +For statements without an applicable count, it returns `-1`. + +## Parameters + +`?` placeholders are rewritten to `$p1`, `$p2`, ... with auto-generated +`DECLARE` statements derived from `SQLBindParameter` types. Null values use an +optional YDB type. YDB-native `$pN` syntax also works. +Statements support at most 32767 parameters; larger counts or `$pN` indices +return `HY000`. + +## License + +Apache License 2.0 diff --git a/odbc/examples/CMakeLists.txt b/odbc/examples/CMakeLists.txt new file mode 100644 index 00000000000..88b1f27cc60 --- /dev/null +++ b/odbc/examples/CMakeLists.txt @@ -0,0 +1,2 @@ +add_subdirectory(basic) +add_subdirectory(scheme) diff --git a/odbc/examples/basic/CMakeLists.txt b/odbc/examples/basic/CMakeLists.txt new file mode 100644 index 00000000000..b99d1175f43 --- /dev/null +++ b/odbc/examples/basic/CMakeLists.txt @@ -0,0 +1,14 @@ +add_executable(odbc_basic + main.cpp +) + +target_link_libraries(odbc_basic + PRIVATE + ODBC::ODBC +) +target_compile_definitions(odbc_basic + PRIVATE + ODBC_DRIVER_PATH="$" +) + +add_dependencies(odbc_basic ydb-odbc) diff --git a/odbc/examples/basic/main.cpp b/odbc/examples/basic/main.cpp new file mode 100644 index 00000000000..8084e32f3d1 --- /dev/null +++ b/odbc/examples/basic/main.cpp @@ -0,0 +1,132 @@ +#include +#include + +#include + +void PrintOdbcError(SQLSMALLINT handleType, SQLHANDLE handle) { + SQLCHAR sqlState[6] = {0}; + SQLINTEGER nativeError = 0; + SQLCHAR message[256] = {0}; + SQLSMALLINT textLength = 0; + SQLGetDiagRec(handleType, handle, 1, sqlState, &nativeError, message, sizeof(message), &textLength); + std::cerr << "ODBC error: [" << sqlState << "] " << message << std::endl; +} + +int main() { + SQLHENV henv = nullptr; + SQLHDBC hdbc = nullptr; + SQLHSTMT hstmt = nullptr; + SQLRETURN ret; + + std::cout << "1. Allocating environment handle" << std::endl; + ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv); + if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { + std::cerr << "Error allocating environment handle" << std::endl; + return 1; + } + SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); + + std::cout << "2. Allocating connection handle" << std::endl; + ret = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc); + if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { + std::cerr << "Error allocating connection handle" << std::endl; + SQLFreeHandle(SQL_HANDLE_ENV, henv); + return 1; + } + + std::cout << "3. Building connection string" << std::endl; + std::string connStr = "Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;"; + SQLCHAR outConnStr[1024] = {0}; + SQLSMALLINT outConnStrLen = 0; + + std::cout << "4. Connecting with SQLDriverConnect" << std::endl; + ret = SQLDriverConnect(hdbc, NULL, (SQLCHAR*)connStr.c_str(), SQL_NTS, + outConnStr, sizeof(outConnStr), &outConnStrLen, SQL_DRIVER_COMPLETE); + if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { + std::cerr << "Error connecting with SQLDriverConnect" << std::endl; + PrintOdbcError(SQL_HANDLE_DBC, hdbc); + SQLFreeHandle(SQL_HANDLE_DBC, hdbc); + SQLFreeHandle(SQL_HANDLE_ENV, henv); + return 1; + } + + std::cout << "5. Allocating statement handle" << std::endl; + ret = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt); + if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { + std::cerr << "Error allocating statement handle" << std::endl; + SQLDisconnect(hdbc); + SQLFreeHandle(SQL_HANDLE_DBC, hdbc); + SQLFreeHandle(SQL_HANDLE_ENV, henv); + return 1; + } + + std::cout << "6. Executing query" << std::endl; + SQLCHAR query[] = R"( + DECLARE $p1 AS Int64?; + SELECT id, data from test_table WHERE id == $p1; + )"; + + int64_t paramValue = 1; + SQLLEN paramInd = 0; + ret = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_SBIGINT, SQL_BIGINT, 0, 0, ¶mValue, 0, ¶mInd); + if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { + std::cerr << "Error binding parameter" << std::endl; + PrintOdbcError(SQL_HANDLE_STMT, hstmt); + SQLFreeHandle(SQL_HANDLE_STMT, hstmt); + SQLDisconnect(hdbc); + SQLFreeHandle(SQL_HANDLE_DBC, hdbc); + SQLFreeHandle(SQL_HANDLE_ENV, henv); + return 1; + } + + ret = SQLExecDirect(hstmt, query, SQL_NTS); + if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { + std::cerr << "Error executing query" << std::endl; + PrintOdbcError(SQL_HANDLE_STMT, hstmt); + SQLFreeHandle(SQL_HANDLE_STMT, hstmt); + SQLDisconnect(hdbc); + SQLFreeHandle(SQL_HANDLE_DBC, hdbc); + SQLFreeHandle(SQL_HANDLE_ENV, henv); + return 1; + } + + std::cout << "7. Fetching result" << std::endl; + + SQLLEN ind = 0; + int value1 = 0; + if (SQLBindCol(hstmt, 1, SQL_C_SLONG, &value1, 0, &ind) != SQL_SUCCESS) { + std::cerr << "Error binding column 1" << std::endl; + PrintOdbcError(SQL_HANDLE_STMT, hstmt); + return 1; + } + + SQLCHAR value2[1024] = {0}; + if (SQLBindCol(hstmt, 2, SQL_C_CHAR, &value2, 1024, &ind) != SQL_SUCCESS) { + std::cerr << "Error binding column 2" << std::endl; + PrintOdbcError(SQL_HANDLE_STMT, hstmt); + return 1; + } + + while ((ret = SQLFetch(hstmt)) == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO) { + if (ret != SQL_SUCCESS) { + std::cerr << "Error fetching result" << std::endl; + PrintOdbcError(SQL_HANDLE_STMT, hstmt); + return 1; + } + + std::cout << "Result column 1: " << value1 << std::endl; + std::cout << "Result column 2: " << value2 << std::endl; + + std::cout << "--------------------------------" << std::endl; + } + + std::cout << "8. Cleaning up" << std::endl; + + SQLCloseCursor(hstmt); + SQLFreeHandle(SQL_HANDLE_STMT, hstmt); + SQLDisconnect(hdbc); + SQLFreeHandle(SQL_HANDLE_DBC, hdbc); + SQLFreeHandle(SQL_HANDLE_ENV, henv); + + return 0; +} diff --git a/odbc/examples/scheme/CMakeLists.txt b/odbc/examples/scheme/CMakeLists.txt new file mode 100644 index 00000000000..ffab881aed5 --- /dev/null +++ b/odbc/examples/scheme/CMakeLists.txt @@ -0,0 +1,14 @@ +add_executable(odbc_scheme + main.cpp +) + +target_link_libraries(odbc_scheme + PRIVATE + ODBC::ODBC +) +target_compile_definitions(odbc_scheme + PRIVATE + ODBC_DRIVER_PATH="$" +) + +add_dependencies(odbc_scheme ydb-odbc) diff --git a/odbc/examples/scheme/main.cpp b/odbc/examples/scheme/main.cpp new file mode 100644 index 00000000000..3ae2cd6fe40 --- /dev/null +++ b/odbc/examples/scheme/main.cpp @@ -0,0 +1,116 @@ +#include +#include + +#include + +void PrintOdbcError(SQLSMALLINT handleType, SQLHANDLE handle) { + SQLCHAR sqlState[6] = {0}; + SQLINTEGER nativeError = 0; + SQLCHAR message[256] = {0}; + SQLSMALLINT textLength = 0; + SQLGetDiagRec(handleType, handle, 1, sqlState, &nativeError, message, sizeof(message), &textLength); + std::cerr << "ODBC error: [" << sqlState << "] " << message << std::endl; +} + +int main() { + SQLHENV henv = nullptr; + SQLHDBC hdbc = nullptr; + SQLHSTMT hstmt = nullptr; + SQLRETURN ret; + + std::cout << "1. Allocating environment handle" << std::endl; + ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv); + if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { + std::cerr << "Error allocating environment handle" << std::endl; + return 1; + } + SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); + + std::cout << "2. Allocating connection handle" << std::endl; + ret = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc); + if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { + std::cerr << "Error allocating connection handle" << std::endl; + SQLFreeHandle(SQL_HANDLE_ENV, henv); + return 1; + } + + std::cout << "3. Building connection string" << std::endl; + std::string connStr = "Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;"; + SQLCHAR outConnStr[1024] = {0}; + SQLSMALLINT outConnStrLen = 0; + + std::cout << "4. Connecting with SQLDriverConnect" << std::endl; + ret = SQLDriverConnect(hdbc, NULL, (SQLCHAR*)connStr.c_str(), SQL_NTS, + outConnStr, sizeof(outConnStr), &outConnStrLen, SQL_DRIVER_COMPLETE); + if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { + std::cerr << "Error connecting with SQLDriverConnect" << std::endl; + PrintOdbcError(SQL_HANDLE_DBC, hdbc); + SQLFreeHandle(SQL_HANDLE_DBC, hdbc); + SQLFreeHandle(SQL_HANDLE_ENV, henv); + return 1; + } + + std::cout << "5. Allocating statement handle" << std::endl; + ret = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt); + if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { + std::cerr << "Error allocating statement handle" << std::endl; + SQLDisconnect(hdbc); + SQLFreeHandle(SQL_HANDLE_DBC, hdbc); + SQLFreeHandle(SQL_HANDLE_ENV, henv); + return 1; + } + + std::cout << "6. Getting tables" << std::endl; + + SQLCHAR pattern[] = "/local"; + SQLCHAR tableType[] = "TABLE"; + + ret = SQLTables(hstmt, NULL, 0, NULL, 0, pattern, SQL_NTS, tableType, SQL_NTS); + if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { + std::cerr << "Error executing query" << std::endl; + PrintOdbcError(SQL_HANDLE_STMT, hstmt); + SQLFreeHandle(SQL_HANDLE_STMT, hstmt); + SQLDisconnect(hdbc); + SQLFreeHandle(SQL_HANDLE_DBC, hdbc); + SQLFreeHandle(SQL_HANDLE_ENV, henv); + return 1; + } + + std::cout << "7. Fetching result" << std::endl; + + SQLLEN ind = 0; + SQLCHAR value1[1024] = {0}; + if (SQLBindCol(hstmt, 3, SQL_C_CHAR, &value1, 1024, &ind) != SQL_SUCCESS) { + std::cerr << "Error binding column 1" << std::endl; + PrintOdbcError(SQL_HANDLE_STMT, hstmt); + return 1; + } + + SQLCHAR value2[1024] = {0}; + if (SQLBindCol(hstmt, 4, SQL_C_CHAR, &value2, 1024, &ind) != SQL_SUCCESS) { + std::cerr << "Error binding column 2" << std::endl; + PrintOdbcError(SQL_HANDLE_STMT, hstmt); + return 1; + } + + while ((ret = SQLFetch(hstmt)) == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO) { + if (ret != SQL_SUCCESS) { + std::cerr << "Error fetching result" << std::endl; + PrintOdbcError(SQL_HANDLE_STMT, hstmt); + return 1; + } + + std::cout << "Table name: " << value1 << std::endl; + std::cout << "Table type: " << value2 << std::endl; + + std::cout << "--------------------------------" << std::endl; + } + + std::cout << "8. Cleaning up" << std::endl; + SQLFreeHandle(SQL_HANDLE_STMT, hstmt); + SQLDisconnect(hdbc); + SQLFreeHandle(SQL_HANDLE_DBC, hdbc); + SQLFreeHandle(SQL_HANDLE_ENV, henv); + + return 0; +} diff --git a/odbc/odbc.ini b/odbc/odbc.ini new file mode 100644 index 00000000000..f7334b046f3 --- /dev/null +++ b/odbc/odbc.ini @@ -0,0 +1,9 @@ +[ODBC Data Sources] +YDB=YDB ODBC Driver + +[YDB] +Driver=YDB +Description=YDB Database Connection +Server=localhost:2136 +Database=/local +AuthMode=Anonymous diff --git a/odbc/odbcinst.ini b/odbc/odbcinst.ini new file mode 100644 index 00000000000..db2a9b8378e --- /dev/null +++ b/odbc/odbcinst.ini @@ -0,0 +1,4 @@ +[YDB] +Description=YDB ODBC Driver +Driver=/app/build/odbc/libydb-odbc.so +Setup=/app/build/odbc/libydb-odbc.so diff --git a/odbc/odbcinst.ini.in b/odbc/odbcinst.ini.in new file mode 100644 index 00000000000..8543d9adf73 --- /dev/null +++ b/odbc/odbcinst.ini.in @@ -0,0 +1,4 @@ +[YDB] +Description=YDB ODBC Driver +Driver=@YDB_ODBC_DRIVER_PATH@ +Setup=@YDB_ODBC_DRIVER_PATH@ diff --git a/odbc/packaging/postinst.in b/odbc/packaging/postinst.in new file mode 100644 index 00000000000..902817b6424 --- /dev/null +++ b/odbc/packaging/postinst.in @@ -0,0 +1,10 @@ +#!/bin/sh +set -e + +case "${1:-}" in + configure|abort-upgrade|abort-remove|abort-deconfigure) + odbcinst -i -d -f "@YDB_ODBC_DRIVER_TEMPLATE_PATH@" + ;; +esac + +exit 0 diff --git a/odbc/packaging/prerm.in b/odbc/packaging/prerm.in new file mode 100644 index 00000000000..a91d015be1b --- /dev/null +++ b/odbc/packaging/prerm.in @@ -0,0 +1,13 @@ +#!/bin/sh +set -e + +case "${1:-}" in + remove|upgrade|deconfigure) + if odbcinst -q -d -n YDB 2>/dev/null \ + | grep -Fx "Driver=@YDB_ODBC_DRIVER_PATH@" >/dev/null; then + odbcinst -u -d -n YDB + fi + ;; +esac + +exit 0 diff --git a/odbc/packaging/register_macos.cpp b/odbc/packaging/register_macos.cpp new file mode 100644 index 00000000000..b34ab4cc060 --- /dev/null +++ b/odbc/packaging/register_macos.cpp @@ -0,0 +1,85 @@ +#include + +#include +#include + +namespace { + +struct TProfileEntry { + const char* File; + const char* Section; + const char* Key; + const char* Value; +}; + +void PrintInstallerErrors() { + for (WORD record = 1;; ++record) { + DWORD errorCode = 0; + char message[1024] = {}; + WORD messageLength = 0; + const SQLRETURN result = SQLInstallerError( + record, &errorCode, message, sizeof(message), &messageLength); + if (result == SQL_NO_DATA) { + return; + } + if (result != SQL_SUCCESS && result != SQL_SUCCESS_WITH_INFO) { + return; + } + std::fprintf(stderr, "iODBC installer error %lu: %.*s\n", + static_cast(errorCode), + static_cast(messageLength), message); + } +} + +bool WriteEntry(const TProfileEntry& entry) { + if (SQLWritePrivateProfileString( + entry.Section, entry.Key, entry.Value, entry.File)) { + return true; + } + + std::fprintf(stderr, "Failed to write [%s] %s to %s\n", + entry.Section, entry.Key, entry.File); + PrintInstallerErrors(); + return false; +} + +} // namespace + +int main(int argc, char** argv) { + if (argc != 2) { + std::fprintf(stderr, "Usage: %s /absolute/path/to/libydb-odbc.dylib\n", argv[0]); + return 2; + } + + if (!SQLSetConfigMode(ODBC_SYSTEM_DSN)) { + std::fputs("Failed to select the system iODBC configuration\n", stderr); + PrintInstallerErrors(); + return 1; + } + + const char* driverPath = argv[1]; + const std::array entries = { + TProfileEntry{"odbcinst.ini", "ODBC Drivers", "YDB ODBC Driver", "Installed"}, + TProfileEntry{"odbcinst.ini", "YDB ODBC Driver", "Description", "YDB ODBC Driver"}, + TProfileEntry{"odbcinst.ini", "YDB ODBC Driver", "Driver", driverPath}, + TProfileEntry{"odbcinst.ini", "YDB ODBC Driver", "Setup", driverPath}, + TProfileEntry{"odbcinst.ini", "YDB ODBC Driver", "APILevel", "1"}, + TProfileEntry{"odbcinst.ini", "YDB ODBC Driver", "ConnectFunctions", "YYY"}, + TProfileEntry{"odbcinst.ini", "YDB ODBC Driver", "DriverODBCVer", "03.00"}, + TProfileEntry{"odbcinst.ini", "YDB ODBC Driver", "FileUsage", "0"}, + TProfileEntry{"odbc.ini", "ODBC Data Sources", "YDB", "YDB ODBC Driver"}, + TProfileEntry{"odbc.ini", "YDB", "Driver", driverPath}, + TProfileEntry{"odbc.ini", "YDB", "Description", "Local YDB"}, + TProfileEntry{"odbc.ini", "YDB", "Endpoint", "grpc://localhost:2136"}, + TProfileEntry{"odbc.ini", "YDB", "Database", "/local"}, + TProfileEntry{"odbc.ini", "YDB", "AuthMode", "Anonymous"}, + }; + + for (const auto& entry : entries) { + if (!WriteEntry(entry)) { + return 1; + } + } + + return 0; +} diff --git a/odbc/proposal.md b/odbc/proposal.md new file mode 100644 index 00000000000..e5c79825d8f --- /dev/null +++ b/odbc/proposal.md @@ -0,0 +1,225 @@ +# ODBC driver bindings + +## Goal + +Validate the YDB ODBC driver through established ODBC bindings. Applications use the binding's public API and select YDB through a DSN or connection string. Binding implementation code is not patched. + +Languages with a maintained native YDB SDK are out of scope. PHP remains in scope because its native SDK is planned for deprecation. + +## Binding matrix + +Each language has one binding, one pinned upstream revision, its upstream database tests, and one runnable example. + +| Tier | Language | Binding | Tests | +|---|---|---|---| +| Core | PHP | [PDO_ODBC](https://github.com/php/php-src/tree/master/ext/pdo_odbc) | PDO_ODBC and generic PDO PHPT tests | +| Core | Ruby | [ruby-odbc](https://github.com/larskanis/ruby-odbc) | Upstream test scripts | +| Core | Lua | [LuaSQL ODBC](https://github.com/lunarmodules/luasql) | Common LuaSQL and ODBC parameter tests | +| Core | R | [odbc](https://github.com/r-dbi/odbc) | `testthat` and DBItest | +| Expansion | Dart | [dart_odbc](https://pub.dev/packages/dart_odbc) | `dart test` | +| Expansion | D | [odbc](https://github.com/singingbush/odbc) | Upstream unit and integration tests | +| Expansion | OCaml | [ocaml-odbc](https://opam.ocaml.org/packages/odbc/) | Upstream tests | + +## Required driver behavior + +### Connections + +An ODBC connection is one endpoint/database pair. YDB requires both values for routing ([connection parameters](https://ydb.tech/docs/en/concepts/connect)). + +Each `SQLHDBC` owns: + +- one SDK `TDriver` configured with its endpoint and database; +- its query, table, and scheme clients; +- its query session and active transaction; +- its current catalog, credentials, and diagnostics. + +Connection strings and DSNs must accept: + +- `Server` or `Endpoint`, `Database`, and `DSN`; +- `AuthMode=Anonymous`; +- `AuthMode=Token` with `Token`; +- `AuthMode=Static` with `User` and `Password`; +- `AuthMode=Metadata`, optionally with `MetadataHost` and `MetadataPort`; +- `AuthMode=ServiceAccount` with `ServiceAccountKeyFile`; +- `AuthMode=OAuth2` with `OAuth2KeyFile`; +- `AuthMode=Environment`; +- `IamEndpoint`, `RootCertificate`, `ClientCertificate`, and `ClientPrivateKey`. + +`UID`/`PWD`, `AccessToken`, `SaFile`, and `CaFile` are accepted aliases. The +authentication mode is inferred when exactly one credential type is present. +`SQLConnect` user and password arguments override DSN values. + +`SQLAllocHandle(SQL_HANDLE_DBC)` creates a `TConnection`, and +`TConnection::TYdbState` owns the SDK driver and clients. `SQLHENV` only tracks +connection handles. Connections in the same environment therefore keep +endpoint, database, session, transaction, and catalog state separate. + +`SQL_ATTR_CURRENT_CATALOG` uses a path below the connected database as `TablePathPrefix`. Setting it to another database path recreates only that connection's SDK state. + +Required tests: + +- two database paths on one endpoint; +- two endpoints; +- simultaneous queries; +- independent transactions and catalogs; +- failure and disconnect of one connection while the other remains usable; +- driver-manager pooling keyed by endpoint, database, credentials, and TLS settings. + +### Concurrency and thread safety + +The driver is [thread-safe as required by +ODBC](https://learn.microsoft.com/en-us/sql/odbc/reference/develop-app/multithreading) +and its connections have no thread affinity. It serializes conflicting +operations on the same ODBC handle internally; callers do not have to provide +external locking merely because handles are used from different threads. + +Statements allocated from the same connection retain independent cursor, +descriptor, parameter, and diagnostic state. Distinct statement handles may +execute concurrently in autocommit mode by using separate sessions from the +SDK client pool. Statements participating in one explicit transaction share +that transaction's session, so the driver serializes their query execution. +Calls on unrelated connections remain independent. + +Required tests cover calls from different threads on the same and different +handles, concurrent autocommit statements, serialized execution within an +explicit transaction, race-free cross-thread cancellation, disconnect and +handle-free coordination, and driver-manager connection pooling. + +### Cursors + +YDB returns result sets, not server-side ODBC cursors. The driver owns cursor state for each statement. + +The cursor states are `before first`, `on row or rowset`, `after last`, and `closed`. `SQLFetch` and `SQLFetchScroll(SQL_FETCH_NEXT)` advance a forward cursor. A static cursor stores a result snapshot and implements `FIRST`, `LAST`, `PRIOR`, `ABSOLUTE`, and `RELATIVE`. + +The cursor also owns: + +- typed YDB rows and column metadata; +- row-wise and column-wise bindings; +- row-array status and processed-row counters; +- an offset for the active `SQLGetData` stream; +- static-cursor rows cached in memory until the cursor is closed or replaced, + in addition to the SDK's materialized result. + +Re-execution replaces the cursor. Close, cancel, commit, rollback, and disconnect release it according to the advertised cursor behavior. + +### Multiple results + +When a YDB query returns multiple result sets, execution positions the +statement on the first set and retains the remaining sets in their original +order. [`SQLMoreResults`](https://learn.microsoft.com/en-us/sql/odbc/reference/syntax/sqlmoreresults-function) +discards unread rows in the current set and advances to the next one, +refreshing the implementation row descriptor, row count, fetch state, and +`SQLGetData` offsets. It returns `SQL_NO_DATA` and closes the result sequence +after the last set. + +Application column bindings remain installed across `SQLMoreResults`, as +required by ODBC. Applications must rebind or unbind them when the next result +has a different shape. `SQLCloseCursor`, `SQLFreeStmt(SQL_CLOSE)`, cancellation, +re-execution, and statement destruction discard the entire remaining result +sequence. The driver advertises multiple-result support through +`SQL_MULT_RESULT_SETS`. + +### Binding contract + +The driver must support the operations used by the Core bindings: + +- DSN and connection-string connection; +- prepare, bind, execute, and data-at-execution parameters; +- scalar and rowset fetch; +- multiple result sets through `SQLMoreResults`; +- `NULL`, integer, floating-point, decimal, text, binary, date, time, and timestamp conversion; +- column, table, key, index, type, and result metadata; +- autocommit and explicit transactions; +- diagnostics through SQLSTATE and native YDB issues; +- independent statements and connections; +- thread-safe handle use and concurrent autocommit statements; +- deterministic cleanup after errors. + +### Row counts + +Data-modification statements must request Basic YDB query statistics. +`SQLRowCount` must sum updated and deleted rows from every query phase. +Parameter-array execution must sum the count of each executed parameter set. It +returns `-1` for other statements or when statistics do not contain a usable +count. + +### Debian package + +The driver is shipped as a separate `ydb-odbc` package with the same version as +the SDK release. It contains `libydb-odbc.so` in the multiarch library directory +and an unixODBC driver template. Package dependencies include `odbcinst` and the +shared-library dependencies derived from the built artifact. + +Installation registers the `YDB` driver with `odbcinst -i -d -f`. Upgrade +updates the registration without creating duplicate entries. Removal +unregisters only the entry owned by the package. The package does not install +`/etc/odbc.ini` or modify user DSNs. + +The package is built and published with the SDK release. A clean-container test +installs it, checks `odbcinst -q -d`, connects through `isql` and Qt QODBC, +tests an upgrade, removes the package, and verifies that unrelated drivers and +user DSNs remain unchanged. + +## Resulting limitations + +| Area | Limitation | +|---|---| +| SQL dialect | Statements are YQL. The driver rewrites ODBC escapes and `?` parameters; it is not a general ANSI SQL translator. | +| Retry classification | The driver cannot infer whether arbitrary SQL is idempotent. Autocommit statement retries use `TRetryOperationSettings::Idempotent(false)`. This enables only retries safe for a non-idempotent operation and may return an error with an unknown execution outcome. See [YDB retry settings](https://ydb.tech/docs/en/recipes/ydb-sdk/retry) and [error handling](https://ydb.tech/docs/en/reference/ydb-sdk/error_handling). | +| Explicit transactions | An ODBC transaction is not retried by the driver. Conflicts, node failures, maintenance, and network failures can abort it, including at commit. The application must open a new transaction and replay the entire unit of work in a retry loop. Retrying only the failed statement is incorrect ([query execution](https://ydb.tech/docs/en/concepts/query_execution/), [transactions](https://ydb.tech/docs/en/concepts/transactions)). | +| Transaction isolation | Read-write connections support serializable and snapshot read-write modes. ODBC read-committed and read-uncommitted requests are rejected. | +| Transaction scope | `SQLEndTran(SQL_HANDLE_ENV, ...)` completes each connection independently. It is not an atomic transaction across databases or endpoints. | +| Explicit-transaction concurrency | An explicit transaction uses one YDB session, which executes one query at a time. The driver therefore serializes query execution by statements sharing that transaction; applications that need parallel in-flight queries must use autocommit or separate connections ([YDB session pool](https://ydb.tech/docs/en/recipes/ydb-sdk/session-pool-limit)). | +| Result buffering | Query execution uses the non-streaming SDK result and keeps it for cursor fetches. Large results can consume memory proportional to the result size. | +| Prepare | `SQLPrepare` stores the query and counts client-side parameter markers. It does not create a persistent server-side prepared statement. | +| Batches | Parameter arrays are accepted only for data-modification statements and execute sequentially. Earlier parameter sets may already be committed when a later set fails. | +| Cancellation | Execution is synchronous. `SQLCancel` clears local cursor and parameter state but does not interrupt an in-flight SDK request. | +| Metadata namespace | YDB paths are exposed as catalogs. Schemas are empty. | +| DDL | Autocommit DDL uses `NoTx`. DDL executed while autocommit is off is sent through the active transaction and may be rejected by YDB. | +| Optional ODBC features | Stored procedures, output parameters, positioned updates, bookmarks, asynchronous execution, and ODBC batch operations are not supported. | + +## Test repository + +```text +odbc/tests/frameworks/ + registry.yaml + / + upstream.lock + run-tests + convert-results + example/ +odbc/tests/reporting/ +``` + +`registry.yaml` records the language, tier, runtime image, upstream URL and revision, archive checksum, test command, result format, and example command. CI verifies the checksum before running the unchanged upstream binding. + +Each example uses only the binding's public API. It accepts `YDB_ODBC_DSN` or `YDB_ODBC_CONNECTION_STRING`, creates isolated test data, executes bound statements, iterates a cursor, demonstrates commit and rollback, and cleans up. + +Test output is converted to Allure without changing the upstream runner. Reports include the binding version, runtime version, driver commit, YDB version, endpoint/database mode, and upstream checksum. Missing tests, an empty suite, infrastructure failure, and unexpected skips fail the job. + +## CI + +The complete matrix runs only: + +- after a merge into `odbc-driver-feature`; +- when a pull request has the special full-matrix tag. + +It does not run for ordinary pull requests, direct non-merge pushes, Git tags, schedules, or manual dispatches. + +Each job starts a pinned YDB version, installs the `ydb-odbc` package, creates a +job-local DSN, verifies the upstream source, runs the upstream tests and +example, and uploads native and Allure results. + +## Acceptance + +- `ydb-odbc` passes clean install, upgrade, removal, registration, `isql`, and + Qt QODBC tests. +- Every selected binding runs from a pinned, verified upstream source. +- Binding implementation code is unchanged. +- Every upstream database test is executed or reported as unsupported with its original test identifier. +- Every binding has a runnable example. +- Unit and integration tests pass. +- Endpoint/database isolation tests pass. +- Multiple result sets pass native ODBC and Qt `QSqlQuery::nextResult()` tests. +- Thread-safety and concurrent-statement tests pass without application-side locking. +- Reports contain no missing or unexpected skipped tests. diff --git a/odbc/src/connection.cpp b/odbc/src/connection.cpp new file mode 100644 index 00000000000..04023ba8774 --- /dev/null +++ b/odbc/src/connection.cpp @@ -0,0 +1,398 @@ +#include "connection.h" +#include "statement.h" + +#include "utils/escape.h" + +#include +#include + +#include + +#include +#include + +#include "odbc_compat.h" + +namespace NYdb::NOdbc { + +void TConnection::DestroyYdbState() { + Tx_.reset(); + Ydb_.reset(); +} + +SQLRETURN TConnection::DriverConnect(std::string_view connectionString, + SQLCHAR* outConnectionString, + SQLSMALLINT bufferLength, + SQLSMALLINT* stringLength2Ptr) { + std::vector ignoredAttributes; + TConnectionParameters explicitParameters = + ParseAndNormalizeConnectionString(connectionString, ignoredAttributes); + const auto dsnIt = explicitParameters.find("DSN"); + TConnectionParameters parameters; + if (dsnIt != explicitParameters.end() && !dsnIt->second.empty()) { + parameters = ReadDsnParameters(dsnIt->second); + } + OverlayConnectionParameters(parameters, explicitParameters); + ApplyResolvedSettings(ResolveConnectionSettings(std::move(parameters))); + + const SQLRETURN outputResult = Diag::WriteOptionalOdbcString( + *this, connectionString, outConnectionString, bufferLength, stringLength2Ptr); + if (outputResult == SQL_ERROR) { + return outputResult; + } + + if (!ignoredAttributes.empty()) { + std::string message = ignoredAttributes.size() == 1 + ? "Invalid connection string attribute ignored: " + : "Invalid connection string attributes ignored: "; + for (size_t i = 0; i < ignoredAttributes.size(); ++i) { + if (i != 0) { + message += ", "; + } + message += ignoredAttributes[i]; + } + return AddError("01S00", 0, message, SQL_SUCCESS_WITH_INFO); + } + + return outputResult; +} + +SQLRETURN TConnection::Connect(std::string_view serverName, + std::string_view userName, + std::string_view auth) { + TConnectionParameters parameters = ReadDsnParameters(serverName); + if (!userName.empty() || !auth.empty()) { + for (const std::string_view key : { + "Token", "MetadataHost", "MetadataPort", "ServiceAccountKeyFile", + "OAuth2KeyFile", "IamEndpoint"}) { + parameters.erase(std::string(key)); + } + parameters["AuthMode"] = "Static"; + } + if (!userName.empty()) { + parameters["User"] = std::string(userName); + } + if (!auth.empty()) { + parameters["Password"] = std::string(auth); + } + ApplyResolvedSettings(ResolveConnectionSettings(std::move(parameters), std::string(serverName))); + + return SQL_SUCCESS; +} + +SQLRETURN TConnection::Disconnect() { + if (!IsConnected()) { + return AddError("08003", 0, "Connection not open"); + } + for (auto* child : GetChildren()) { + if (const auto* statement = dynamic_cast(child); statement && statement->NeedsData()) { + return AddError("HY010", 0, "Statement still needs parameter data"); + } + } + if (Tx_) { + return AddError("25000", 0, "Transaction must be committed or rolled back before disconnecting"); + } + // The exclusive lifecycle gate has drained all child calls. + for (auto* child : ReleaseChildren()) { + delete child; + } + DestroyYdbState(); + DriverConfig_.reset(); + DbmsVersionCache_.reset(); + Database_.clear(); + ServerName_.clear(); + DataSourceName_.clear(); + return SQL_SUCCESS; +} + +NQuery::TTransaction& TConnection::GetOrCreateTx(TStatement& statement) { + if (!Tx_) { + // Retry only transaction creation; never replay statements in an existing transaction. + auto status = Ydb_->QueryClient.RetryQuerySync([&](NQuery::TSession session) { + statement.CheckCancellation(); + auto result = session.BeginTransaction(MakeTxSettings()).ExtractValueSync(); + statement.CheckExecutionStatus(result); + if (result.IsSuccess()) { + Tx_.emplace(result.GetTransaction()); + } + return TStatus(result); + }); + NStatusHelpers::ThrowOnError(status); + } + return *Tx_; +} + +std::optional TConnection::GetClient() { + if (!Ydb_) { + return std::nullopt; + } + return Ydb_->QueryClient; +} + +std::optional TConnection::GetTableClient() { + if (!Ydb_) { + return std::nullopt; + } + return Ydb_->TableClient; +} + +std::optional TConnection::GetSchemeClient() { + if (!Ydb_) { + return std::nullopt; + } + return Ydb_->SchemeClient; +} + +SQLRETURN TConnection::Execute(TStatement& statement) { + // The caller holds the statement operation lock and a shared lifecycle gate. + std::unique_lock transaction(TransactionMutex_, std::defer_lock); + const bool explicitTransaction = !GetAutocommit(); + if (explicitTransaction) { + transaction.lock(); + } + return statement.ExecuteInternal(); +} + +void TConnection::EndTranFromEnvironment(SQLSMALLINT completionType) { + auto check = LockShared(); + if (GetAutocommit()) { + return; + } + check.unlock(); + auto lifecycle = LockExclusive(); + auto operation = LockOperation(); + if (GetAutocommit()) { + return; + } + if (completionType == SQL_COMMIT) { + CommitTx(); + } else { + RollbackTx(); + } +} + +void TConnection::CloseStatementCursors() { + // The exclusive lifecycle gate has drained statement/descriptor calls. + for (auto* child : GetChildren()) { + if (auto* stmt = dynamic_cast(child)) { + stmt->Close(true); + } + } +} + +void TConnection::InvalidatePreparedStatementMetadata() { + for (auto* child : GetChildren()) { + if (auto* stmt = dynamic_cast(child)) { + stmt->InvalidatePreparedColumnMeta(); + stmt->InvalidateInferredParamMetadata(); + } + } +} + +SQLRETURN TConnection::SetAutocommit(bool value) { + if (value) { + CommitTx(); + } + return Attributes_.SetAutocommit(value); +} + +bool TConnection::GetAutocommit() const { + return Attributes_.GetAutocommit(); +} + +SQLRETURN TConnection::SetConnectAttr(SQLINTEGER attr, SQLPOINTER value, SQLINTEGER stringLength) { + if (attr == SQL_ATTR_AUTOCOMMIT) { + const intptr_t token = ReadIntegerAttr(value); + if (token != SQL_AUTOCOMMIT_ON && token != SQL_AUTOCOMMIT_OFF) { + return Diag::AddInvalidAttrValue(*this, "SQL_ATTR_AUTOCOMMIT"); + } + return SetAutocommit(token == SQL_AUTOCOMMIT_ON); + } + if (attr == SQL_ATTR_CURRENT_CATALOG) { + std::optional rebindDatabase; + SQLRETURN rc = Attributes_.ApplyCatalogChange(value, stringLength, Database_, rebindDatabase, *this); + if (rc != SQL_SUCCESS) { + return rc; + } + InvalidatePreparedStatementMetadata(); + if (rebindDatabase) { + RebindToDatabase(*rebindDatabase); + } + return SQL_SUCCESS; + } + return Attributes_.SetConnectAttr(attr, value, *this); +} + +SQLRETURN TConnection::GetConnectAttr(SQLINTEGER attr, SQLPOINTER value, SQLINTEGER bufferLength, + SQLINTEGER* stringLengthPtr) { + return Attributes_.GetConnectAttr(attr, value, bufferLength, stringLengthPtr, *this); +} + +NQuery::TTxSettings TConnection::MakeTxSettings() const { + return Attributes_.MakeTxSettings(); +} + +const std::optional& TConnection::GetTx() { + return Tx_; +} + +SQLRETURN TConnection::EndTx(bool commit) { + if (!Tx_) { + return SQL_SUCCESS; + } + auto status = commit ? TStatus(Tx_->Commit().ExtractValueSync()) : Tx_->Rollback().ExtractValueSync(); + const bool missing = status.GetStatus() == EStatus::NOT_FOUND || status.GetStatus() == EStatus::BAD_SESSION + || status.GetStatus() == EStatus::SESSION_EXPIRED; + // Keep uncertain or still-active transactions available for rollback. + if (status.IsSuccess() || missing || status.GetStatus() == EStatus::ABORTED) { + Tx_.reset(); + CloseStatementCursors(); + } + if (missing) { + if (commit) { + throw TOdbcException("25S01", static_cast(status.GetStatus()), + "Transaction no longer exists: " + status.GetIssues().ToString()); + } + return SQL_SUCCESS; + } + NStatusHelpers::ThrowOnError(status); + return SQL_SUCCESS; +} + +const std::string& TConnection::GetDataSourceName() const { + return DataSourceName_; +} + +const std::string& TConnection::GetDatabaseName() const { + return Attributes_.GetCurrentCatalog(); +} + +const std::string& TConnection::GetServerName() const { + return ServerName_; +} + +SQLUINTEGER TConnection::GetSupportedTxnIsolationOptions() const { + return Attributes_.GetSupportedTxnIsolationOptions(); +} + +bool TConnection::IsDataSourceReadOnly() const { + return Attributes_.GetAccessMode() == SQL_MODE_READ_ONLY; +} + +const std::string& TConnection::GetDbmsVersion() { + if (DbmsVersionCache_) { + return *DbmsVersionCache_; + } + + auto client = GetClient(); + if (!client) { + throw TOdbcException("08003", 0, "Connection is not established"); + } + + std::optional fetched; + const NYdb::TStatus status = client->RetryQuerySync( + [&fetched](NQuery::TSession session) -> NYdb::TStatus { + auto result = session.ExecuteQuery( + "SELECT Version();", + NQuery::TTxControl::NoTx(), + NYdb::TParamsBuilder().Build()).ExtractValueSync(); + if (!result.IsSuccess()) { + // Version() is unavailable on YDB 24.1 and 24.2. SQL_DBMS_VER is + // mandatory metadata, so report an unknown version on those servers. + const auto issues = result.GetIssues().ToOneLineString(); + if (issues.find("Unknown builtin: Version") != std::string::npos) { + fetched = "00.00.0000"; + return NYdb::TStatus(EStatus::SUCCESS, NYdb::NIssue::TIssues()); + } + return result; + } + if (result.GetResultSets().empty()) { + return NYdb::TStatus(EStatus::SUCCESS, NYdb::NIssue::TIssues()); + } + TResultSetParser parser(result.GetResultSetParser(0)); + if (parser.TryNextRow()) { + fetched = parser.ColumnParser(0).GetString(); + } + return NYdb::TStatus(EStatus::SUCCESS, NYdb::NIssue::TIssues()); + }); + + NStatusHelpers::ThrowOnError(status); + if (!fetched || fetched->empty()) { + throw TOdbcException("HY000", 0, "Failed to retrieve DBMS version"); + } + + DbmsVersionCache_ = std::move(*fetched); + return *DbmsVersionCache_; +} + +void TConnection::RecreateYdbClients() { + if (!DriverConfig_) { + throw TOdbcException("08003", 0, "Connection configuration is not available"); + } + InvalidatePreparedStatementMetadata(); + CloseStatementCursors(); + DestroyYdbState(); + DbmsVersionCache_.reset(); + Ydb_.emplace(*DriverConfig_); +} + +void TConnection::ApplyResolvedSettings(TResolvedConnectionSettings&& settings) { + TConnectionAttributes::NormalizeCatalogPath(settings.Database); + settings.DriverConfig.SetDatabase(settings.Database); + + Database_ = std::move(settings.Database); + ServerName_ = std::move(settings.Endpoint); + DataSourceName_ = std::move(settings.DataSourceName); + AnsiSql_ = settings.AnsiSql; + DriverConfig_.emplace(std::move(settings.DriverConfig)); + RecreateYdbClients(); + Attributes_.SetCurrentCatalog(Database_); +} + +void TConnection::RebindToDatabase(std::string_view newDatabase) { + if (!DriverConfig_) { + throw TOdbcException("08003", 0, "Connection configuration is not available"); + } + std::string db(newDatabase); + TConnectionAttributes::NormalizeCatalogPath(db); + Database_ = std::move(db); + DriverConfig_->SetDatabase(Database_); + Attributes_.SetCurrentCatalog(Database_); + RecreateYdbClients(); +} + + +std::string TConnection::WrapQueryForCurrentCatalog(const std::string& sql) const { + std::optional rel = Attributes_.ResolveCatalogRoute(Database_).TablePathPrefix; + if (!rel) { + return AddSqlPreamble(sql, "PRAGMA AnsiImplicitCrossJoin;\nPRAGMA OrderedColumns;\n"); + } + std::string escapedPrefix; + escapedPrefix.reserve(rel->size() + 8); + for (const char ch : *rel) { + if (ch == '\\' || ch == '"') { + escapedPrefix.push_back('\\'); + } + escapedPrefix.push_back(ch); + } + return AddSqlPreamble(sql, "PRAGMA AnsiImplicitCrossJoin;\nPRAGMA OrderedColumns;\nPRAGMA TablePathPrefix = \"" + escapedPrefix + "\";\n"); +} + +TConnectionAttributes::TCatalogBinding TConnection::GetCatalogBinding() const { + return Attributes_.BuildCatalogBinding(Database_); +} + +std::string TConnection::PrepareSql(std::string sql) const { + constexpr std::string_view prefix = "--!ansi_lexer\nPRAGMA UnicodeLiterals;\n"; + if (AnsiSql_ && !sql.empty() && !sql.starts_with(prefix)) { + sql.insert(0, prefix); + } + return sql; +} + +SQLRETURN TConnection::NativeSql(const std::string& inSql, SQLCHAR* outSql, SQLINTEGER outMax, SQLINTEGER* outLen) { + const std::string nativeSql = RewriteOdbcEscapes(PrepareSql(inSql)); + return Diag::WriteOptionalOdbcString(*this, nativeSql, outSql, outMax, outLen); +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/connection.h b/odbc/src/connection.h new file mode 100644 index 00000000000..32f86c8c07d --- /dev/null +++ b/odbc/src/connection.h @@ -0,0 +1,116 @@ +#pragma once + +#include "connection_attr.h" +#include "connection_config.h" +#include "environment.h" + +#include +#include +#include +#include + +#include "odbc_compat.h" + +#include +#include +#include + +namespace NYdb::NOdbc { + +class TStatement; + +class TConnection : public THandle { +private: + std::shared_mutex Lifecycle_; // Shared by calls; exclusive for connection-state changes and child invalidation. + std::mutex TransactionMutex_; // Tx_; also protected by exclusive Lifecycle_. + struct TYdbState { + // Declared first: constructed before clients, destroyed after them. + TDriver Driver; + NQuery::TQueryClient QueryClient; + NScheme::TSchemeClient SchemeClient; + NTable::TTableClient TableClient; + + explicit TYdbState(const TDriverConfig& config) + : Driver(config) + , QueryClient(Driver) + , SchemeClient(Driver) + , TableClient(Driver) + {} + + ~TYdbState() { + Driver.Stop(true); + } + }; + + std::optional Ydb_; + std::optional DriverConfig_; + std::optional Tx_; + + std::string Database_; + std::string ServerName_; + std::string DataSourceName_; + bool AnsiSql_ = false; + + TConnectionAttributes Attributes_; + mutable std::optional DbmsVersionCache_; + + void DestroyYdbState(); + void ApplyResolvedSettings(TResolvedConnectionSettings&& settings); + void RecreateYdbClients(); + void RebindToDatabase(std::string_view newDatabase); + void InvalidatePreparedStatementMetadata(); + SQLRETURN EndTx(bool commit); +public: + explicit TConnection(TEnvironment* parent = nullptr) : THandle(parent) {} + TConnection& GetConnection() noexcept { return *this; } + template + auto LockShared(Args... args) { return std::shared_lock(Lifecycle_, args...); } + template + auto LockExclusive(Args... args) { return std::unique_lock(Lifecycle_, args...); } + + SQLRETURN Connect(std::string_view serverName, + std::string_view userName, + std::string_view auth); + + SQLRETURN DriverConnect(std::string_view connectionString, SQLCHAR* outConnectionString, + SQLSMALLINT bufferLength, SQLSMALLINT* stringLength2Ptr); + SQLRETURN Disconnect(); + bool IsConnected() const { return Ydb_.has_value(); } + + void CloseStatementCursors(); + // Test seam for holding transaction ordering without a server-side operation. + std::unique_lock LockTransaction() { return std::unique_lock(TransactionMutex_); } + SQLRETURN Execute(TStatement& statement); + void EndTranFromEnvironment(SQLSMALLINT completionType); + + std::optional GetClient(); + NQuery::TTransaction& GetOrCreateTx(TStatement& statement); + std::optional GetTableClient(); + std::optional GetSchemeClient(); + + SQLRETURN SetAutocommit(bool value); + bool GetAutocommit() const; + + SQLRETURN SetConnectAttr(SQLINTEGER attr, SQLPOINTER value, SQLINTEGER stringLength); + SQLRETURN GetConnectAttr(SQLINTEGER attr, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLengthPtr); + NQuery::TTxSettings MakeTxSettings() const; + + std::string WrapQueryForCurrentCatalog(const std::string& sql) const; + std::string PrepareSql(std::string sql) const; + TConnectionAttributes::TCatalogBinding GetCatalogBinding() const; + const std::string& GetDbmsVersion(); + const std::string& GetDatabaseName() const; + const std::string& GetServerName() const; + const std::string& GetDataSourceName() const; + SQLUINTEGER GetSupportedTxnIsolationOptions() const; + bool IsDataSourceReadOnly() const; + + const std::optional& GetTx(); + + SQLRETURN CommitTx() { return EndTx(true); } + SQLRETURN RollbackTx() { return EndTx(false); } + + SQLRETURN NativeSql(const std::string& inSql, SQLCHAR* outSql, SQLINTEGER outMax, SQLINTEGER* outLen); +}; + +} // namespace NYdb::NOdbc diff --git a/odbc/src/connection_attr.cpp b/odbc/src/connection_attr.cpp new file mode 100644 index 00000000000..444923489f0 --- /dev/null +++ b/odbc/src/connection_attr.cpp @@ -0,0 +1,206 @@ +#include "connection_attr.h" + +namespace NYdb::NOdbc { + +namespace { + +namespace Tx { + +bool IsKnownTxnIsolation(SQLUINTEGER txnIsolation) { + return txnIsolation == SQL_TXN_READ_UNCOMMITTED + || txnIsolation == SQL_TXN_READ_COMMITTED + || txnIsolation == SQL_TXN_REPEATABLE_READ + || txnIsolation == SQL_TXN_SERIALIZABLE; +} + +std::optional ResolveTxMode(SQLUINTEGER accessMode, SQLUINTEGER txnIsolation) { + if (accessMode == SQL_MODE_READ_ONLY) { + return NQuery::TTxSettings::TS_SNAPSHOT_RO; + } + + switch (txnIsolation) { + case SQL_TXN_REPEATABLE_READ: + return NQuery::TTxSettings::TS_SNAPSHOT_RW; + case SQL_TXN_SERIALIZABLE: + return NQuery::TTxSettings::TS_SERIALIZABLE_RW; + default: + return std::nullopt; + } +} + +} // namespace Tx + +} // namespace + +void TConnectionAttributes::NormalizeCatalogPath(std::string& path) { + if (path.empty() || path == "/") { + return; + } + const size_t end = path.find_last_not_of('/'); + if (end == std::string::npos) { + path = "/"; + } else { + path.erase(end + 1); + } +} + +SQLRETURN TConnectionAttributes::SetConnectAttr( + SQLINTEGER attr, + SQLPOINTER value, + TErrorManager& errors) { + switch (attr) { + case SQL_ATTR_ACCESS_MODE: + return SetAccessMode(value, errors); + case SQL_ATTR_TXN_ISOLATION: + return SetTxnIsolation(value, errors); + case SQL_ATTR_TRANSLATE_LIB: + if (!value) { + return Diag::AddNullPointer(errors); + } + return errors.AddError( + "HYC00", 0, "Translation libraries are not supported"); + default: + return TStoredProperties::Set(attr, *this, value) + ? SQL_SUCCESS + : Diag::AddNotImplemented(errors); + } +} + +SQLRETURN TConnectionAttributes::GetConnectAttr( + SQLINTEGER attr, + SQLPOINTER value, + SQLINTEGER bufferLength, + SQLINTEGER* stringLengthPtr, + TErrorManager& errors) const { + const bool stringAttribute = + attr == SQL_ATTR_CURRENT_CATALOG || attr == SQL_ATTR_TRANSLATE_LIB; + if (!value && (!stringAttribute || !stringLengthPtr)) { + return Diag::AddNullPointer(errors); + } + if (stringLengthPtr) { + *stringLengthPtr = 0; + } + if (attr == SQL_ATTR_AUTOCOMMIT) { + *static_cast(value) = Autocommit_ ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF; + return SQL_SUCCESS; + } + if (attr == SQL_ATTR_CURRENT_CATALOG) { + return Diag::WriteString( + &errors, CurrentCatalog_, value, bufferLength, stringLengthPtr); + } + if (attr == SQL_ATTR_TRANSLATE_LIB) { + return SQL_NO_DATA; + } + if (auto result = TStoredProperties::Get(attr, *this, value, stringLengthPtr)) { + return *result; + } + if (auto result = TReadOnlyProperties::Get(attr, *this, value)) { + return *result; + } + return Diag::AddNotImplemented(errors); +} + +SQLRETURN TConnectionAttributes::SetAccessMode(SQLPOINTER value, TErrorManager& errors) { + const SQLUINTEGER mode = ReadIntegerAttr(value); + if (mode != SQL_MODE_READ_WRITE && mode != SQL_MODE_READ_ONLY) { + return Diag::AddInvalidAttrValue(errors, "SQL_ATTR_ACCESS_MODE"); + } + auto txMode = Tx::ResolveTxMode(mode, TxnIsolation_); + if (!txMode) { + return errors.AddError( + "HYC00", + 0, + mode == SQL_MODE_READ_WRITE + ? "Transaction isolation is not supported for read-write mode" + : "Transaction isolation is not supported for read-only mode"); + } + AccessMode_ = mode; + return SQL_SUCCESS; +} + +SQLRETURN TConnectionAttributes::SetTxnIsolation(SQLPOINTER value, TErrorManager& errors) { + const SQLUINTEGER isolation = ReadIntegerAttr(value); + if (!Tx::IsKnownTxnIsolation(isolation)) { + return Diag::AddInvalidAttrValue(errors, "SQL_ATTR_TXN_ISOLATION"); + } + auto txMode = Tx::ResolveTxMode(AccessMode_, isolation); + if (!txMode) { + return errors.AddError("HYC00", 0, "SQL_ATTR_TXN_ISOLATION value is not supported"); + } + TxnIsolation_ = isolation; + return SQL_SUCCESS; +} + +SQLRETURN TConnectionAttributes::SetCurrentCatalog(SQLPOINTER value, SQLINTEGER stringLength, TErrorManager& errors) { + if (!value) { + return Diag::AddNullPointer(errors); + } + std::string catalog = ReadAttributeString(value, stringLength); + NormalizeCatalogPath(catalog); + if (catalog.empty()) { + return Diag::AddInvalidAttrValue(errors, "SQL_ATTR_CURRENT_CATALOG"); + } + CurrentCatalog_ = std::move(catalog); + return SQL_SUCCESS; +} + +SQLUINTEGER TConnectionAttributes::GetSupportedTxnIsolationOptions() const { + return AccessMode_ == SQL_MODE_READ_ONLY + ? SQL_TXN_READ_UNCOMMITTED | SQL_TXN_READ_COMMITTED + | SQL_TXN_REPEATABLE_READ | SQL_TXN_SERIALIZABLE + : SQL_TXN_REPEATABLE_READ | SQL_TXN_SERIALIZABLE; +} + +NQuery::TTxSettings TConnectionAttributes::MakeTxSettings() const { + const auto mode = Tx::ResolveTxMode(AccessMode_, TxnIsolation_); + if (mode == NQuery::TTxSettings::TS_SNAPSHOT_RO) { + return NQuery::TTxSettings::SnapshotRO(); + } + if (mode == NQuery::TTxSettings::TS_SNAPSHOT_RW) { + return NQuery::TTxSettings::SnapshotRW(); + } + return NQuery::TTxSettings::SerializableRW(); +} + +TConnectionAttributes::TCatalogBinding TConnectionAttributes::BuildCatalogBinding(const std::string& database) const { + TCatalogBinding binding{CurrentCatalog_, database, std::nullopt}; + NormalizeCatalogPath(binding.Catalog); + NormalizeCatalogPath(binding.Database); + const std::string prefix = binding.Database + "/"; + if (binding.Catalog.size() > prefix.size() + && binding.Catalog.compare(0, prefix.size(), prefix) == 0) { + binding.RelativeCatalog = binding.Catalog.substr(prefix.size()); + } + return binding; +} + +TConnectionAttributes::TCatalogRoute TConnectionAttributes::ResolveCatalogRoute( + const std::string& currentDatabase) const { + const TCatalogBinding binding = BuildCatalogBinding(currentDatabase); + if (binding.Catalog == binding.Database) { + return {binding.Database, std::nullopt}; + } + if (binding.RelativeCatalog) { + return {binding.Database, binding.Catalog}; + } + return {binding.Catalog, std::nullopt}; +} + +SQLRETURN TConnectionAttributes::ApplyCatalogChange( + SQLPOINTER value, + SQLINTEGER stringLength, + const std::string& currentDatabase, + std::optional& rebindDatabase, + TErrorManager& errors) { + SQLRETURN rc = SetCurrentCatalog(value, stringLength, errors); + if (rc != SQL_SUCCESS) { + return rc; + } + const TCatalogRoute route = ResolveCatalogRoute(currentDatabase); + rebindDatabase = route.EffectiveDatabase == currentDatabase + ? std::nullopt + : std::optional(route.EffectiveDatabase); + return SQL_SUCCESS; +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/connection_attr.h b/odbc/src/connection_attr.h new file mode 100644 index 00000000000..85726cf9360 --- /dev/null +++ b/odbc/src/connection_attr.h @@ -0,0 +1,82 @@ +#pragma once + +#include "utils/attr.h" + +#include + +#include +#include + +namespace NYdb::NOdbc { + +class TConnectionAttributes { +public: + struct TCatalogBinding { + std::string Catalog; + std::string Database; + std::optional RelativeCatalog; + }; + + struct TCatalogRoute { + std::string EffectiveDatabase; + std::optional TablePathPrefix; + }; + + SQLRETURN SetAutocommit(bool value) { + Autocommit_ = value; + return SQL_SUCCESS; + } + bool GetAutocommit() const { return Autocommit_; } + + SQLRETURN SetConnectAttr( + SQLINTEGER attr, + SQLPOINTER value, + TErrorManager& errors); + + SQLRETURN GetConnectAttr( + SQLINTEGER attr, + SQLPOINTER value, + SQLINTEGER bufferLength, + SQLINTEGER* stringLengthPtr, + TErrorManager& errors) const; + + NQuery::TTxSettings MakeTxSettings() const; + void SetCurrentCatalog(const std::string& value) { + CurrentCatalog_ = value; + NormalizeCatalogPath(CurrentCatalog_); + } + const std::string& GetCurrentCatalog() const { return CurrentCatalog_; } + TCatalogBinding BuildCatalogBinding(const std::string& database) const; + TCatalogRoute ResolveCatalogRoute(const std::string& currentDatabase) const; + SQLRETURN ApplyCatalogChange( + SQLPOINTER value, + SQLINTEGER stringLength, + const std::string& currentDatabase, + std::optional& rebindDatabase, + TErrorManager& errors); + static void NormalizeCatalogPath(std::string& path); + SQLUINTEGER GetSupportedTxnIsolationOptions() const; + SQLUINTEGER GetAccessMode() const { return AccessMode_; } + +private: + SQLRETURN SetAccessMode(SQLPOINTER value, TErrorManager& errors); + SQLRETURN SetTxnIsolation(SQLPOINTER value, TErrorManager& errors); + SQLRETURN SetCurrentCatalog(SQLPOINTER value, SQLINTEGER stringLength, TErrorManager& errors); + + bool Autocommit_ = true; + std::string CurrentCatalog_; + std::optional QuietMode_; + std::optional TranslateOption_; + SQLUINTEGER LoginTimeout_ = 0; + SQLUINTEGER AccessMode_ = SQL_MODE_READ_WRITE; + SQLUINTEGER TxnIsolation_ = SQL_TXN_SERIALIZABLE; + using TStoredProperties = TScalarProperties< + TScalarProperty, + TScalarProperty, + TScalarProperty>; + using TReadOnlyProperties = TScalarProperties< + TScalarProperty, + TScalarProperty>; +}; + +} // namespace NYdb::NOdbc diff --git a/odbc/src/connection_config.cpp b/odbc/src/connection_config.cpp new file mode 100644 index 00000000000..6245f1843b0 --- /dev/null +++ b/odbc/src/connection_config.cpp @@ -0,0 +1,384 @@ +#include "connection_config.h" + +#include "utils/error_manager.h" +#include "utils/util.h" + +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { +namespace { +enum class EAuthenticationMode : uint8_t { + Anonymous = 0, + Token = 1 << 0, + Static = 1 << 1, + Metadata = 1 << 2, + ServiceAccount = 1 << 3, + OAuth2 = 1 << 4, + Environment = 1 << 5, +}; +constexpr uint8_t AuthenticationFamilies = 0x1f; +constexpr uint8_t SelectsAuth = 1 << 7; +constexpr uint8_t IamAuthentication = + uint8_t(EAuthenticationMode::ServiceAccount) | uint8_t(EAuthenticationMode::OAuth2); +struct TConnectionKeySpec { + std::string_view Canonical; + std::string_view Alias; + uint8_t Authentication = 0; +}; +constexpr std::array ConnectionKeys = { + TConnectionKeySpec{"Driver"}, + TConnectionKeySpec{"Description"}, + TConnectionKeySpec{"DSN"}, + TConnectionKeySpec{"Endpoint", "Server"}, + TConnectionKeySpec{"Database"}, + TConnectionKeySpec{"AnsiSQL"}, + TConnectionKeySpec{"AuthMode"}, + TConnectionKeySpec{"Token", "AccessToken", uint8_t(EAuthenticationMode::Token) | SelectsAuth}, + TConnectionKeySpec{"User", "UID", uint8_t(EAuthenticationMode::Static) | SelectsAuth}, + TConnectionKeySpec{"Password", "PWD", uint8_t(EAuthenticationMode::Static) | SelectsAuth}, + TConnectionKeySpec{"MetadataHost", {}, uint8_t(EAuthenticationMode::Metadata) | SelectsAuth}, + TConnectionKeySpec{"MetadataPort", {}, uint8_t(EAuthenticationMode::Metadata) | SelectsAuth}, + TConnectionKeySpec{"ServiceAccountKeyFile", "SaFile", uint8_t(EAuthenticationMode::ServiceAccount) | SelectsAuth}, + TConnectionKeySpec{"OAuth2KeyFile", {}, uint8_t(EAuthenticationMode::OAuth2) | SelectsAuth}, + TConnectionKeySpec{"IamEndpoint", {}, IamAuthentication}, + TConnectionKeySpec{"RootCertificate", "CaFile"}, + TConnectionKeySpec{"ClientCertificate"}, + TConnectionKeySpec{"ClientPrivateKey"}, +}; +constexpr std::array AuthModes = { + std::pair{"Anonymous", EAuthenticationMode::Anonymous}, + std::pair{"Token", EAuthenticationMode::Token}, + std::pair{"Static", EAuthenticationMode::Static}, + std::pair{"Metadata", EAuthenticationMode::Metadata}, + std::pair{"ServiceAccount", EAuthenticationMode::ServiceAccount}, + std::pair{"OAuth2", EAuthenticationMode::OAuth2}, + std::pair{"Environment", EAuthenticationMode::Environment}, +}; + +bool EqualsIgnoreCase(std::string_view lhs, std::string_view rhs) { + return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin(), [](char lhs, char rhs) { + return std::tolower(static_cast(lhs)) == std::tolower(static_cast(rhs)); + }); +} +const TConnectionKeySpec* FindKey(std::string_view key) { + const auto it = std::find_if(ConnectionKeys.begin(), ConnectionKeys.end(), [key](const auto& spec) { + return EqualsIgnoreCase(key, spec.Canonical) || (!spec.Alias.empty() && EqualsIgnoreCase(key, spec.Alias)); + }); + return it == ConnectionKeys.end() ? nullptr : &*it; +} +[[noreturn]] void ThrowInvalidAttribute(std::string_view attribute, std::string_view detail) { + throw TOdbcException("HY024", 0, "Invalid connection string attribute " + + std::string(attribute) + ": " + std::string(detail)); +} +bool Has(const TConnectionParameters& parameters, std::string_view key) { + return parameters.contains(key); +} +std::string_view Get(const TConnectionParameters& parameters, std::string_view key) { + const auto it = parameters.find(key); + return it == parameters.end() ? std::string_view{} : std::string_view(it->second); +} + +uint8_t CredentialMask(const TConnectionParameters& parameters) { + uint8_t mask = 0; + for (const auto& key : ConnectionKeys) { + const uint8_t family = key.Authentication & AuthenticationFamilies; + if ((key.Authentication & SelectsAuth) + && Has(parameters, key.Canonical) + && (family != uint8_t(EAuthenticationMode::Static) + || !Get(parameters, key.Canonical).empty())) { + mask |= family; + } + } + return mask; +} + +std::string_view RequireNonEmpty( + const TConnectionParameters& parameters, std::string_view key, std::string_view authMode) { + const auto value = Get(parameters, key); + if (value.empty()) { + throw TOdbcException("28000", 0, std::string(authMode) + " authentication requires " + std::string(key)); + } + return value; +} + +std::string ReadDsnValue(std::string_view dsn, std::string_view key) { + const std::string dsnName(dsn); + const std::string attribute(key); + std::vector buffer(256); + while (buffer.size() <= 1024 * 1024) { + const int length = SQLGetPrivateProfileString( + dsnName.c_str(), attribute.c_str(), "", buffer.data(), static_cast(buffer.size()), nullptr); + if (length < 0) { + return {}; + } + if (static_cast(length) + 1 < buffer.size()) { + return std::string(buffer.data(), static_cast(length)); + } + buffer.resize(buffer.size() * 2); + } + throw TOdbcException("08001", 0, "DSN attribute is too large: " + attribute); +} + +std::string ReadFile(std::string_view attribute, std::string_view path) { + const std::string pathString(path); + std::ifstream input(pathString, std::ios::binary); + if (!input) { + throw TOdbcException("08001", 0, "Unable to read " + std::string(attribute) + " file: " + pathString); + } + std::string content(std::istreambuf_iterator(input), {}); + if (content.empty()) { + throw TOdbcException("08001", 0, std::string(attribute) + " file is empty: " + pathString); + } + return content; +} + +struct TEndpointSettings { + std::string Endpoint; + bool Secure = false; + bool ExplicitlyInsecure = false; +}; + +TEndpointSettings ParseEndpoint( + std::string_view value, + std::string_view attribute, + bool secureByDefault, + std::string_view protocolError = "only grpc:// and grpcs:// protocols are supported") { + constexpr std::string_view grpc = "grpc://"; + constexpr std::string_view grpcs = "grpcs://"; + if (value.starts_with(grpc)) { + return {std::string(value.substr(grpc.size())), false, true}; + } + if (value.starts_with(grpcs)) { + return {std::string(value.substr(grpcs.size())), true, false}; + } + if (value.find("://") != std::string::npos) { + ThrowInvalidAttribute(attribute, protocolError); + } + return {std::string(value), secureByDefault, false}; +} + +uint32_t ParseMetadataPort(std::string_view value) { + if (value.empty()) { + ThrowInvalidAttribute("MetadataPort", "value is empty"); + } + uint32_t port = 0; + const auto [end, error] = std::from_chars(value.data(), value.data() + value.size(), port); + if (error != std::errc() || end != value.data() + value.size() || port == 0 || port > 65535) { + ThrowInvalidAttribute("MetadataPort", "expected an integer from 1 to 65535"); + } + return port; +} +EAuthenticationMode ParseAuthMode(std::string_view value) { + for (const auto& [name, mode] : AuthModes) { + if (EqualsIgnoreCase(value, name)) { + return mode; + } + } + throw TOdbcException("28000", 0, "Unknown authentication mode: " + std::string(value)); +} + +EAuthenticationMode ResolveAuthMode(const TConnectionParameters& parameters) { + const uint8_t credentials = CredentialMask(parameters); + EAuthenticationMode mode; + if (Has(parameters, "AuthMode")) { + mode = ParseAuthMode(Get(parameters, "AuthMode")); + } else if (!credentials) { + if (Has(parameters, "IamEndpoint")) { + throw TOdbcException("28000", 0, "IamEndpoint requires ServiceAccount or OAuth2 authentication"); + } + mode = EAuthenticationMode::Anonymous; + } else if (credentials & (credentials - 1)) { + throw TOdbcException("28000", 0, "Authentication mode is ambiguous"); + } else { + mode = EAuthenticationMode(credentials); + } + + const uint8_t family = uint8_t(mode) & AuthenticationFamilies; + if (credentials != family && !(mode == EAuthenticationMode::Metadata && !credentials)) { + throw TOdbcException("28000", 0, "Credential attributes conflict with the selected authentication mode"); + } + if (Has(parameters, "IamEndpoint") && !(family & IamAuthentication)) { + throw TOdbcException("28000", 0, "IamEndpoint is valid only for ServiceAccount or OAuth2 authentication"); + } + return mode; +} +} // namespace + +TConnectionParameters ParseAndNormalizeConnectionString( + std::string_view connectionString, std::vector& ignoredAttributes) +{ + TConnectionParameters parameters; + for (const auto& [key, value] : ParseConnectionStringEntries(connectionString)) { + const auto* spec = FindKey(key); + if (!spec) { + ignoredAttributes.push_back(key); + continue; + } + parameters[std::string(spec->Canonical)] = value; + } + return parameters; +} + +TConnectionParameters ReadDsnParameters(std::string_view dsn) { + TConnectionParameters parameters; + for (const auto& spec : ConnectionKeys) { + for (const std::string_view key : {spec.Alias, spec.Canonical}) { // Canonical is read last and wins. + if (!key.empty()) { + if (std::string value = ReadDsnValue(dsn, key); !value.empty()) { + parameters[std::string(spec.Canonical)] = std::move(value); + } + } + } + } + return parameters; +} + +void OverlayConnectionParameters(TConnectionParameters& destination, const TConnectionParameters& source) { + const bool explicitMode = Has(source, "AuthMode"); + uint8_t family = explicitMode + ? uint8_t(ParseAuthMode(Get(source, "AuthMode"))) & AuthenticationFamilies + : CredentialMask(source); + const bool inferredMode = !explicitMode && family && !(family & (family - 1)); + if (inferredMode) { + destination.erase("AuthMode"); + } + if (explicitMode || inferredMode) { + for (const auto& key : ConnectionKeys) { + const uint8_t keyFamilies = key.Authentication & AuthenticationFamilies; + if (keyFamilies && !(keyFamilies & family)) { + destination.erase(std::string(key.Canonical)); + } + } + } + for (const auto& [key, value] : source) { + destination[key] = value; + } +} + +TResolvedConnectionSettings ResolveConnectionSettings(TConnectionParameters parameters, std::string dataSourceName) { + const auto ansiSql = Get(parameters, "AnsiSQL"); + if (!ansiSql.empty() && ansiSql != "0" && ansiSql != "1") { + ThrowInvalidAttribute("AnsiSQL", "expected 0 or 1"); + } + const std::string endpointValue(Get(parameters, "Endpoint")); + const std::string database(Get(parameters, "Database")); + if (endpointValue.empty() || database.empty()) { + throw TOdbcException("08001", 0, "Missing Endpoint (or Server) or Database"); + } + + const TEndpointSettings endpoint = ParseEndpoint(endpointValue, "Endpoint", false); + const bool hasRoot = Has(parameters, "RootCertificate"); + const bool hasClientCert = Has(parameters, "ClientCertificate"); + const bool hasClientKey = Has(parameters, "ClientPrivateKey"); + if (hasClientCert != hasClientKey) { + throw TOdbcException("08001", 0, + "ClientCertificate and ClientPrivateKey must be specified together"); + } + const bool hasTlsFiles = hasRoot || hasClientCert; + if (endpoint.ExplicitlyInsecure && hasTlsFiles) { + ThrowInvalidAttribute("Endpoint", "grpc:// cannot be combined with TLS certificate attributes"); + } + + const EAuthenticationMode authMode = ResolveAuthMode(parameters); + TDriverConfig driverConfig = authMode == EAuthenticationMode::Environment + ? CreateFromEnvironment() + : TDriverConfig(); + driverConfig.SetEndpoint(endpoint.Endpoint).SetDatabase(database); + + switch (authMode) { + case EAuthenticationMode::Anonymous: + driverConfig.SetCredentialsProviderFactory(CreateInsecureCredentialsProviderFactory()); + break; + case EAuthenticationMode::Token: + driverConfig.SetCredentialsProviderFactory(CreateOAuthCredentialsProviderFactory( + std::string(RequireNonEmpty(parameters, "Token", "Token")))); + break; + case EAuthenticationMode::Static: + driverConfig.SetCredentialsProviderFactory(CreateLoginCredentialsProviderFactory({ + .User = std::string(RequireNonEmpty(parameters, "User", "Static")), + .Password = std::string(RequireNonEmpty(parameters, "Password", "Static")), + })); + break; + case EAuthenticationMode::Metadata: { + TIamHost params; + if (Has(parameters, "MetadataHost")) { + params.Host = std::string(RequireNonEmpty(parameters, "MetadataHost", "Metadata")); + } + if (Has(parameters, "MetadataPort")) { + params.Port = ParseMetadataPort(Get(parameters, "MetadataPort")); + } + driverConfig.SetCredentialsProviderFactory(CreateIamCredentialsProviderFactory(params)); + break; + } + case EAuthenticationMode::ServiceAccount: { + TIamJwtFilename params; + params.JwtFilename = std::string(RequireNonEmpty(parameters, "ServiceAccountKeyFile", "ServiceAccount")); + if (const auto value = Get(parameters, "IamEndpoint"); !value.empty()) { + auto iamEndpoint = ParseEndpoint( + value, "IamEndpoint", true, + "service-account IAM supports grpc:// and grpcs://"); + params.Endpoint = std::move(iamEndpoint.Endpoint); + params.EnableSsl = iamEndpoint.Secure; + } + try { + driverConfig.SetCredentialsProviderFactory(CreateIamJwtFileCredentialsProviderFactory(params)); + } catch (const std::exception& ex) { + throw TOdbcException("08001", 0, + "Unable to load ServiceAccountKeyFile " + params.JwtFilename + ": " + ex.what()); + } + break; + } + case EAuthenticationMode::OAuth2: { + const std::string path(RequireNonEmpty(parameters, "OAuth2KeyFile", "OAuth2")); + try { + driverConfig.SetCredentialsProviderFactory( + CreateOauth2TokenExchangeFileCredentialsProviderFactory( + path, std::string(Get(parameters, "IamEndpoint")))); + } catch (const std::exception& ex) { + throw TOdbcException("08001", 0, + "Unable to load OAuth2KeyFile " + path + ": " + ex.what()); + } + break; + } + case EAuthenticationMode::Environment: + break; + } + + const std::string rootPem = hasRoot ? ReadFile("RootCertificate", Get(parameters, "RootCertificate")) : ""; + if (endpoint.Secure || hasTlsFiles) { + driverConfig.UseSecureConnection(rootPem); + } + if (hasClientCert) { + const std::string cert = ReadFile("ClientCertificate", Get(parameters, "ClientCertificate")); + const std::string key = ReadFile("ClientPrivateKey", Get(parameters, "ClientPrivateKey")); + driverConfig.UseClientCertificate(cert, key); + } + if (dataSourceName.empty()) { + dataSourceName = std::string(Get(parameters, "DSN")); + } + return { + .Endpoint = endpoint.Endpoint, + .Database = database, + .DataSourceName = std::move(dataSourceName), + .DriverConfig = std::move(driverConfig), + .AnsiSql = ansiSql == "1", + }; +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/connection_config.h b/odbc/src/connection_config.h new file mode 100644 index 00000000000..615cd8d00be --- /dev/null +++ b/odbc/src/connection_config.h @@ -0,0 +1,25 @@ +#pragma once + +#include + +#include +#include +#include +#include + +namespace NYdb::NOdbc { +using TConnectionParameters = std::map>; +struct TResolvedConnectionSettings { + std::string Endpoint; + std::string Database; + std::string DataSourceName; + TDriverConfig DriverConfig; + bool AnsiSql = false; +}; +TConnectionParameters ParseAndNormalizeConnectionString( + std::string_view connectionString, std::vector& ignoredAttributes); +TConnectionParameters ReadDsnParameters(std::string_view dsn); +void OverlayConnectionParameters(TConnectionParameters& destination, const TConnectionParameters& source); +TResolvedConnectionSettings ResolveConnectionSettings( + TConnectionParameters parameters, std::string dataSourceName = {}); +} // namespace NYdb::NOdbc diff --git a/odbc/src/descriptor.cpp b/odbc/src/descriptor.cpp new file mode 100644 index 00000000000..bdc5a76b8b0 --- /dev/null +++ b/odbc/src/descriptor.cpp @@ -0,0 +1,368 @@ +#include "descriptor.h" + +#include "connection.h" +#include "utils/diag.h" +#include "utils/sql_type_map.h" + +#include + +namespace NYdb::NOdbc { +namespace { + +SQLPOINTER Offset(SQLPOINTER pointer, SQLULEN offset, SQLULEN index, SQLULEN stride) { + return pointer + ? static_cast(pointer) + offset + index * stride + : nullptr; +} + +bool IsCharacter(SQLSMALLINT type) { + return type == SQL_CHAR || type == SQL_VARCHAR || type == SQL_LONGVARCHAR + || type == SQL_WCHAR || type == SQL_WVARCHAR || type == SQL_WLONGVARCHAR; +} + +SQLSMALLINT DateTimeCode(SQLSMALLINT type) { + switch (type) { + case SQL_TYPE_DATE: return SQL_CODE_DATE; + case SQL_TYPE_TIME: return SQL_CODE_TIME; + case SQL_TYPE_TIMESTAMP: return SQL_CODE_TIMESTAMP; + default: return 0; + } +} + +std::string TypeName(SQLSMALLINT type) { + const TSqlTypeSpec* spec = FindSqlTypeSpec(type); + return spec ? std::string(spec->Name) : type == SQL_GUID ? "GUID" : ""; +} + +template +SQLRETURN WriteScalar(SQLPOINTER value, T scalar) { + *static_cast(value) = scalar; + return SQL_SUCCESS; +} + +template +void WriteIf(T* output, U value) { + if (output) { + *output = static_cast(value); + } +} + +using TRecordProperties = TScalarProperties< + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty>; + +} // namespace + +TDescriptor::TDescriptor(TConnection* conn, EDescType type) + : THandle(conn) + , Type_(type) {} + +void TDescriptor::Snapshot(TDescriptorState& state, uint64_t& generation) const { + std::lock_guard lock(OperationMutex_); + SnapshotUnlocked(state, generation); +} + +void TDescriptor::SnapshotUnlocked(TDescriptorState& state, uint64_t& generation) const { + state = static_cast(*this); + generation = GetGeneration(); +} + +void TDescriptor::SnapshotHeader(TDescriptorState& state, uint64_t& generation) const { + std::lock_guard lock(OperationMutex_); + // The implementation row descriptor is consumed only for status outputs. + state.Header_ = Header_; + generation = GetGeneration(); +} + +void TDescriptor::Clear() { + std::lock_guard lock(OperationMutex_); + ClearRecords(); +} + +TDescRecord& TDescriptor::Record(SQLSMALLINT number) { + if (number < 1) { + throw TOdbcException("07009", 0, "Invalid descriptor index"); + } + if (Records_.size() < static_cast(number)) { + Records_.resize(static_cast(number)); + } + Changed(); + TDescRecord& record = Records_[static_cast(number - 1)]; + record.Active = true; + return record; +} + +const TDescRecord* TDescriptorState::FindRecord(SQLSMALLINT number) const noexcept { + if (number < 1 || static_cast(number) > Records_.size()) { + return nullptr; + } + const TDescRecord& record = Records_[static_cast(number - 1)]; + return record.Active ? &record : nullptr; +} + +void TDescriptor::RemoveRecord(SQLSMALLINT number) { + if (number > 0 && static_cast(number) <= Records_.size()) { + Records_[static_cast(number - 1)] = {}; + while (!Records_.empty() && !Records_.back().Active) { + Records_.pop_back(); + } + Changed(); + } +} + +SQLSMALLINT TDescriptorState::GetRecordCount() const noexcept { + return static_cast(Records_.size()); +} + +TResolvedBinding TDescriptorState::ResolveBinding( + const TDescRecord& record, SQLULEN index, bool useOffset) const noexcept { + const SQLULEN offset = useOffset && Header_.BindOffsetPtr ? *Header_.BindOffsetPtr : 0; + const SQLULEN dataStride = Header_.BindType == SQL_BIND_BY_COLUMN + ? GetCTypeSize(record.Type, record.OctetLength) : Header_.BindType; + const SQLULEN lengthStride = Header_.BindType == SQL_BIND_BY_COLUMN + ? sizeof(SQLLEN) : Header_.BindType; + return { + Offset(record.DataPtr, offset, index, dataStride), + static_cast(Offset(record.IndicatorPtr, offset, index, lengthStride)), + static_cast(Offset(record.OctetLengthPtr, offset, index, lengthStride)), + }; +} + +void TDescriptor::Changed(bool schema) { + if (schema) { + ++SchemaGeneration_; + } + Generation_.fetch_add(1, std::memory_order_relaxed); +} + +SQLRETURN TDescriptor::GetDescField(SQLSMALLINT recNumber, SQLSMALLINT field, SQLPOINTER value, + SQLINTEGER bufferLength, SQLINTEGER* lengthPtr) { + const bool stringField = field == SQL_DESC_BASE_COLUMN_NAME || field == SQL_DESC_NAME + || field == SQL_DESC_TYPE_NAME || field == SQL_DESC_LOCAL_TYPE_NAME + || field == SQL_DESC_LITERAL_PREFIX || field == SQL_DESC_LITERAL_SUFFIX; + if (!value && (!stringField || !lengthPtr)) { + return Diag::AddNullPointer(*this); + } + if (field == SQL_DESC_ALLOC_TYPE) { + return WriteScalar(value, static_cast( + Type_ == EDescType::Explicit ? SQL_DESC_ALLOC_USER : SQL_DESC_ALLOC_AUTO)); + } + if (field == SQL_DESC_COUNT) { + return WriteScalar(value, GetRecordCount()); + } + if (auto result = THeaderProperties::Get(field, Header_, value)) { + return *result; + } + + const TDescRecord* record = FindRecord(recNumber); + if (!record) { + return recNumber > GetRecordCount() + ? SQL_NO_DATA + : AddError("07009", 0, "Invalid descriptor index"); + } + if (auto result = TRecordProperties::Get(field, *record, value)) { + return *result; + } + switch (field) { + case SQL_DESC_DISPLAY_SIZE: + return WriteScalar(value, GetDisplaySize(record->Type, record->Length, record->Unsigned)); + case SQL_DESC_BASE_COLUMN_NAME: + case SQL_DESC_NAME: + return Diag::WriteString( + this, record->Name, value, bufferLength, lengthPtr); + case SQL_DESC_TYPE_NAME: + case SQL_DESC_LOCAL_TYPE_NAME: + return Diag::WriteString( + this, TypeName(record->Type), value, bufferLength, lengthPtr); + case SQL_DESC_LITERAL_PREFIX: + case SQL_DESC_LITERAL_SUFFIX: + return Diag::WriteString(this, + IsCharacter(record->Type) || DateTimeCode(record->Type) ? "'" : "", + value, bufferLength, lengthPtr); + case SQL_DESC_TYPE: + return WriteScalar(value, static_cast( + DateTimeCode(record->Type) ? SQL_DATETIME : record->Type)); + case SQL_DESC_DATETIME_INTERVAL_CODE: + return WriteScalar(value, DateTimeCode(record->Type)); + case SQL_DESC_CASE_SENSITIVE: + return WriteScalar(value, static_cast(IsCharacter(record->Type))); + case SQL_DESC_FIXED_PREC_SCALE: + return WriteScalar(value, static_cast( + record->Type == SQL_DECIMAL || record->Type == SQL_NUMERIC)); + case SQL_DESC_SEARCHABLE: + return WriteScalar(value, static_cast(SQL_SEARCHABLE)); + case SQL_DESC_UNNAMED: + return WriteScalar(value, static_cast( + record->Name.empty() ? SQL_UNNAMED : SQL_NAMED)); + case SQL_DESC_UNSIGNED: + return WriteScalar(value, static_cast(record->Unsigned ? SQL_TRUE : SQL_FALSE)); + case SQL_DESC_UPDATABLE: + return WriteScalar(value, static_cast(SQL_ATTR_READONLY)); + default: return Diag::AddNotImplemented(*this); + } +} + +SQLRETURN TDescriptor::GetDescRec(SQLSMALLINT recNumber, SQLCHAR* name, SQLSMALLINT bufferLength, + SQLSMALLINT* nameLengthPtr, SQLSMALLINT* typePtr, + SQLSMALLINT* subTypePtr, SQLLEN* lengthPtr, + SQLSMALLINT* precisionPtr, SQLSMALLINT* scalePtr, + SQLSMALLINT* nullablePtr) { + const TDescRecord* record = FindRecord(recNumber); + if (!record) { + return recNumber > GetRecordCount() + ? SQL_NO_DATA + : AddError("07009", 0, "Invalid descriptor index"); + } + SQLSMALLINT nameLength = 0; + SQLRETURN result = SQL_SUCCESS; + if (name) { + result = Diag::WriteString( + this, record->Name, name, bufferLength, &nameLength); + } else { + nameLength = static_cast(record->Name.size()); + } + WriteIf(nameLengthPtr, nameLength); + WriteIf(typePtr, DateTimeCode(record->Type) ? SQL_DATETIME : record->Type); + WriteIf(subTypePtr, DateTimeCode(record->Type)); + WriteIf(lengthPtr, record->Length); + WriteIf(precisionPtr, record->Precision); + WriteIf(scalePtr, record->Scale); + WriteIf(nullablePtr, record->Nullable); + return result; +} + +SQLRETURN TDescriptor::SetDescField(SQLSMALLINT recNumber, SQLSMALLINT field, SQLPOINTER value, + SQLINTEGER bufferLength) { + switch (field) { + case SQL_DESC_COUNT: { + const auto count = static_cast(reinterpret_cast(value)); + if (count < 0) { + return AddError("HY024", 0, "Invalid SQL_DESC_COUNT value"); + } + Records_.resize(static_cast(count)); + Changed(); + for (auto& record : Records_) { + record.Active = true; + } + return SQL_SUCCESS; + } + case SQL_DESC_ARRAY_SIZE: { + const auto size = static_cast(reinterpret_cast(value)); + if (size == 0) { + return AddError("HY024", 0, "Invalid SQL_DESC_ARRAY_SIZE value"); + } + Header_.ArraySize = size; + Changed(false); + return SQL_SUCCESS; + } + default: break; + } + if (THeaderProperties::Set(field, Header_, value)) { + Changed(false); + return SQL_SUCCESS; + } + + if (Type_ == EDescType::ImpRow) { + return AddError("HY016", 0, "Cannot modify an implementation row descriptor"); + } + + if (TRecordProperties::CanSet(field)) { + auto& record = Record(recNumber); + TRecordProperties::Set(field, record, value); + if (field == SQL_DESC_TYPE || field == SQL_DESC_CONCISE_TYPE) { + record.Inferred = false; + } + return SQL_SUCCESS; + } + if (field == SQL_DESC_NAME) { + if (!value) { + return Diag::AddNullPointer(*this); + } + if (bufferLength < 0 && bufferLength != SQL_NTS) { + return Diag::AddInvalidBufferLength(*this); + } + std::string name = bufferLength == SQL_NTS + ? std::string(static_cast(value)) + : std::string(static_cast(value), static_cast(bufferLength)); + Record(recNumber).Name = std::move(name); + return SQL_SUCCESS; + } + return Diag::AddNotImplemented(*this); +} + +SQLRETURN TDescriptor::SetDescRec(SQLSMALLINT recNumber, SQLSMALLINT type, SQLSMALLINT subType, + SQLLEN length, SQLSMALLINT precision, SQLSMALLINT scale, + SQLPOINTER dataPtr, SQLLEN* stringLengthPtr, + SQLLEN* indicatorPtr) { + if (Type_ == EDescType::ImpRow) { + return AddError("HY016", 0, "Cannot modify an implementation row descriptor"); + } + TDescRecord& record = Record(recNumber); + record.Type = type; + record.Inferred = false; + record.SubType = subType; + record.Length = length; + record.OctetLength = length; + record.Precision = precision; + record.Scale = scale; + record.DataPtr = dataPtr; + record.OctetLengthPtr = stringLengthPtr; + record.IndicatorPtr = indicatorPtr; + return SQL_SUCCESS; +} + +SQLRETURN TDescriptor::Copy(SQLHDESC source, SQLHDESC target) { + auto* src = CheckedHandle(source); + auto* dst = CheckedHandle(target); + if (!src || !dst) { + return SQL_INVALID_HANDLE; + } + auto sourceLifecycle = src->GetConnection().LockShared(std::defer_lock); + std::shared_lock targetLifecycle; + if (&dst->GetConnection() != &src->GetConnection()) { + targetLifecycle = dst->GetConnection().LockShared(std::defer_lock); + std::lock(sourceLifecycle, targetLifecycle); + } else { + sourceLifecycle.lock(); + } + std::unique_lock sourceLock(src->OperationMutex_, std::defer_lock); + std::unique_lock targetLock(dst->OperationMutex_, std::defer_lock); + if (src != dst) { + std::lock(sourceLock, targetLock); + } else { + sourceLock.lock(); + } + src->ClearErrors(); + try { + const auto result = src->CopyDesc(*dst); + src->SetLastReturnCode(result); + return result; + } catch (...) { + return RecordCurrentException(*src); + } +} + +SQLRETURN TDescriptor::CopyDesc(TDescriptor& target) { + if (target.Type_ == EDescType::ImpRow) { + return AddError("HY016", 0, "Cannot modify an implementation row descriptor"); + } + if (&target == this) return SQL_SUCCESS; + target.Changed(); + target.Header_ = Header_; + target.Records_ = Records_; + for (auto& record : target.Records_) { + record.Inferred = false; + } + return SQL_SUCCESS; +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/descriptor.h b/odbc/src/descriptor.h new file mode 100644 index 00000000000..96e5269a393 --- /dev/null +++ b/odbc/src/descriptor.h @@ -0,0 +1,146 @@ +#pragma once + +#include "utils/attr.h" +#include "utils/bindings.h" +#include "connection.h" + +#include "odbc_compat.h" + +#include +#include +#include + +namespace NYdb::NOdbc { + +class TStatement; + +enum class EDescType { + AppRow, + AppParam, + ImpRow, + ImpParam, + Explicit, +}; + +struct TDescRecord { + std::string Name; + SQLSMALLINT Type = SQL_UNKNOWN_TYPE; + SQLSMALLINT SubType = 0; + SQLLEN Length = 0; + SQLLEN OctetLength = 0; + SQLSMALLINT Precision = 0; + SQLSMALLINT Scale = 0; + SQLSMALLINT Nullable = SQL_NULLABLE; + bool Unsigned = false; + SQLPOINTER DataPtr = nullptr; + SQLLEN* IndicatorPtr = nullptr; + SQLLEN* OctetLengthPtr = nullptr; + SQLSMALLINT ParameterType = SQL_PARAM_INPUT; + bool Active = false; + bool Inferred = false; + std::optional WideTemporalType; +}; + +struct TResolvedBinding { + SQLPOINTER Data = nullptr; + SQLLEN* Indicator = nullptr; + SQLLEN* OctetLength = nullptr; + + bool IsDataAtExec() const noexcept { + return (!Indicator || *Indicator != SQL_NULL_DATA) && OctetLength + && (*OctetLength == SQL_DATA_AT_EXEC || *OctetLength <= SQL_LEN_DATA_AT_EXEC_OFFSET); + } +}; + +class TDescriptorState { + friend class TDescriptor; +protected: + struct THeader { + SQLULEN ArraySize = 1; + SQLULEN BindType = SQL_BIND_BY_COLUMN; + SQLULEN* BindOffsetPtr = nullptr; + SQLUSMALLINT* ArrayStatusPtr = nullptr; + SQLULEN* RowsProcessedPtr = nullptr; + }; + + THeader Header_; + std::vector Records_; + uint64_t SchemaGeneration_ = 0; + +public: + SQLULEN GetArraySize() const noexcept { return Header_.ArraySize; } + SQLUSMALLINT* GetArrayStatusPtr() const noexcept { return Header_.ArrayStatusPtr; } + SQLULEN* GetRowsProcessedPtr() const noexcept { return Header_.RowsProcessedPtr; } + uint64_t GetSchemaGeneration() const noexcept { return SchemaGeneration_; } + const TDescRecord* FindRecord(SQLSMALLINT number) const noexcept; + SQLSMALLINT GetRecordCount() const noexcept; + TResolvedBinding ResolveBinding(const TDescRecord& record, SQLULEN index, bool useOffset = true) const noexcept; +}; + +class TDescriptor : public THandle, private TDescriptorState { + using THeaderProperties = TScalarProperties< + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty>; + +public: + explicit TDescriptor(TConnection* conn, EDescType type = EDescType::Explicit); + + EDescType GetDescType() const noexcept { return Type_; } + TConnection& GetConnection() const noexcept { return static_cast(*GetParent()); } + + // Statement access locks this descriptor; binding snapshots are statement-owned. + void Clear(); + uint64_t GetGeneration() const { return Generation_.load(std::memory_order_relaxed); } + void Snapshot(TDescriptorState& state, uint64_t& generation) const; + void SnapshotHeader(TDescriptorState& state, uint64_t& generation) const; + + // ODBC entrypoints already hold the handle operation lock. + SQLRETURN GetDescField(SQLSMALLINT recNumber, SQLSMALLINT fieldIdentifier, SQLPOINTER value, + SQLINTEGER bufferLength, SQLINTEGER* stringLengthPtr); + SQLRETURN GetDescRec(SQLSMALLINT recNumber, SQLCHAR* name, SQLSMALLINT bufferLength, + SQLSMALLINT* stringLengthPtr, SQLSMALLINT* typePtr, SQLSMALLINT* subTypePtr, + SQLLEN* lengthPtr, SQLSMALLINT* precisionPtr, SQLSMALLINT* scalePtr, + SQLSMALLINT* nullablePtr); + SQLRETURN SetDescField(SQLSMALLINT recNumber, SQLSMALLINT fieldIdentifier, SQLPOINTER value, + SQLINTEGER bufferLength); + SQLRETURN SetDescRec(SQLSMALLINT recNumber, SQLSMALLINT type, SQLSMALLINT subType, SQLLEN length, + SQLSMALLINT precision, SQLSMALLINT scale, SQLPOINTER dataPtr, + SQLLEN* stringLengthPtr, SQLLEN* indicatorPtr); + static SQLRETURN Copy(SQLHDESC source, SQLHDESC target); + +private: + friend class TStatement; + + // Callbacks consume or mutate records within this scope; no references escape. + template + auto WithLock(Fn&& fn) { + std::lock_guard lock(OperationMutex_); + return std::forward(fn)(*this); + } + + template + auto WithLock(TDescriptor& other, Fn&& fn) { + std::scoped_lock lock(OperationMutex_, other.OperationMutex_); + return std::forward(fn)(*this, other); + } + + TDescRecord& Record(SQLSMALLINT number); + void RemoveRecord(SQLSMALLINT number); + void RemoveInferredRecord(SQLSMALLINT number) { + if (const auto* record = FindRecord(number); record && record->Inferred) { + RemoveRecord(number); + } + } + void ClearRecords() noexcept { Records_.clear(); Changed(); } + void SnapshotUnlocked(TDescriptorState& state, uint64_t& generation) const; + SQLRETURN CopyDesc(TDescriptor& target); + void Changed(bool schema = true); + + EDescType Type_; + std::atomic Generation_ = 1; +}; + +} // namespace NYdb::NOdbc diff --git a/odbc/src/environment.cpp b/odbc/src/environment.cpp new file mode 100644 index 00000000000..d85f8b84103 --- /dev/null +++ b/odbc/src/environment.cpp @@ -0,0 +1,89 @@ +#include "environment.h" +#include "connection.h" + + #include + +namespace NYdb { +namespace NOdbc { + +TEnvironment::TEnvironment() : OdbcVersion_(SQL_OV_ODBC3) {} +TEnvironment::~TEnvironment() {} + +SQLRETURN TEnvironment::SetAttribute(SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength) { + switch (attribute) { + case SQL_ATTR_ODBC_VERSION: { + if (!value) { + return AddError("HY009", 0, "Invalid use of null pointer"); + } + OdbcVersion_ = static_cast(reinterpret_cast(value)); + return SQL_SUCCESS; + } + case SQL_ATTR_OUTPUT_NTS: { + if (value && static_cast(reinterpret_cast(value)) != SQL_TRUE) { + return AddError("HY024", 0, "SQL_ATTR_OUTPUT_NTS must be SQL_TRUE"); + } + return SQL_SUCCESS; + } + default: + return AddError("HYC00", 0, "Optional feature not implemented"); + } +} + +SQLRETURN TEnvironment::GetAttribute(SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLengthPtr) { + if (!value) { + return AddError("HY009", 0, "Invalid use of null pointer"); + } + if (stringLengthPtr) { + *stringLengthPtr = 0; + } + switch (attribute) { + case SQL_ATTR_ODBC_VERSION: + if (bufferLength < static_cast(sizeof(SQLINTEGER))) { + return AddError("HY090", 0, "Invalid string or buffer length"); + } + *reinterpret_cast(value) = OdbcVersion_; + if (stringLengthPtr) { + *stringLengthPtr = sizeof(SQLINTEGER); + } + return SQL_SUCCESS; + case SQL_ATTR_OUTPUT_NTS: + if (bufferLength < static_cast(sizeof(SQLINTEGER))) { + return AddError("HY090", 0, "Invalid string or buffer length"); + } + *reinterpret_cast(value) = SQL_TRUE; + if (stringLengthPtr) { + *stringLengthPtr = sizeof(SQLINTEGER); + } + return SQL_SUCCESS; + default: + return AddError("HYC00", 0, "Optional feature not implemented"); + } +} + +SQLRETURN TEnvironment::EndTran(SQLSMALLINT completionType){ + if (completionType != SQL_COMMIT && completionType != SQL_ROLLBACK){ + return AddError("HY012", 0, "Invalid transaction operation code"); + } + int failedCount = 0; + + for (auto* child : GetChildren()) { + auto* conn = static_cast(child); + try { + conn->EndTranFromEnvironment(completionType); + } catch (const std::exception& ex) { + ++failedCount; + AddError("HY000", 0, ex.what()); + } catch (...) { + ++failedCount; + AddError("HY000", 0, "Unknown error during ENV-level transaction completion"); + } + } + if (failedCount != 0) { + AddError("HY000", 0, + "SQLEndTran(SQL_HANDLE_ENV): " + std::to_string(failedCount) + " connection(s) failed"); + return SQL_ERROR; + } + return SQL_SUCCESS; +} +} // namespace NOdbc +} // namespace NYdb diff --git a/odbc/src/environment.h b/odbc/src/environment.h new file mode 100644 index 00000000000..8cb6a192e75 --- /dev/null +++ b/odbc/src/environment.h @@ -0,0 +1,25 @@ +#pragma once + +#include "utils/handle.h" + +#include "odbc_compat.h" + +namespace NYdb { +namespace NOdbc { + +class TEnvironment : public THandle { +private: + SQLINTEGER OdbcVersion_; + +public: + TEnvironment(); + ~TEnvironment(); + + SQLRETURN SetAttribute(SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength); + SQLRETURN GetAttribute(SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLengthPtr); + + SQLRETURN EndTran(SQLSMALLINT completionType); +}; + +} // namespace NOdbc +} // namespace NYdb diff --git a/odbc/src/metadata.cpp b/odbc/src/metadata.cpp new file mode 100644 index 00000000000..29ff92fd233 --- /dev/null +++ b/odbc/src/metadata.cpp @@ -0,0 +1,353 @@ +#include "metadata.h" + +#include "utils/diag.h" +#include "utils/sql_type_map.h" + +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { +namespace { + +using TInfoValue = std::variant; + +struct TInfo { + SQLUSMALLINT Id; + TInfoValue Value; +}; + +constexpr TInfo S(SQLUSMALLINT id, std::string_view value) { + return {id, value}; +} + +constexpr TInfo U16(SQLUSMALLINT id, SQLUSMALLINT value) { + return {id, value}; +} + +constexpr TInfo I16(SQLUSMALLINT id, SQLSMALLINT value) { + return {id, value}; +} + +constexpr TInfo U32(SQLUSMALLINT id, SQLUINTEGER value) { + return {id, value}; +} + +constexpr SQLUSMALLINT kMaxTableColumns = 200; +constexpr SQLUSMALLINT kMaxIndexColumns = 20; + +constexpr TInfo kInfo[] = { + S(SQL_DRIVER_NAME, "ydb-odbc"), + S(SQL_DRIVER_VER, YDB_ODBC_DRIVER_VERSION), + S(SQL_DRIVER_ODBC_VER, "03.00"), + U32(SQL_ODBC_INTERFACE_CONFORMANCE, SQL_OIC_CORE), + U16(SQL_ODBC_API_CONFORMANCE, SQL_OAC_LEVEL1), + U16(SQL_ODBC_SAG_CLI_CONFORMANCE, SQL_OSCC_NOT_COMPLIANT), + I16(SQL_ODBC_SQL_CONFORMANCE, SQL_OSC_MINIMUM), + U16(SQL_MAX_TABLE_NAME_LEN, 255), + U16(SQL_MAX_COLUMN_NAME_LEN, 255), + U16(SQL_MAX_CATALOG_NAME_LEN, 255), + U16(SQL_MAX_IDENTIFIER_LEN, 255), + U16(SQL_MAX_SCHEMA_NAME_LEN, 0), + U16(SQL_MAX_PROCEDURE_NAME_LEN, 0), + U16(SQL_MAX_USER_NAME_LEN, 128), + U16(SQL_MAX_DRIVER_CONNECTIONS, 0), + U16(SQL_MAX_CONCURRENT_ACTIVITIES, 0), + U32(SQL_MAX_STATEMENT_LEN, 0), + U32(SQL_MAX_BINARY_LITERAL_LEN, 0), + U32(SQL_MAX_CHAR_LITERAL_LEN, 0), + U16(SQL_MAX_COLUMNS_IN_GROUP_BY, 0), + U16(SQL_MAX_COLUMNS_IN_ORDER_BY, 0), + U16(SQL_MAX_COLUMNS_IN_INDEX, kMaxIndexColumns), + U16(SQL_MAX_COLUMNS_IN_SELECT, 0), + U16(SQL_MAX_COLUMNS_IN_TABLE, kMaxTableColumns), + U16(SQL_MAX_TABLES_IN_SELECT, 0), + S(SQL_SEARCH_PATTERN_ESCAPE, "\\"), + S(SQL_KEYWORDS, ""), + S(SQL_SPECIAL_CHARACTERS, ""), + U16(SQL_CONCAT_NULL_BEHAVIOR, SQL_CB_NULL), + U16(SQL_NULL_COLLATION, SQL_NC_HIGH), + U16(SQL_MAX_CURSOR_NAME_LEN, 128), + S(SQL_DBMS_NAME, "YDB"), + S(SQL_USER_NAME, ""), + S(SQL_IDENTIFIER_QUOTE_CHAR, "`"), + U16(SQL_IDENTIFIER_CASE, SQL_IC_SENSITIVE), + S(SQL_CATALOG_NAME, "Y"), + S(SQL_CATALOG_NAME_SEPARATOR, "/"), + S(SQL_CATALOG_TERM, "path"), + U16(SQL_CATALOG_LOCATION, SQL_CL_START), + // YDB's database path scopes metadata and relative table names, but it is + // not a catalog qualifier in YQL data-manipulation statements. + U32(SQL_CATALOG_USAGE, 0), + U32(SQL_SCHEMA_USAGE, 0), + S(SQL_SCHEMA_TERM, ""), + U32(SQL_ALTER_TABLE, 0), + U16(SQL_GROUP_BY, SQL_GB_GROUP_BY_CONTAINS_SELECT), + U16(SQL_NON_NULLABLE_COLUMNS, SQL_NNC_NON_NULL), + S(SQL_MULT_RESULT_SETS, "Y"), + U32(SQL_DYNAMIC_CURSOR_ATTRIBUTES1, 0), + U32(SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1, SQL_CA1_NEXT), + U32(SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2, SQL_CA2_READ_ONLY_CONCURRENCY), + U32(SQL_STATIC_CURSOR_ATTRIBUTES1, + SQL_CA1_NEXT | SQL_CA1_ABSOLUTE | SQL_CA1_RELATIVE), + U32(SQL_STATIC_CURSOR_ATTRIBUTES2, + SQL_CA2_READ_ONLY_CONCURRENCY | SQL_CA2_MAX_ROWS_SELECT | SQL_CA2_MAX_ROWS_CATALOG), + U32(SQL_FETCH_DIRECTION, + SQL_FD_FETCH_NEXT | SQL_FD_FETCH_FIRST | SQL_FD_FETCH_LAST + | SQL_FD_FETCH_PRIOR | SQL_FD_FETCH_ABSOLUTE | SQL_FD_FETCH_RELATIVE), + U32(SQL_SCROLL_OPTIONS, SQL_SO_FORWARD_ONLY | SQL_SO_STATIC), + U32(SQL_SCROLL_CONCURRENCY, SQL_SCCO_READ_ONLY), + U32(SQL_CURSOR_SENSITIVITY, SQL_INSENSITIVE), + U16(SQL_CURSOR_COMMIT_BEHAVIOR, SQL_CB_CLOSE), + U16(SQL_CURSOR_ROLLBACK_BEHAVIOR, SQL_CB_CLOSE), + U16(SQL_TXN_CAPABLE, SQL_TC_DML), + U32(SQL_DEFAULT_TXN_ISOLATION, SQL_TXN_SERIALIZABLE), + S(SQL_PROCEDURES, "N"), + S(SQL_OUTER_JOINS, "Y"), + S(SQL_ORDER_BY_COLUMNS_IN_SELECT, "N"), + U32(SQL_POSITIONED_STATEMENTS, 0), + U32(SQL_BATCH_SUPPORT, SQL_BS_SELECT_EXPLICIT), + U32(SQL_BATCH_ROW_COUNT, 0), + U32(SQL_PARAM_ARRAY_ROW_COUNTS, SQL_PARC_NO_BATCH), + U32(SQL_PARAM_ARRAY_SELECTS, SQL_PAS_BATCH), + U32(SQL_BOOKMARK_PERSISTENCE, 0), + U16(SQL_FILE_USAGE, SQL_FILE_NOT_SUPPORTED), + U32(SQL_GETDATA_EXTENSIONS, SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER), + U32(SQL_CONVERT_CHAR, SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR + | SQL_CVT_WCHAR | SQL_CVT_WVARCHAR | SQL_CVT_WLONGVARCHAR), + U32(SQL_CONVERT_VARCHAR, SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR + | SQL_CVT_WCHAR | SQL_CVT_WVARCHAR | SQL_CVT_WLONGVARCHAR), + U32(SQL_CONVERT_LONGVARCHAR, SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR + | SQL_CVT_WCHAR | SQL_CVT_WVARCHAR | SQL_CVT_WLONGVARCHAR), + U32(SQL_ASYNC_MODE, SQL_AM_NONE), + U16(SQL_QUOTED_IDENTIFIER_CASE, SQL_IC_SENSITIVE), +}; + +struct TFunctionRange { + SQLUSMALLINT First; + SQLUSMALLINT Last; +}; + +constexpr TFunctionRange kSupportedFunctions[] = { + {SQL_API_SQLALLOCSTMT, SQL_API_SQLDISCONNECT}, + {SQL_API_SQLEXECDIRECT, SQL_API_SQLFETCH}, + {SQL_API_SQLFREESTMT, SQL_API_SQLSETCURSORNAME}, + {SQL_API_SQLCOLUMNS, SQL_API_SQLDRIVERCONNECT}, + {SQL_API_SQLGETDATA, SQL_API_SQLGETINFO}, + {SQL_API_SQLGETTYPEINFO, SQL_API_SQLPUTDATA}, + {SQL_API_SQLSPECIALCOLUMNS, SQL_API_SQLTABLES}, + {SQL_API_SQLDESCRIBEPARAM, SQL_API_SQLDESCRIBEPARAM}, + {SQL_API_SQLEXTENDEDFETCH, SQL_API_SQLNUMPARAMS}, + {SQL_API_SQLPRIMARYKEYS, SQL_API_SQLPRIMARYKEYS}, + {SQL_API_SQLCOLUMNPRIVILEGES, SQL_API_SQLCOLUMNPRIVILEGES}, + {SQL_API_SQLBINDPARAMETER, SQL_API_SQLBINDPARAMETER}, + {SQL_API_SQLALLOCHANDLE, SQL_API_SQLALLOCHANDLE}, + {SQL_API_SQLCLOSECURSOR, SQL_API_SQLGETENVATTR}, + {SQL_API_SQLGETSTMTATTR, SQL_API_SQLGETSTMTATTR}, + {SQL_API_SQLSETCONNECTATTR, SQL_API_SQLFETCHSCROLL}, +}; + +template +SQLRETURN WriteInfoScalar(TConnection* connection, T value, SQLPOINTER output, + SQLSMALLINT* length) { + if (!output) { + return connection->AddError("HY009", 0, "Invalid use of null pointer"); + } + *static_cast(output) = value; + if (length) { + *length = static_cast(sizeof(T)); + } + return SQL_SUCCESS; +} + +SQLRETURN WriteInfo(TConnection* connection, const TInfoValue& value, SQLPOINTER output, + SQLSMALLINT bufferLength, SQLSMALLINT* length) { + return std::visit( + [&](auto item) -> SQLRETURN { + using T = decltype(item); + if constexpr (std::is_same_v) { + return Diag::WriteOdbcString(*connection, item, output, bufferLength, length); + } else { + return WriteInfoScalar(connection, item, output, length); + } + }, + value); +} + +bool IsSupportedFunction(SQLUSMALLINT id) { + return std::ranges::any_of(kSupportedFunctions, [id](const auto& range) { + return id >= range.First && id <= range.Last; + }); +} + +const TColumnMeta& GetColumn(TStatement* statement, SQLUSMALLINT number) { + const auto& columns = statement->GetColumnMeta(); + if (number < 1 || number > columns.size()) { + throw TOdbcException("07009", 0, "Invalid descriptor index"); + } + return columns[number - 1]; +} + +SQLRETURN WriteAttributeNumber(TStatement* statement, SQLLEN value, SQLLEN* output) { + if (!output) { + return statement->AddError("HY009", 0, "Invalid use of null pointer"); + } + *output = value; + return SQL_SUCCESS; +} + +} // namespace + +SQLRETURN NMetadata::GetInfo(TConnection* connection, SQLUSMALLINT infoType, + SQLPOINTER infoValuePtr, SQLSMALLINT bufferLength, + SQLSMALLINT* stringLengthPtr) { + switch (infoType) { + case SQL_DBMS_VER: + return Diag::WriteOdbcString( + *connection, connection->GetDbmsVersion(), infoValuePtr, bufferLength, stringLengthPtr); + case SQL_DATA_SOURCE_READ_ONLY: + return Diag::WriteOdbcString(*connection, connection->IsDataSourceReadOnly() ? "Y" : "N", + infoValuePtr, bufferLength, stringLengthPtr); + case SQL_DATA_SOURCE_NAME: + return Diag::WriteOdbcString(*connection, connection->GetDataSourceName(), + infoValuePtr, bufferLength, stringLengthPtr); + case SQL_DATABASE_NAME: + return Diag::WriteOdbcString(*connection, connection->GetDatabaseName(), + infoValuePtr, bufferLength, stringLengthPtr); + case SQL_SERVER_NAME: + return Diag::WriteOdbcString(*connection, connection->GetServerName(), + infoValuePtr, bufferLength, stringLengthPtr); + case SQL_TXN_ISOLATION_OPTION: + return WriteInfoScalar(connection, connection->GetSupportedTxnIsolationOptions(), + infoValuePtr, stringLengthPtr); + default: + break; + } + const auto info = std::ranges::find(kInfo, infoType, &TInfo::Id); + if (info == std::end(kInfo)) { + return connection->AddError("HYC00", 0, "Optional feature not implemented"); + } + return WriteInfo(connection, info->Value, infoValuePtr, bufferLength, stringLengthPtr); +} + +SQLRETURN NMetadata::GetFunctions(SQLUSMALLINT functionId, SQLUSMALLINT* supportedPtr) { + if (!supportedPtr) { + return SQL_ERROR; + } + if (functionId == SQL_API_ALL_FUNCTIONS) { + std::memset(supportedPtr, 0, 100 * sizeof(SQLUSMALLINT)); + for (SQLUSMALLINT id = 0; id < 100; ++id) { + if (IsSupportedFunction(id)) { + supportedPtr[id] = SQL_TRUE; + } + } + } else if (functionId == SQL_API_ODBC3_ALL_FUNCTIONS) { + std::memset(supportedPtr, 0, SQL_API_ODBC3_ALL_FUNCTIONS_SIZE * sizeof(SQLUSMALLINT)); + for (SQLUSMALLINT id = 0; id < SQL_API_ODBC3_ALL_FUNCTIONS_SIZE * 16; ++id) { + if (IsSupportedFunction(id)) { + supportedPtr[id >> 4] |= (1 << (id & 0x000F)); + } + } + } else { + *supportedPtr = IsSupportedFunction(functionId) ? SQL_TRUE : SQL_FALSE; + } + return SQL_SUCCESS; +} + +SQLRETURN NMetadata::DescribeCol(TStatement* statement, SQLUSMALLINT columnNumber, + SQLCHAR* columnName, SQLSMALLINT bufferLength, + SQLSMALLINT* nameLengthPtr, SQLSMALLINT* dataTypePtr, + SQLULEN* columnSizePtr, SQLSMALLINT* decimalDigitsPtr, + SQLSMALLINT* nullablePtr) { + const auto& column = GetColumn(statement, columnNumber); + const SQLRETURN result = Diag::WriteOdbcString( + *statement, column.Name, columnName, bufferLength, nameLengthPtr); + if (result != SQL_SUCCESS) { + return result; + } + if (dataTypePtr) { + *dataTypePtr = column.SqlType; + } + if (columnSizePtr) { + *columnSizePtr = column.Size; + } + if (decimalDigitsPtr) { + *decimalDigitsPtr = column.DecimalDigits; + } + if (nullablePtr) { + *nullablePtr = column.Nullable; + } + return SQL_SUCCESS; +} + +SQLRETURN NMetadata::ColAttribute(TStatement* statement, SQLUSMALLINT columnNumber, + SQLUSMALLINT fieldIdentifier, SQLPOINTER characterAttributePtr, + SQLSMALLINT bufferLength, SQLSMALLINT* stringLengthAttributePtr, + SQLLEN* numericAttributePtr) { + const auto& column = GetColumn(statement, columnNumber); + switch (fieldIdentifier) { + case SQL_DESC_NAME: + case SQL_COLUMN_NAME: + case SQL_DESC_LABEL: + return Diag::WriteString( + statement, column.Name, characterAttributePtr, bufferLength, + stringLengthAttributePtr); + case SQL_DESC_BASE_COLUMN_NAME: + case SQL_DESC_BASE_TABLE_NAME: + case SQL_DESC_CATALOG_NAME: + case SQL_DESC_SCHEMA_NAME: + case SQL_DESC_TABLE_NAME: + return Diag::WriteString( + statement, "", characterAttributePtr, bufferLength, + stringLengthAttributePtr); + case SQL_DESC_TYPE_NAME: { + const TSqlTypeSpec* spec = FindSqlTypeSpec(column.SqlType); + return Diag::WriteString( + statement, spec ? spec->Name : "UNKNOWN", characterAttributePtr, + bufferLength, stringLengthAttributePtr); + } + case SQL_DESC_TYPE: + case SQL_DESC_CONCISE_TYPE: + return WriteAttributeNumber(statement, column.SqlType, numericAttributePtr); + case SQL_DESC_LENGTH: + case SQL_DESC_OCTET_LENGTH: + case SQL_COLUMN_LENGTH: + case SQL_DESC_PRECISION: + case SQL_COLUMN_PRECISION: + return WriteAttributeNumber(statement, static_cast(column.Size), numericAttributePtr); + case SQL_DESC_DISPLAY_SIZE: + return WriteAttributeNumber(statement, + GetDisplaySize(column.SqlType, column.Size, column.Unsigned), numericAttributePtr); + case SQL_DESC_SCALE: + case SQL_COLUMN_SCALE: + return WriteAttributeNumber(statement, column.DecimalDigits, numericAttributePtr); + case SQL_DESC_NULLABLE: + case SQL_COLUMN_NULLABLE: + return WriteAttributeNumber(statement, column.Nullable, numericAttributePtr); + case SQL_DESC_UNSIGNED: + return WriteAttributeNumber(statement, column.Unsigned ? SQL_TRUE : SQL_FALSE, + numericAttributePtr); + case SQL_DESC_AUTO_UNIQUE_VALUE: + return WriteAttributeNumber(statement, SQL_FALSE, numericAttributePtr); + case SQL_DESC_CASE_SENSITIVE: + return WriteAttributeNumber(statement, + column.SqlType == SQL_CHAR || column.SqlType == SQL_VARCHAR + || column.SqlType == SQL_LONGVARCHAR || column.SqlType == SQL_WCHAR + || column.SqlType == SQL_WVARCHAR || column.SqlType == SQL_WLONGVARCHAR, + numericAttributePtr); + case SQL_DESC_FIXED_PREC_SCALE: + return WriteAttributeNumber(statement, + column.SqlType == SQL_DECIMAL || column.SqlType == SQL_NUMERIC, + numericAttributePtr); + case SQL_DESC_SEARCHABLE: + return WriteAttributeNumber(statement, SQL_PRED_SEARCHABLE, numericAttributePtr); + case SQL_DESC_UPDATABLE: + return WriteAttributeNumber(statement, SQL_ATTR_READONLY, numericAttributePtr); + default: + return statement->AddError("HYC00", 0, "Optional feature not implemented"); + } +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/metadata.h b/odbc/src/metadata.h new file mode 100644 index 00000000000..d5187c39aae --- /dev/null +++ b/odbc/src/metadata.h @@ -0,0 +1,22 @@ +#pragma once + +#include "statement.h" + +namespace NYdb::NOdbc::NMetadata { + +SQLRETURN GetInfo(TConnection* connection, SQLUSMALLINT infoType, SQLPOINTER infoValuePtr, + SQLSMALLINT bufferLength, SQLSMALLINT* stringLengthPtr); + +SQLRETURN GetFunctions(SQLUSMALLINT functionId, SQLUSMALLINT* supportedPtr); + +SQLRETURN DescribeCol(TStatement* statement, SQLUSMALLINT columnNumber, SQLCHAR* columnName, + SQLSMALLINT bufferLength, SQLSMALLINT* nameLengthPtr, + SQLSMALLINT* dataTypePtr, SQLULEN* columnSizePtr, + SQLSMALLINT* decimalDigitsPtr, SQLSMALLINT* nullablePtr); + +SQLRETURN ColAttribute(TStatement* statement, SQLUSMALLINT columnNumber, + SQLUSMALLINT fieldIdentifier, SQLPOINTER characterAttributePtr, + SQLSMALLINT bufferLength, SQLSMALLINT* stringLengthAttributePtr, + SQLLEN* numericAttributePtr); + +} // namespace NYdb::NOdbc::NMetadata diff --git a/odbc/src/odbc_compat.h b/odbc/src/odbc_compat.h new file mode 100644 index 00000000000..0191b138e16 --- /dev/null +++ b/odbc/src/odbc_compat.h @@ -0,0 +1,10 @@ +#pragma once + +#include +#include + +// iODBC exposes this generic macro from its public headers. It collides with +// SDK identifiers included by the driver after the ODBC headers. +#ifdef EXPORT +#undef EXPORT +#endif diff --git a/odbc/src/odbc_driver.cpp b/odbc/src/odbc_driver.cpp new file mode 100644 index 00000000000..cb9bad5f33d --- /dev/null +++ b/odbc/src/odbc_driver.cpp @@ -0,0 +1,535 @@ +#include "environment.h" +#include "connection.h" +#include "statement.h" +#include "metadata.h" +#include "descriptor.h" + +#include "utils/util.h" +#include "utils/error_manager.h" + +#include "odbc_compat.h" + +#include +#include + +namespace { + namespace Odbc = NYdb::NOdbc; + using Odbc::TConnection; + using Odbc::TDescriptor; + using Odbc::TEnvironment; + using Odbc::TStatement; + + template + SQLRETURN Call(SQLHANDLE handle, Fn&& fn) { + return Odbc::CallOdbc(handle, std::forward(fn)); + } + + template + struct TLazyText { + Char* Value; + SQLINTEGER Length; + auto Resolve() const { + if constexpr (PreserveNull) { + return Value ? std::optional{Odbc::GetString(Value, Length)} : std::nullopt; + } else { + return Odbc::GetString(Value, Length); + } + } + }; + + template + decltype(auto) Resolve(T& value) { + if constexpr (requires { value.Resolve(); }) { + return value.Resolve(); + } else { + return (value); + } + } + + template + TLazyText Text(Char* value, SQLINTEGER length) { + return {value, length}; + } + + template + TLazyText OptionalText(Char* value, SQLINTEGER length) { + return {value, length}; + } + + template + SQLRETURN Forward(SQLHANDLE handle, Args&&... args) { + return Call(handle, [&](Handle* value) { + return Odbc::InvokeOdbc(Method, value, Resolve(args)...); + }); + } + + template + SQLRETURN Prepare(SQLHSTMT handle, Char* sql, SQLINTEGER length) { + return Call(handle, [&](auto* statement) { + const SQLRETURN result = statement->Prepare(Odbc::GetString(sql, length)); + return Execute && result == SQL_SUCCESS ? statement->Execute() : result; + }); + } + + template + SQLRETURN Free(SQLHANDLE handle) { + // Destruction must follow release of the handle's operation lock. + std::unique_ptr consumed; + return Call || std::is_same_v>(handle, [&](Handle* value) { + if constexpr (std::is_same_v) { + if (value->HasChildren()) { + return value->AddError("HY010", 0, "Connection handles are still allocated"); + } + } else if constexpr (std::is_same_v) { + if (value->IsConnected()) { + return value->AddError("HY010", 0, "Connection must be disconnected before freeing"); + } + if (value->HasChildren()) { + return value->AddError("HY010", 0, "Statement or descriptor handles are still allocated"); + } + } else if constexpr (std::is_same_v) { + if (value->GetDescType() != Odbc::EDescType::Explicit) { + return value->AddError("HY017", 0, "Invalid use of an automatically allocated descriptor handle"); + } + for (auto* child : value->GetConnection().GetChildren()) { + if (auto* statement = dynamic_cast(child)) { + statement->ResetDescriptor(*value); + } + } + } else if constexpr (std::is_same_v) { + if (value->NeedsData()) { + return value->AddError("HY010", 0, "Statement still needs parameter data"); + } + } + if (auto* parent = value->GetParent()) { + parent->RemoveChild(value); + } + consumed.reset(value); + return static_cast(SQL_SUCCESS); + }); + } + + template + SQLRETURN Allocate(SQLHANDLE parentHandle, SQLHANDLE* output) { + if constexpr (std::is_same_v) { + if (!output) { + return SQL_ERROR; + } + try { + *output = static_cast(new TEnvironment()); + return SQL_SUCCESS; + } catch (...) { + return SQL_ERROR; + } + } else { + using Parent = std::conditional_t, TEnvironment, TConnection>; + return Call(parentHandle, [&](Parent* parent) -> SQLRETURN { + if (!output) { + return parent->AddError("HY009", 0, "Output handle pointer is null"); + } + if constexpr (std::is_same_v) { + if (!parent->IsConnected()) { + return parent->AddError("08003", 0, "Connection not open"); + } + } + auto value = std::make_unique(parent); + parent->AddChild(value.get()); + *output = static_cast(value.release()); + return SQL_SUCCESS; + }); + } + } + + template + SQLRETURN VisitHandle(SQLSMALLINT type, SQLHANDLE handle, Fn&& fn) { + switch (type) { + case SQL_HANDLE_ENV: return Call(handle, fn); + case SQL_HANDLE_DBC: return Call(handle, fn); + case SQL_HANDLE_STMT: return Call(handle, fn); + case SQL_HANDLE_DESC: return Call(handle, fn); + default: return SQL_ERROR; + } + } + +} + +extern "C" { + +#define ODBC_FORWARD(NAME, HANDLE, METHOD, SIGNATURE, ARGUMENTS) \ + SQLRETURN SQL_API NAME SIGNATURE { \ + return Forward ARGUMENTS; \ + } + +#define ODBC_EXCLUSIVE(NAME, HANDLE, METHOD, SIGNATURE, ARGUMENTS) \ + SQLRETURN SQL_API NAME SIGNATURE { \ + return Forward ARGUMENTS; \ + } + +#define ODBC_PREPARE(NAME, CHAR, EXECUTE) \ + SQLRETURN SQL_API NAME( \ + SQLHSTMT statementHandle, CHAR* statementText, SQLINTEGER textLength) { \ + return Prepare(statementHandle, statementText, textLength); \ + } + +SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT handleType, + SQLHANDLE inputHandle, + SQLHANDLE* outputHandle) { + if (outputHandle) { + *outputHandle = SQL_NULL_HANDLE; + } + + switch (handleType) { + case SQL_HANDLE_ENV: return Allocate(inputHandle, outputHandle); + case SQL_HANDLE_DBC: return Allocate(inputHandle, outputHandle); + case SQL_HANDLE_STMT: return Allocate(inputHandle, outputHandle); + case SQL_HANDLE_DESC: return Allocate(inputHandle, outputHandle); + default: return SQL_ERROR; + } +} + +SQLRETURN SQL_API SQLAllocStmt(SQLHDBC connectionHandle, SQLHSTMT* statementHandle) { + if (statementHandle) { + *statementHandle = SQL_NULL_HSTMT; + } + return Allocate(connectionHandle, statementHandle); +} + +SQLRETURN SQL_API SQLFreeHandle(SQLSMALLINT handleType, SQLHANDLE handle) { + switch (handleType) { + case SQL_HANDLE_ENV: return Free(handle); + case SQL_HANDLE_DBC: return Free(handle); + case SQL_HANDLE_STMT: return Free(handle); + case SQL_HANDLE_DESC: return Free(handle); + default: return SQL_INVALID_HANDLE; + } +} + +SQLRETURN SQL_API SQLSetEnvAttr(SQLHENV environmentHandle, + SQLINTEGER attribute, + SQLPOINTER value, + SQLINTEGER stringLength) { + return Call(environmentHandle, [&](auto* env) { + return env->SetAttribute(attribute, value, stringLength); + }); +} + +SQLRETURN SQL_API SQLGetEnvAttr(SQLHENV environmentHandle, + SQLINTEGER attribute, + SQLPOINTER value, + SQLINTEGER bufferLength, + SQLINTEGER* stringLengthPtr) { + return Call(environmentHandle, [&](auto* env) { + return env->GetAttribute( + attribute, value, bufferLength, stringLengthPtr); + }); +} + +ODBC_EXCLUSIVE(SQLDriverConnect, TConnection, TConnection::DriverConnect, + (SQLHDBC connectionHandle, SQLHWND, SQLCHAR* inConnectionString, + SQLSMALLINT stringLength1, SQLCHAR* outConnectionString, SQLSMALLINT bufferLength, + SQLSMALLINT* stringLength2Ptr, SQLUSMALLINT), + (connectionHandle, Text(inConnectionString, stringLength1), outConnectionString, + bufferLength, stringLength2Ptr)) + +ODBC_EXCLUSIVE(SQLConnect, TConnection, TConnection::Connect, + (SQLHDBC connectionHandle, SQLCHAR* serverName, SQLSMALLINT nameLength1, + SQLCHAR* userName, SQLSMALLINT nameLength2, + SQLCHAR* authentication, SQLSMALLINT nameLength3), + (connectionHandle, Text(serverName, nameLength1), Text(userName, nameLength2), + Text(authentication, nameLength3))) + +ODBC_EXCLUSIVE(SQLDisconnect, TConnection, TConnection::Disconnect, + (SQLHDBC connectionHandle), (connectionHandle)) + +ODBC_PREPARE(SQLExecDirect, SQLCHAR, true) +ODBC_PREPARE(SQLExecDirectW, SQLWCHAR, true) +ODBC_PREPARE(SQLPrepare, SQLCHAR, false) +ODBC_PREPARE(SQLPrepareW, SQLWCHAR, false) + +ODBC_FORWARD(SQLExecute, TStatement, TStatement::Execute, + (SQLHSTMT statementHandle), (statementHandle)) +ODBC_FORWARD(SQLFetch, TStatement, TStatement::Fetch, + (SQLHSTMT statementHandle), (statementHandle)) + +ODBC_FORWARD(SQLGetData, TStatement, TStatement::GetData, + (SQLHSTMT statementHandle, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, + SQLPOINTER targetValue, SQLLEN bufferLength, SQLLEN* strLenOrInd), + (statementHandle, columnNumber, targetType, targetValue, bufferLength, strLenOrInd)) + +ODBC_FORWARD(SQLBindCol, TStatement, TStatement::BindCol, + (SQLHSTMT statementHandle, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, + SQLPOINTER targetValue, SQLLEN bufferLength, SQLLEN* strLenOrInd), + (statementHandle, columnNumber, targetType, targetValue, bufferLength, strLenOrInd)) + +SQLRETURN SQL_API SQLGetDiagRec(SQLSMALLINT handleType, + SQLHANDLE handle, + SQLSMALLINT recNumber, + SQLCHAR* sqlState, + SQLINTEGER* nativeError, + SQLCHAR* messageText, + SQLSMALLINT bufferLength, + SQLSMALLINT* textLength) { + return VisitHandle(handleType, handle, [&](auto* typed) { + return typed->GetDiagRec( + recNumber, sqlState, nativeError, messageText, bufferLength, textLength); + }); +} + +SQLRETURN SQL_API SQLGetDiagField(SQLSMALLINT handleType, + SQLHANDLE handle, + SQLSMALLINT recNumber, + SQLSMALLINT diagIdentifier, + SQLPOINTER diagInfoPtr, + SQLSMALLINT bufferLength, + SQLSMALLINT* stringLengthPtr) { + return VisitHandle(handleType, handle, [&](auto* typed) { + return typed->GetDiagField( + recNumber, diagIdentifier, diagInfoPtr, bufferLength, stringLengthPtr); + }); +} + +ODBC_FORWARD(SQLBindParameter, TStatement, TStatement::BindParameter, + (SQLHSTMT statementHandle, SQLUSMALLINT paramNumber, SQLSMALLINT inputOutputType, + SQLSMALLINT valueType, SQLSMALLINT parameterType, SQLULEN columnSize, + SQLSMALLINT decimalDigits, SQLPOINTER parameterValuePtr, SQLLEN bufferLength, + SQLLEN* strLenOrIndPtr), + (statementHandle, paramNumber, inputOutputType, valueType, parameterType, columnSize, + decimalDigits, parameterValuePtr, bufferLength, strLenOrIndPtr)) + +SQLRETURN SQL_API SQLEndTran(SQLSMALLINT handleType, SQLHANDLE handle, SQLSMALLINT completionType) { + if (handleType == SQL_HANDLE_ENV) { + return Forward(handle, completionType); + } + if (handleType == SQL_HANDLE_DBC) { + const auto preflight = Call(handle, [&](auto* connection) { + if (completionType != SQL_COMMIT && completionType != SQL_ROLLBACK) { + throw Odbc::TOdbcException("HY012", 0, "Invalid transaction operation code"); + } + return connection->GetAutocommit() ? SQL_SUCCESS : SQL_NO_DATA; + }); + if (preflight != SQL_NO_DATA) { + return preflight; + } + return Call(handle, [&](auto* connection) { + if (completionType == SQL_COMMIT) { + return connection->CommitTx(); + } + return connection->RollbackTx(); + }); + } + return SQL_INVALID_HANDLE; +} + +ODBC_EXCLUSIVE(SQLSetConnectAttr, TConnection, TConnection::SetConnectAttr, + (SQLHDBC connectionHandle, SQLINTEGER attribute, SQLPOINTER value, + SQLINTEGER stringLength), + (connectionHandle, attribute, value, stringLength)) + +ODBC_FORWARD(SQLGetConnectAttr, TConnection, TConnection::GetConnectAttr, + (SQLHDBC connectionHandle, SQLINTEGER attribute, SQLPOINTER value, + SQLINTEGER bufferLength, SQLINTEGER* stringLengthPtr), + (connectionHandle, attribute, value, bufferLength, stringLengthPtr)) + +ODBC_FORWARD(SQLColumns, TStatement, TStatement::Columns, + (SQLHSTMT statementHandle, SQLCHAR* catalogName, SQLSMALLINT nameLength1, + SQLCHAR* schemaName, SQLSMALLINT nameLength2, SQLCHAR* tableName, + SQLSMALLINT nameLength3, SQLCHAR* columnName, SQLSMALLINT nameLength4), + (statementHandle, OptionalText(catalogName, nameLength1), OptionalText(schemaName, nameLength2), + OptionalText(tableName, nameLength3), OptionalText(columnName, nameLength4))) + +ODBC_FORWARD(SQLTables, TStatement, TStatement::Tables, + (SQLHSTMT statementHandle, SQLCHAR* catalogName, SQLSMALLINT nameLength1, + SQLCHAR* schemaName, SQLSMALLINT nameLength2, SQLCHAR* tableName, + SQLSMALLINT nameLength3, SQLCHAR* tableType, SQLSMALLINT nameLength4), + (statementHandle, OptionalText(catalogName, nameLength1), OptionalText(schemaName, nameLength2), + OptionalText(tableName, nameLength3), OptionalText(tableType, nameLength4))) + +ODBC_FORWARD(SQLCloseCursor, TStatement, TStatement::Close, + (SQLHSTMT statementHandle), (statementHandle, false)) + +SQLRETURN SQL_API SQLFreeStmt(SQLHSTMT statementHandle, SQLUSMALLINT option) { + if (option == SQL_DROP) { + return SQLFreeHandle(SQL_HANDLE_STMT, statementHandle); + } + return Call(statementHandle, [&](auto* stmt) -> SQLRETURN { + switch (option) { + case SQL_CLOSE: + return stmt->Close(true); + case SQL_UNBIND: + stmt->UnbindColumns(); + return SQL_SUCCESS; + case SQL_RESET_PARAMS: + stmt->ResetParams(); + return SQL_SUCCESS; + default: + throw NYdb::NOdbc::TOdbcException("HY000", 0, "Invalid option"); + } + }); +} + +SQLRETURN SQL_API SQLFetchScroll(SQLHSTMT statementHandle, SQLSMALLINT fetchOrientation, SQLLEN fetchOffset) { + return Forward( + statementHandle, fetchOrientation, fetchOffset); +} + +ODBC_FORWARD(SQLExtendedFetch, TStatement, TStatement::ExtendedFetch, + (SQLHSTMT statementHandle, SQLUSMALLINT fetchOrientation, SQLLEN fetchOffset, + SQLULEN* rowCount, SQLUSMALLINT* rowStatus), + (statementHandle, fetchOrientation, fetchOffset, rowCount, rowStatus)) + +ODBC_FORWARD(SQLRowCount, TStatement, TStatement::RowCount, + (SQLHSTMT statementHandle, SQLLEN* rowCount), (statementHandle, rowCount)) + +ODBC_FORWARD(SQLNumResultCols, TStatement, TStatement::NumResultCols, + (SQLHSTMT statementHandle, SQLSMALLINT* colCount), (statementHandle, colCount)) + +ODBC_FORWARD(SQLDescribeCol, TStatement, Odbc::NMetadata::DescribeCol, + (SQLHSTMT statementHandle, SQLUSMALLINT columnNumber, SQLCHAR* columnName, + SQLSMALLINT bufferLength, SQLSMALLINT* nameLengthPtr, SQLSMALLINT* dataTypePtr, + SQLULEN* columnSizePtr, SQLSMALLINT* decimalDigitsPtr, SQLSMALLINT* nullablePtr), + (statementHandle, columnNumber, columnName, bufferLength, nameLengthPtr, dataTypePtr, + columnSizePtr, decimalDigitsPtr, nullablePtr)) + +ODBC_FORWARD(SQLMoreResults, TStatement, TStatement::MoreResults, + (SQLHSTMT statementHandle), (statementHandle)) + +SQLRETURN SQL_API SQLGetFunctions(SQLHDBC connectionHandle, SQLUSMALLINT functionId, SQLUSMALLINT* supportedPtr) { + return Call(connectionHandle, [&](auto*) { + return NYdb::NOdbc::NMetadata::GetFunctions(functionId, supportedPtr); + }); +} + +ODBC_FORWARD(SQLSetStmtAttr, TStatement, TStatement::SetStmtAttr, + (SQLHSTMT statementHandle, SQLINTEGER attribute, SQLPOINTER value, + SQLINTEGER stringLength), + (statementHandle, attribute, value, stringLength)) + +ODBC_FORWARD(SQLGetStmtAttr, TStatement, TStatement::GetStmtAttr, + (SQLHSTMT statementHandle, SQLINTEGER attribute, SQLPOINTER value, + SQLINTEGER bufferLength, SQLINTEGER* stringLengthPtr), + (statementHandle, attribute, value, bufferLength, stringLengthPtr)) + +ODBC_FORWARD(SQLGetInfo, TConnection, Odbc::NMetadata::GetInfo, + (SQLHDBC connectionHandle, SQLUSMALLINT infoType, SQLPOINTER infoValuePtr, + SQLSMALLINT bufferLength, SQLSMALLINT* stringLengthPtr), + (connectionHandle, infoType, infoValuePtr, bufferLength, stringLengthPtr)) + +ODBC_FORWARD(SQLGetTypeInfo, TStatement, TStatement::GetTypeInfo, + (SQLHSTMT statementHandle, SQLSMALLINT dataType), (statementHandle, dataType)) + +ODBC_FORWARD(SQLStatistics, TStatement, TStatement::Statistics, + (SQLHSTMT statementHandle, SQLCHAR* catalogName, SQLSMALLINT nameLength1, + SQLCHAR* schemaName, SQLSMALLINT nameLength2, SQLCHAR* tableName, + SQLSMALLINT nameLength3, SQLUSMALLINT unique, SQLUSMALLINT reserved), + (statementHandle, OptionalText(catalogName, nameLength1), OptionalText(schemaName, nameLength2), + OptionalText(tableName, nameLength3), unique, reserved)) + +ODBC_FORWARD(SQLSpecialColumns, TStatement, TStatement::SpecialColumns, + (SQLHSTMT statementHandle, SQLUSMALLINT identifierType, SQLCHAR* catalogName, + SQLSMALLINT nameLength1, SQLCHAR* schemaName, SQLSMALLINT nameLength2, + SQLCHAR* tableName, SQLSMALLINT nameLength3, SQLUSMALLINT scope, SQLUSMALLINT nullable), + (statementHandle, OptionalText(catalogName, nameLength1), OptionalText(schemaName, nameLength2), + OptionalText(tableName, nameLength3), identifierType, scope, nullable)) + +ODBC_FORWARD(SQLColAttribute, TStatement, Odbc::NMetadata::ColAttribute, + (SQLHSTMT statementHandle, SQLUSMALLINT columnNumber, SQLUSMALLINT fieldIdentifier, + SQLPOINTER characterAttributePtr, SQLSMALLINT bufferLength, + SQLSMALLINT* stringLengthAttributePtr, SQLLEN* numericAttributePtr), + (statementHandle, columnNumber, fieldIdentifier, characterAttributePtr, bufferLength, + stringLengthAttributePtr, numericAttributePtr)) + +ODBC_FORWARD(SQLNumParams, TStatement, TStatement::NumParams, + (SQLHSTMT statementHandle, SQLSMALLINT* paramCountPtr), + (statementHandle, paramCountPtr)) + +ODBC_FORWARD(SQLDescribeParam, TStatement, TStatement::DescribeParam, + (SQLHSTMT statementHandle, SQLUSMALLINT paramNumber, SQLSMALLINT* dataTypePtr, + SQLULEN* paramSizePtr, SQLSMALLINT* decimalDigitsPtr, SQLSMALLINT* nullablePtr), + (statementHandle, paramNumber, dataTypePtr, paramSizePtr, decimalDigitsPtr, nullablePtr)) + +ODBC_FORWARD(SQLParamData, TStatement, TStatement::ParamData, + (SQLHSTMT statementHandle, SQLPOINTER* valuePtr), (statementHandle, valuePtr)) +ODBC_FORWARD(SQLPutData, TStatement, TStatement::PutData, + (SQLHSTMT statementHandle, SQLPOINTER data, SQLLEN strLenOrInd), + (statementHandle, data, strLenOrInd)) +SQLRETURN SQL_API SQLCancel(SQLHSTMT statementHandle) { + auto* stmt = Odbc::CheckedHandle(statementHandle); + return stmt ? stmt->Cancel() : SQL_INVALID_HANDLE; +} + +ODBC_FORWARD(SQLNativeSql, TConnection, TConnection::NativeSql, + (SQLHDBC connectionHandle, SQLCHAR* inNativeSql, SQLINTEGER textLength1, + SQLCHAR* outNativeSql, SQLINTEGER bufferLength, SQLINTEGER* outLengthPtr), + (connectionHandle, Text(inNativeSql, textLength1), + outNativeSql, bufferLength, outLengthPtr)) + +ODBC_FORWARD(SQLSetCursorName, TStatement, TStatement::SetCursorName, + (SQLHSTMT statementHandle, SQLCHAR* cursorName, SQLSMALLINT nameLength), + (statementHandle, Text(cursorName, nameLength))) + +ODBC_FORWARD(SQLGetCursorName, TStatement, TStatement::GetCursorName, + (SQLHSTMT statementHandle, SQLCHAR* cursorName, SQLSMALLINT bufferLength, + SQLSMALLINT* nameLengthPtr), + (statementHandle, cursorName, bufferLength, nameLengthPtr)) + +ODBC_FORWARD(SQLPrimaryKeys, TStatement, TStatement::PrimaryKeys, + (SQLHSTMT statementHandle, SQLCHAR* catalogName, SQLSMALLINT nameLength1, + SQLCHAR* schemaName, SQLSMALLINT nameLength2, + SQLCHAR* tableName, SQLSMALLINT nameLength3), + (statementHandle, OptionalText(catalogName, nameLength1), OptionalText(schemaName, nameLength2), + OptionalText(tableName, nameLength3))) + +ODBC_FORWARD(SQLForeignKeys, TStatement, TStatement::ForeignKeys, + (SQLHSTMT statementHandle, SQLCHAR* pkCatalogName, SQLSMALLINT nameLength1, + SQLCHAR* pkSchemaName, SQLSMALLINT nameLength2, + SQLCHAR* pkTableName, SQLSMALLINT nameLength3, + SQLCHAR* fkCatalogName, SQLSMALLINT nameLength4, + SQLCHAR* fkSchemaName, SQLSMALLINT nameLength5, + SQLCHAR* fkTableName, SQLSMALLINT nameLength6), + (statementHandle, Text(pkCatalogName, nameLength1), Text(pkSchemaName, nameLength2), + Text(pkTableName, nameLength3), Text(fkCatalogName, nameLength4), + Text(fkSchemaName, nameLength5), Text(fkTableName, nameLength6))) + +ODBC_FORWARD(SQLColumnPrivileges, TStatement, TStatement::ColumnPrivileges, + (SQLHSTMT statementHandle, SQLCHAR* catalogName, SQLSMALLINT nameLength1, + SQLCHAR* schemaName, SQLSMALLINT nameLength2, + SQLCHAR* tableName, SQLSMALLINT nameLength3, + SQLCHAR* columnName, SQLSMALLINT nameLength4), + (statementHandle, Text(catalogName, nameLength1), Text(schemaName, nameLength2), + Text(tableName, nameLength3), Text(columnName, nameLength4))) + +ODBC_FORWARD(SQLGetDescField, TDescriptor, TDescriptor::GetDescField, + (SQLHDESC descriptorHandle, SQLSMALLINT recNumber, SQLSMALLINT fieldIdentifier, + SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLengthPtr), + (descriptorHandle, recNumber, fieldIdentifier, value, bufferLength, stringLengthPtr)) + +ODBC_FORWARD(SQLGetDescRec, TDescriptor, TDescriptor::GetDescRec, + (SQLHDESC descriptorHandle, SQLSMALLINT recNumber, SQLCHAR* name, + SQLSMALLINT bufferLength, SQLSMALLINT* stringLengthPtr, SQLSMALLINT* typePtr, + SQLSMALLINT* subTypePtr, SQLLEN* lengthPtr, SQLSMALLINT* precisionPtr, + SQLSMALLINT* scalePtr, SQLSMALLINT* nullablePtr), + (descriptorHandle, recNumber, name, bufferLength, stringLengthPtr, typePtr, subTypePtr, + lengthPtr, precisionPtr, scalePtr, nullablePtr)) + +ODBC_FORWARD(SQLSetDescField, TDescriptor, TDescriptor::SetDescField, + (SQLHDESC descriptorHandle, SQLSMALLINT recNumber, SQLSMALLINT fieldIdentifier, + SQLPOINTER value, SQLINTEGER bufferLength), + (descriptorHandle, recNumber, fieldIdentifier, value, bufferLength)) + +ODBC_FORWARD(SQLSetDescRec, TDescriptor, TDescriptor::SetDescRec, + (SQLHDESC descriptorHandle, SQLSMALLINT recNumber, SQLSMALLINT type, + SQLSMALLINT subType, SQLLEN length, SQLSMALLINT precision, SQLSMALLINT scale, + SQLPOINTER dataPtr, SQLLEN* stringLengthPtr, SQLLEN* indicatorPtr), + (descriptorHandle, recNumber, type, subType, length, precision, scale, dataPtr, + stringLengthPtr, indicatorPtr)) + +SQLRETURN SQL_API SQLCopyDesc(SQLHDESC sourceDesc, SQLHDESC targetDesc) { + return TDescriptor::Copy(sourceDesc, targetDesc); +} + +#undef ODBC_PREPARE +#undef ODBC_FORWARD +#undef ODBC_EXCLUSIVE + +} diff --git a/odbc/src/statement.cpp b/odbc/src/statement.cpp new file mode 100644 index 00000000000..e5c63e3630a --- /dev/null +++ b/odbc/src/statement.cpp @@ -0,0 +1,1496 @@ +#include "statement.h" + +#include "utils/convert.h" +#include "utils/attr.h" +#include "utils/diag.h" +#include "utils/param_rewrite.h" +#include "utils/status_util.h" + +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { + +namespace { + + std::optional ExtractAffectedRows(const NQuery::TExecuteQueryResult& result) { + const auto& stats = result.GetStats(); + if (!stats) { + return std::nullopt; + } + + const uint64_t maxSqlLen = static_cast(std::numeric_limits::max()); + std::optional affectedRows; + const auto phases = stats->GetQueryPhases(); + const auto tables = phases | std::views::transform(&NQuery::TQueryPhaseStats::GetTableAccess) + | std::views::join; + // An optimized no-op has an execution phase without any table accesses. + // Deferred writes have no execution phases and retain an unknown count. + if (!phases.empty() && std::ranges::empty(tables)) { + affectedRows = 0; + } + for (const auto& table : tables) { + // User tables are schema leaves; descendants are internal index tables. + if (std::ranges::any_of(tables, [&](const auto& parent) { + const std::string_view name = table.GetName(), prefix = parent.GetName(); + return !prefix.empty() && name.size() > prefix.size() + && name.starts_with(prefix) && name[prefix.size()] == '/'; + })) { + continue; + } + const auto rows = table.GetAffectedRows(); + if (!rows) { + continue; + } + if (*rows > maxSqlLen - affectedRows.value_or(0)) { + return std::nullopt; + } + affectedRows = affectedRows.value_or(0) + *rows; + } + if (affectedRows == 0 && !result.GetResultSets().empty()) { + return std::nullopt; + } + return affectedRows; + } + + std::string BuildResultMetadataQuery(std::string_view query) { + query = TrimTrailingSqlTrivia(query); + std::string_view statement = GetSqlStatement(query); + const std::string_view prologue = query.substr(0, query.size() - statement.size()); + if (!statement.empty() && statement.back() == ';') { + statement.remove_suffix(1); + statement = TrimTrailingSqlTrivia(statement); + } + return std::string(prologue) + "SELECT * FROM (\n" + std::string(statement) + + "\n) AS __ydb_odbc_result_metadata LIMIT 0"; + } + +} + +TStatement::TStatement(TConnection* conn) + : THandle(conn) + , AppRowDesc_(conn, EDescType::AppRow) + , AppParamDesc_(conn, EDescType::AppParam) + , ImpRowDesc_(conn, EDescType::ImpRow) + , ImpParamDesc_(conn, EDescType::ImpParam) {} + +void TStatement::ResetDescriptor(TDescriptor& descriptor) { + if (AppRowDescPtr_ == &descriptor) { + SetAppDescriptor(SQL_ATTR_APP_ROW_DESC, nullptr); + } + if (AppParamDescPtr_ == &descriptor) { + SetAppDescriptor(SQL_ATTR_APP_PARAM_DESC, nullptr); + } +} + +void TStatement::SetAppDescriptor(SQLINTEGER attr, TDescriptor* descriptor) { + auto& current = attr == SQL_ATTR_APP_ROW_DESC ? AppRowDescPtr_ : AppParamDescPtr_; + if (current != descriptor) { + current = descriptor; + if (attr == SQL_ATTR_APP_ROW_DESC) { + RowGeneration_ = 0; + } else { + ParamGeneration_ = 0; + AtExecValues_.clear(); + InvalidatePreparedColumnMeta(); + } + } +} + +void TStatement::RefreshRowBindings() { + if (GetAppRowDesc().GetGeneration() != RowGeneration_) { + GetAppRowDesc().Snapshot(RowBindings_, RowGeneration_); + } + if (ImpRowDesc_.GetGeneration() != ImpRowGeneration_) { + ImpRowDesc_.SnapshotHeader(ImpRowBindings_, ImpRowGeneration_); + } +} + +void TStatement::RefreshParamBindings() { + const auto paramSchema = ParamBindings_.GetSchemaGeneration(); + const auto impSchema = ImpParamBindings_.GetSchemaGeneration(); + if (GetAppParamDesc().GetGeneration() != ParamGeneration_) { + GetAppParamDesc().Snapshot(ParamBindings_, ParamGeneration_); + } + if (ImpParamDesc_.GetGeneration() != ImpParamGeneration_) { + ImpParamDesc_.Snapshot(ImpParamBindings_, ImpParamGeneration_); + } + if (paramSchema != ParamBindings_.GetSchemaGeneration() + || impSchema != ImpParamBindings_.GetSchemaGeneration()) { + InvalidatePreparedColumnMeta(); + } +} + +SQLRETURN TStatement::Prepare(const std::string& statementText) { + IsPrepared_ = false; + ParamCount_ = 0; + PreparedQuery_.clear(); + RowCount_ = -1; + PreparedColumnMeta_.reset(); + ClearResults(); + PreparedQuery_ = GetConnection().PrepareSql(statementText); + ParamCount_ = CountOdbcParams(PreparedQuery_); + ImpParamDesc_.WithLock([&](TDescriptor& desc) { + while (desc.GetRecordCount() > ParamCount_) { + desc.RemoveRecord(desc.GetRecordCount()); + } + for (SQLUSMALLINT i = 1; i <= ParamCount_; ++i) { + desc.RemoveInferredRecord(i); + desc.Record(i).Nullable = SQL_NULLABLE_UNKNOWN; + desc.Record(i).WideTemporalType.reset(); + } + }); + IsPrepared_ = true; + return SQL_SUCCESS; +} + +SQLRETURN TStatement::Execute() { + if (!IsPrepared_ || PreparedQuery_.empty()) { + throw TOdbcException("HY007", 0, "No prepared statement"); + } + RefreshParamBindings(); + for (SQLUSMALLINT number = 1; number <= ParamCount_; ++number) { + const auto* record = ImpParamBindings_.FindRecord(number); + if (record && !record->WideTemporalType + && (record->Type == SQL_TYPE_DATE || record->Type == SQL_TYPE_TIMESTAMP)) { + DescribeParam(number, nullptr, nullptr, nullptr, nullptr); + } + } + const SQLULEN paramsetSize = ParamCount_ > 0 ? ParamBindings_.GetArraySize() : 1; + ClearResults(); + RowCount_ = -1; + if (auto* processed = ImpParamBindings_.GetRowsProcessedPtr()) { + *processed = 0; + } + if (auto* statuses = ImpParamBindings_.GetArrayStatusPtr()) { + std::fill_n(statuses, paramsetSize, SQL_PARAM_UNUSED); + } + if (paramsetSize > 1 + && !StartsWithSqlStatement(PreparedQuery_, {"SELECT", "INSERT", "UPDATE", "DELETE", "UPSERT", "REPLACE"})) { + return AddError("HYC00", 0, "Parameter arrays are supported only for SELECT and data-modification statements"); + } + for (SQLULEN paramSet = 0; paramSet < paramsetSize; ++paramSet) { + if (FindNextNeedDataParam(paramSet)) { + if (paramsetSize > 1) { + return AddError("HYC00", 0, "Data-at-execution parameter arrays are not supported"); + } + NeedDataParam_ = 0; + InAtExec_ = true; + return SQL_NEED_DATA; + } + } + InAtExec_ = false; + NeedDataParam_ = 0; + return GetConnection().Execute(*this); +} + +SQLRETURN TStatement::ExecuteInternal() { + bool completed = false; + Y_DEFER { + if (!completed) { + AtExecValues_.clear(); + try { + ClearResults(); + } catch (const std::bad_alloc&) { + InvalidatePreparedColumnMeta(); + } + } + }; + RowCount_ = 0; + bool hasSuccessfulParamSet = false; + bool rowCountUsable = true; + const SQLULEN paramsetSize = ParamCount_ > 0 ? ParamBindings_.GetArraySize() : 1; + SQLUSMALLINT* const operations = ParamBindings_.GetArrayStatusPtr(); + SQLUSMALLINT* const statuses = ImpParamBindings_.GetArrayStatusPtr(); + SQLULEN* const processed = ImpParamBindings_.GetRowsProcessedPtr(); + SQLRETURN result = SQL_SUCCESS; + for (SQLULEN paramSet = 0; paramSet < paramsetSize; ++paramSet) { + if (operations && operations[paramSet] == SQL_PARAM_IGNORE) { + if (processed) { + *processed = paramSet + 1; + } + continue; + } + if (operations && operations[paramSet] != SQL_PARAM_PROCEED) { + if (statuses) { + statuses[paramSet] = SQL_PARAM_ERROR; + } + if (processed) { + *processed = paramSet + 1; + } + return AddError("HY024", 0, "Invalid parameter operation value"); + } + std::optional affectedRows; + SQLRETURN rc; + try { + rc = ExecuteParamSet(paramSet, affectedRows); + } catch (...) { + if (statuses) { + statuses[paramSet] = SQL_PARAM_ERROR; + } + if (processed) { + *processed = paramSet + 1; + } + if (!hasSuccessfulParamSet) { + RowCount_ = -1; + } + throw; + } + if (statuses) { + statuses[paramSet] = rc == SQL_SUCCESS_WITH_INFO + ? SQL_PARAM_SUCCESS_WITH_INFO + : rc == SQL_SUCCESS ? SQL_PARAM_SUCCESS : SQL_PARAM_ERROR; + } + if (processed) { + *processed = paramSet + 1; + } + if (rc == SQL_ERROR) { + if (!hasSuccessfulParamSet) { + RowCount_ = -1; + } + return SQL_ERROR; + } + hasSuccessfulParamSet = true; + if (rowCountUsable) { + if (!affectedRows || *affectedRows > std::numeric_limits::max() - RowCount_) { + RowCount_ = -1; + rowCountUsable = false; + } else { + RowCount_ += *affectedRows; + } + } + if (rc == SQL_SUCCESS_WITH_INFO) { + result = SQL_SUCCESS_WITH_INFO; + } + } + completed = true; + return result; +} + +SQLRETURN TStatement::ExecuteParamSet( + SQLULEN paramSet, + std::optional& affectedRows) +{ + CheckCancellation(); + auto client = GetConnection().GetClient(); + if (!client) { + throw TOdbcException("HY000", 0, "No client connection"); + } + NYdb::TParams params = NYdb::TParamsBuilder().Build(); + const SQLRETURN buildRc = BuildParams(params, paramSet); + if (buildRc != SQL_SUCCESS) { + return buildRc; + } + + if (GetConnection().GetAutocommit()) { + const NYdb::NRetry::TRetryOperationSettings retrySettings = MakeAutocommitRetrySettings(); + + const NYdb::TStatus execStatus = client->RetryQuerySync( + [this, ¶ms, &affectedRows, paramSet](NQuery::TSession session) -> NYdb::TStatus { + CheckCancellation(); + NQuery::TExecuteQueryResult result = ExecuteQuery(session, params, paramSet); + CheckExecutionStatus(result); + if (!result.IsSuccess()) { + return StatusFrom(result); + } + affectedRows = ExtractAffectedRows(result); + if (!IsCancelRequested()) { + SetResults(result); + } + return NYdb::TStatus(EStatus::SUCCESS, NYdb::NIssue::TIssues()); + }, + retrySettings); + + NStatusHelpers::ThrowOnError(execStatus); + } else { + auto session = GetConnection().GetOrCreateTx(*this).GetSession(); + CheckCancellation(); + NQuery::TExecuteQueryResult result = ExecuteQuery(session, params, paramSet); + NStatusHelpers::ThrowOnError(result); + affectedRows = ExtractAffectedRows(result); + if (!IsCancelRequested()) { + SetResults(result); + } + } + InAtExec_ = false; + NeedDataParam_ = 0; + AtExecValues_.clear(); + return SQL_SUCCESS; +} + +SQLRETURN TStatement::MoreResults() { + if (InAtExec_) { + return AddError("HY010", 0, "Function sequence error"); + } + RowCount_ = -1; + if (!RemainingResultSets_.empty()) { + auto cursor = CreateExecCursor( + RemainingResultSets_.front(), Attributes_.CursorType == SQL_CURSOR_STATIC); + SetCursor(std::move(cursor)); + RemainingResultSets_.pop_front(); + return SQL_SUCCESS; + } + ClearResults(); + return SQL_NO_DATA; +} + +SQLUSMALLINT TStatement::FindNextNeedDataParam(SQLULEN paramSet) const { + if (const auto* operations = ParamBindings_.GetArrayStatusPtr(); + ParamCount_ > 0 && operations && operations[paramSet] != SQL_PARAM_PROCEED) { + return 0; + } + for (SQLUSMALLINT i = 1; i <= ParamCount_; ++i) { + const auto* record = ParamBindings_.FindRecord(i); + if (record && ImpParamBindings_.FindRecord(i) && ParamBindings_.ResolveBinding(*record, paramSet).IsDataAtExec() + && (AtExecValues_.size() <= i || !AtExecValues_[i].Complete)) { + return i; + } + } + return 0; +} + +NYdb::NRetry::TRetryOperationSettings TStatement::MakeAutocommitRetrySettings() { + NYdb::NRetry::TRetryOperationSettings settings; + settings.Idempotent(false); + SQLUINTEGER queryTimeoutSec = Attributes_.GetQueryTimeoutSec(); + if (queryTimeoutSec > 0) { + const TDuration deadline = TDuration::Seconds(queryTimeoutSec); + settings.MaxTimeout(deadline).GetSessionClientTimeout(deadline); + } + return settings; +} + +NQuery::TExecuteQueryResult TStatement::ExecuteQuery( + NQuery::TSession& session, + const NYdb::TParams& params, + SQLULEN paramSet) +{ + const std::vector activeParams = GetBoundParams(paramSet); + const TParamRewriteResult rewritten = RewriteOdbcSql( + PreparedQuery_, activeParams, Attributes_.GetNoScanMode() != SQL_NOSCAN_ON); + if (!rewritten.Success) { + throw TOdbcException(rewritten.SqlState, 0, rewritten.Message); + } + const bool isDdl = StartsWithSqlStatement( + rewritten.Sql, {"CREATE", "DROP", "ALTER", "GRANT", "REVOKE"}); + const std::string queryText = GetConnection().WrapQueryForCurrentCatalog(rewritten.Sql); + NQuery::TExecuteQuerySettings execSettings; + execSettings.StatsMode(NQuery::EStatsMode::Basic).CollectAffectedRows(true); + const SQLUINTEGER queryTimeoutSec = Attributes_.GetQueryTimeoutSec(); + if (queryTimeoutSec > 0) { + execSettings.ClientTimeout(TDuration::Seconds(queryTimeoutSec)); + } + const auto txSettings = GetConnection().MakeTxSettings(); + if (GetConnection().GetAutocommit()) { + // TS_SNAPSHOT_RW doesn't support explicit BeginTx() - we use NoTx() instead + // DDL must use NoTx() per YDB documentation + const bool isSnapshotRw = (txSettings.GetMode() == NQuery::TTxSettings::TS_SNAPSHOT_RW); + + if (isSnapshotRw || isDdl) { + return session.ExecuteQuery( + queryText, + NQuery::TTxControl::NoTx(), + params, + execSettings).ExtractValueSync(); + } + return session.ExecuteQuery( + queryText, + NQuery::TTxControl::BeginTx(txSettings).CommitTx(), + params, + execSettings).ExtractValueSync(); + } + return session.ExecuteQuery( + queryText, + NQuery::TTxControl::Tx(*GetConnection().GetTx()).CommitTx(false), + params, + execSettings).ExtractValueSync(); +} + + + +SQLRETURN TStatement::Fetch() { + return FetchScroll(SQL_FETCH_NEXT, 0); +} + +SQLRETURN TStatement::FetchScroll(SQLSMALLINT orientation, SQLLEN offset) { + if (!Cursor_) { + return SQL_NO_DATA; + } + RefreshRowBindings(); + return FetchRows(orientation, offset, RowBindings_.GetArraySize(), + ImpRowBindings_.GetRowsProcessedPtr(), ImpRowBindings_.GetArrayStatusPtr(), false); +} + +SQLRETURN TStatement::ExtendedFetch(SQLUSMALLINT orientation, SQLLEN offset, + SQLULEN* fetched, SQLUSMALLINT* statuses) { + if (!statuses) { + return AddError("HY009", 0, "Invalid use of null pointer"); + } + if (!Cursor_) { + return AddError("24000", 0, "Invalid cursor state"); + } + RefreshRowBindings(); + return FetchRows(orientation, offset, Attributes_.RowsetSize, fetched, statuses, true); +} + +SQLRETURN TStatement::FetchRows(SQLSMALLINT orientation, SQLLEN offset, SQLULEN rowArraySize, + SQLULEN* fetched, SQLUSMALLINT* statuses, bool extended) { + switch (orientation) { + case SQL_FETCH_NEXT: + case SQL_FETCH_PRIOR: + case SQL_FETCH_FIRST: + case SQL_FETCH_LAST: + case SQL_FETCH_ABSOLUTE: + case SQL_FETCH_RELATIVE: + break; + default: + return AddError("HY106", 0, "Fetch type out of range"); + } + if (Attributes_.CursorType == SQL_CURSOR_FORWARD_ONLY + && orientation != SQL_FETCH_NEXT) { + return AddError("HY106", 0, "Fetch type out of range for a forward-only cursor"); + } + + if (fetched) { + *fetched = 0; + } + if (statuses) { + std::fill_n(statuses, rowArraySize, SQL_ROW_NOROW); + } + + const TFetchResult fetch = Cursor_->Fetch( + orientation, offset, rowArraySize, Attributes_.GetMaxRows()); + if (fetch.Rows == 0) { + GetDataColumn_ = 0; + return SQL_NO_DATA; + } + + SQLRETURN result = SQL_SUCCESS; + for (SQLULEN row = 0; row < fetch.Rows; ++row) { + const SQLULEN rows = row + 1; + const SQLRETURN rowResult = FillBoundColumns(row, !extended); + if (fetched) { + *fetched = rows; + } + if (statuses) { + statuses[row] = rowResult == SQL_SUCCESS_WITH_INFO + ? SQL_ROW_SUCCESS_WITH_INFO + : rowResult == SQL_SUCCESS ? SQL_ROW_SUCCESS : SQL_ROW_ERROR; + } + if (rowResult == SQL_ERROR) { + result = extended + ? AddError("01S01", 0, "Error in row", SQL_SUCCESS_WITH_INFO) + : SQL_ERROR; + } else if (rowResult == SQL_SUCCESS_WITH_INFO && result == SQL_SUCCESS) { + result = SQL_SUCCESS_WITH_INFO; + } + } + GetDataColumn_ = 0; + if (fetch.OverlappedStart) { + AddError("01S06", 0, "Attempt to fetch before the result set returned the first rowset", + SQL_SUCCESS_WITH_INFO); + if (result == SQL_SUCCESS) { + result = SQL_SUCCESS_WITH_INFO; + } + } + return result; +} + +SQLRETURN TStatement::GetData(SQLUSMALLINT columnNumber, SQLSMALLINT targetType, + SQLPOINTER targetValue, SQLLEN bufferLength, SQLLEN* strLenOrInd) { + if (!Cursor_) { + return SQL_NO_DATA; + } + if (columnNumber < 1 || columnNumber > Cursor_->GetColumnMeta().size()) { + return AddError("07009", 0, "Invalid descriptor index"); + } + if (bufferLength < 0) { + return AddError("HY090", 0, "Invalid string or buffer length"); + } + if (columnNumber != GetDataColumn_) { + GetDataColumn_ = columnNumber; + GetDataOffset_ = 0; + } + if (GetDataOffset_ < 0) { + return SQL_NO_DATA; + } + SQLLEN offset = GetDataOffset_; + const SQLRETURN rc = Cursor_->GetData( + 0, columnNumber, targetType, targetValue, bufferLength, strLenOrInd, + &offset); + if (targetValue && SQL_SUCCEEDED(rc)) { + GetDataOffset_ = rc == SQL_SUCCESS ? -1 : offset; + } + if (const char* sqlState = ConsumeLastConvertSqlState()) { + AddError(sqlState, 0, std::strcmp(sqlState, "22003") == 0 ? "Numeric value out of range" : "Conversion error"); + } else if (rc == SQL_SUCCESS_WITH_INFO) { + AddError("01004", 0, "String data, right truncated", SQL_SUCCESS_WITH_INFO); + } + return rc; +} + +SQLRETURN TStatement::FillBoundColumns(SQLULEN row, bool useOffset) { + if (!Cursor_) { + return SQL_NO_DATA; + } + SQLRETURN result = SQL_SUCCESS; + for (SQLSMALLINT number = 1; number <= RowBindings_.GetRecordCount(); ++number) { + const TDescRecord* col = RowBindings_.FindRecord(number); + if (!col || !col->DataPtr) { + continue; + } + if (static_cast(number) > Cursor_->GetColumnMeta().size()) { + if (row == 0) { + AddError("07009", 0, "Invalid descriptor index"); + } + result = SQL_ERROR; + continue; + } + const TResolvedBinding binding = RowBindings_.ResolveBinding(*col, row, useOffset); + SQLLEN* indicator = binding.Indicator; + SQLLEN* length = binding.OctetLength; + SQLLEN convertedLength = 0; + SQLRETURN rc = Cursor_->GetData( + row, static_cast(number), col->Type, + binding.Data, col->OctetLength, + &convertedLength); + if (convertedLength == SQL_NULL_DATA) { + if (!indicator) { + AddError("22002", 0, "Indicator variable required but not supplied"); + rc = SQL_ERROR; + } else { + *indicator = SQL_NULL_DATA; + if (length && length != indicator) { + *length = 0; + } + } + } else { + if (length) { + *length = convertedLength; + } + if (indicator && indicator != length) { + *indicator = 0; + } + } + if (rc == SQL_SUCCESS_WITH_INFO) { + AddError("01004", 0, "String data, right truncated", SQL_SUCCESS_WITH_INFO); + if (result == SQL_SUCCESS) { + result = SQL_SUCCESS_WITH_INFO; + } + } else if (rc != SQL_SUCCESS) { + if (const char* sqlState = ConsumeLastConvertSqlState()) { + AddError(sqlState, 0, std::strcmp(sqlState, "22003") == 0 ? "Numeric value out of range" : "Conversion error"); + } + result = rc; + } + } + return result; +} + +SQLRETURN TStatement::BindCol(SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLLEN bufferLength, SQLLEN* strLenOrInd) { + if (targetValue && columnNumber < 1) { + return AddError("07009", 0, "Invalid descriptor index"); + } + if (Cursor_) { + const size_t n = Cursor_->GetColumnMeta().size(); + if (targetValue && n > 0 && static_cast(columnNumber) > n) { + return AddError("07009", 0, "Invalid descriptor index"); + } + } + + GetAppRowDesc().WithLock([&](TDescriptor& desc) { + if (!targetValue) { + desc.RemoveRecord(static_cast(columnNumber)); + return; + } + TDescRecord& record = desc.Record(static_cast(columnNumber)); + record.Type = targetType; + record.Length = bufferLength; + record.OctetLength = bufferLength; + record.DataPtr = targetValue; + record.IndicatorPtr = strLenOrInd; + record.OctetLengthPtr = strLenOrInd; + }); + return SQL_SUCCESS; +} + +SQLRETURN TStatement::BindParameter(SQLUSMALLINT paramNumber, + SQLSMALLINT inputOutputType, + SQLSMALLINT valueType, + SQLSMALLINT parameterType, + SQLULEN columnSize, + SQLSMALLINT decimalDigits, + SQLPOINTER parameterValuePtr, + SQLLEN bufferLength, + SQLLEN* strLenOrIndPtr) { + if (inputOutputType != SQL_PARAM_INPUT) { + throw TOdbcException("HYC00", 0, "Only input parameters are supported"); + } + if (paramNumber < 1) { + throw TOdbcException("07009", 0, "Invalid descriptor index"); + } + + if (parameterType == SQL_UNKNOWN_TYPE) { + throw TOdbcException("HY004", 0, "Invalid SQL data type"); + } + GetAppParamDesc().WithLock(ImpParamDesc_, [&](TDescriptor& appDesc, TDescriptor& impDesc) { + if (!parameterValuePtr && !strLenOrIndPtr) { + appDesc.RemoveRecord(static_cast(paramNumber)); + impDesc.RemoveRecord(static_cast(paramNumber)); + return; + } + TDescRecord& app = appDesc.Record(static_cast(paramNumber)); + app.Type = valueType; + app.Length = bufferLength; + app.OctetLength = bufferLength; + app.DataPtr = parameterValuePtr; + app.IndicatorPtr = strLenOrIndPtr; + app.OctetLengthPtr = strLenOrIndPtr; + app.ParameterType = inputOutputType; + + TDescRecord& imp = impDesc.Record(static_cast(paramNumber)); + imp.Type = parameterType; + imp.Inferred = false; + imp.Length = static_cast(columnSize); + imp.OctetLength = static_cast(columnSize); + imp.Precision = static_cast(columnSize); + imp.Scale = decimalDigits; + imp.Nullable = SQL_NULLABLE; + imp.ParameterType = inputOutputType; + }); + if (!parameterValuePtr && !strLenOrIndPtr) { + if (AtExecValues_.size() > paramNumber) { + AtExecValues_[paramNumber] = {}; + } + } else { + if (AtExecValues_.size() <= paramNumber) { + AtExecValues_.resize(paramNumber + 1); + } + AtExecValues_[paramNumber] = {}; + } + + InvalidatePreparedColumnMeta(); + return SQL_SUCCESS; +} + +std::vector TStatement::GetBoundParams(SQLULEN paramSet) const { + std::vector params; + for (SQLUSMALLINT number = 1; number <= ParamCount_; ++number) { + const TDescRecord* app = ParamBindings_.FindRecord(number); + const TDescRecord* imp = ImpParamBindings_.FindRecord(number); + if (!app || !imp) { + continue; + } + const TResolvedBinding binding = ParamBindings_.ResolveBinding(*app, paramSet); + const bool isNullData = binding.Indicator + && *binding.Indicator == SQL_NULL_DATA; + const bool atExec = binding.IsDataAtExec(); + const bool atExecNullData = atExec + && AtExecValues_.size() > static_cast(number) + && AtExecValues_[number].Complete + && AtExecValues_[number].Indicator == SQL_NULL_DATA; + TBoundParam param{ + static_cast(number), app->Type, imp->Type, + static_cast(imp->Length), imp->Scale, binding.Data, app->OctetLength, + binding.OctetLength, atExec, isNullData || atExecNullData, + imp->WideTemporalType.value_or(EWideTemporal::None)}; + if (binding.Indicator && *binding.Indicator == SQL_NULL_DATA) { + param.StrLenOrIndPtr = binding.Indicator; + } + params.push_back(std::move(param)); + } + return params; +} + +SQLRETURN TStatement::BuildParams(NYdb::TParams& out, SQLULEN paramSet) { + ClearErrors(); + NYdb::TParamsBuilder paramsBuilder; + const auto conversionError = [&](const TBoundParam& param) { + const char* state = ConsumeLastConvertSqlState(); + return AddError( + state ? state : "07006", + 0, + "Invalid ODBC parameter " + std::to_string(param.ParamNumber) + + " in parameter set " + std::to_string(paramSet + 1) + + " (C type " + std::to_string(static_cast(param.ValueType)) + + ", SQL type " + std::to_string(static_cast(param.ParameterType)) + ")"); + }; + for (const TBoundParam& param : GetBoundParams(paramSet)) { + const std::string paramName = "$p" + std::to_string(param.ParamNumber); + if (param.AtExec) { + if (AtExecValues_.size() <= param.ParamNumber + || !AtExecValues_[param.ParamNumber].Complete) { + return AddError("HY000", 0, "Missing data-at-execution parameter value"); + } + TAtExecValue& value = AtExecValues_[param.ParamNumber]; + SQLLEN indicator = value.Indicator == SQL_NULL_DATA + ? SQL_NULL_DATA + : static_cast(value.Data.size()); + TBoundParam tmp = param; + tmp.ParameterValuePtr = value.Data.data(); + tmp.StrLenOrIndPtr = &indicator; + const bool optional = BoundParamIsNull(tmp) + || GetDeclaredParamOptionality(PreparedQuery_, param.ParamNumber).value_or(false); + const SQLRETURN convRc = ConvertParam( + tmp, paramsBuilder.AddParam(paramName), optional); + if (convRc != SQL_SUCCESS) { + return conversionError(param); + } + continue; + } + const bool optional = BoundParamIsNull(param) + || GetDeclaredParamOptionality(PreparedQuery_, param.ParamNumber).value_or(false); + const SQLRETURN convRc = ConvertParam( + param, paramsBuilder.AddParam(paramName), optional); + if (convRc != SQL_SUCCESS) { + return conversionError(param); + } + } + out = paramsBuilder.Build(); + return SQL_SUCCESS; +} + + +SQLRETURN TStatement::NumParams(SQLSMALLINT* paramCount) { + if (!paramCount) { + throw TOdbcException("HY000", 0, "Invalid parameter"); + } + if (!IsPrepared_) { + throw TOdbcException("HY010", 0, "Function sequence error"); + } + *paramCount = ParamCount_; + return SQL_SUCCESS; +} + +void TStatement::ResetForMetadata() { + ClearErrors(); + RowCount_ = -1; + PreparedQuery_.clear(); + IsPrepared_ = false; + ParamCount_ = 0; + PreparedColumnMeta_.reset(); + ClearResults(); +} + +SQLRETURN TStatement::DescribeParam(SQLUSMALLINT paramNumber, SQLSMALLINT* dataTypePtr, SQLULEN* paramSizePtr, + SQLSMALLINT* decimalDigitsPtr, SQLSMALLINT* nullablePtr) { + if (!IsPrepared_) { + throw TOdbcException("HY010", 0, "Function sequence error"); + } + if (paramNumber < 1 || paramNumber > ParamCount_) { + throw TOdbcException("07009", 0, "Invalid descriptor index"); + } + RefreshParamBindings(); + const TDescRecord* record = ImpParamBindings_.FindRecord(static_cast(paramNumber)); + const bool temporal = record && !record->WideTemporalType + && (record->Type == SQL_TYPE_DATE || record->Type == SQL_TYPE_TIMESTAMP); + if (!record || (record->Type == SQL_UNKNOWN_TYPE && !record->Inferred) || temporal) { + if (const auto query = BuildParamMetadataQuery( + PreparedQuery_, Attributes_.GetNoScanMode() != SQL_NOSCAN_ON, paramNumber, ParamCount_)) { + auto columns = ReadQueryMetadata(*query, true); + // Column nullability constrains insert targets, not predicate parameters. + if (!StartsWithSqlStatement(PreparedQuery_, {"INSERT", "UPSERT", "REPLACE"})) { + for (auto& column : columns) { + column.Nullable = SQL_NULLABLE_UNKNOWN; + } + } + ImpParamDesc_.WithLock([&](TDescriptor& desc) { + for (size_t index = 0; index < columns.size(); ++index) { + const auto i = static_cast(index + 1); + const auto& column = columns[index]; + auto& parameter = desc.Record(i); + parameter.WideTemporalType = column.WideTemporal; + if (parameter.Type != SQL_UNKNOWN_TYPE) { + continue; + } + parameter.Type = column.SqlType; + parameter.Length = parameter.OctetLength = column.Size; + parameter.Precision = static_cast(column.Size); + parameter.Scale = column.DecimalDigits; + parameter.Nullable = column.Nullable; + parameter.Inferred = true; + } + desc.SnapshotUnlocked(ImpParamBindings_, ImpParamGeneration_); + }); + } else if (temporal) { + ImpParamDesc_.WithLock([&](TDescriptor& desc) { + desc.Record(paramNumber).WideTemporalType = EWideTemporal::None; + desc.SnapshotUnlocked(ImpParamBindings_, ImpParamGeneration_); + }); + } + record = ImpParamBindings_.FindRecord(static_cast(paramNumber)); + } + if (!record || record->Type == SQL_UNKNOWN_TYPE) { + throw TOdbcException("HYC00", 0, "Parameter metadata is unavailable for this SQL expression"); + } + if (dataTypePtr) { + *dataTypePtr = record->Type; + } + if (paramSizePtr) { + *paramSizePtr = record->Length; + } + if (decimalDigitsPtr) { + *decimalDigitsPtr = record->Scale; + } + if (nullablePtr) { + *nullablePtr = record->Nullable; + } + return SQL_SUCCESS; +} + +SQLRETURN TStatement::ParamData(SQLPOINTER* valuePtr) { + if (!valuePtr) { + throw TOdbcException("HY009", 0, "Invalid use of null pointer"); + } + if (!InAtExec_) { + return SQL_NO_DATA; + } + RefreshParamBindings(); + if (NeedDataParam_ != 0) { + if (AtExecValues_.size() <= NeedDataParam_) { + AtExecValues_.resize(NeedDataParam_ + 1); + } + AtExecValues_[NeedDataParam_].Complete = true; + NeedDataParam_ = 0; + } + const SQLUSMALLINT next = FindNextNeedDataParam(); + if (next != 0) { + NeedDataParam_ = next; + *valuePtr = ParamBindings_.FindRecord(static_cast(next))->DataPtr; + return SQL_NEED_DATA; + } + InAtExec_ = false; + NeedDataParam_ = 0; + return GetConnection().Execute(*this); +} + +SQLRETURN TStatement::PutData(SQLPOINTER data, SQLLEN strLenOrInd) { + if (!InAtExec_ || NeedDataParam_ == 0) { + throw TOdbcException("HY010", 0, "Function sequence error"); + } + RefreshParamBindings(); + const TDescRecord* param = ParamBindings_.FindRecord( + static_cast(NeedDataParam_)); + if (!param) { + throw TOdbcException("HY010", 0, "Function sequence error"); + } + if (AtExecValues_.size() <= NeedDataParam_) { + AtExecValues_.resize(NeedDataParam_ + 1); + } + TAtExecValue& value = AtExecValues_[NeedDataParam_]; + SQLLEN chunkLen = strLenOrInd; + if (chunkLen == SQL_NULL_DATA) { + value.Indicator = SQL_NULL_DATA; + return SQL_SUCCESS; + } + if (chunkLen == SQL_DEFAULT_PARAM) { + throw TOdbcException("07S01", 0, "Default parameters are not supported"); + } + if (chunkLen == SQL_NTS) { + if (!data) { + throw TOdbcException("HY009", 0, "Invalid use of null pointer"); + } + chunkLen = static_cast(std::strlen(static_cast(data))); + } + if (chunkLen < 0) { + throw TOdbcException("HY090", 0, "Invalid string or buffer length"); + } + if (chunkLen > 0) { + if (!data) { + throw TOdbcException("HY009", 0, "Invalid use of null pointer"); + } + value.Data.append(static_cast(data), static_cast(chunkLen)); + } + return SQL_SUCCESS; +} + +SQLRETURN TStatement::Cancel() { + std::shared_lock lifecycle; + std::unique_lock operation; + try { + if (CancelExecuting()) { + return SQL_SUCCESS; + } + lifecycle = GetConnection().LockShared(std::try_to_lock); + if (!lifecycle.owns_lock()) { + return CancelExecuting() ? SQL_SUCCESS : SQL_ERROR; + } + operation = std::unique_lock(OperationMutex_, std::try_to_lock); + if (!operation.owns_lock()) { + return CancelExecuting() ? SQL_SUCCESS : SQL_ERROR; + } + ClearErrors(); + if (Cursor_ || !RemainingResultSets_.empty() || InAtExec_) { + ClearResults(); + InAtExec_ = false; + NeedDataParam_ = 0; + AtExecValues_.clear(); + } + SetLastReturnCode(SQL_SUCCESS); + return SQL_SUCCESS; + } catch (...) { + if (operation.owns_lock()) { + return RecordCurrentException(*this); + } + // Cross-thread cancellation must not replace the executing call's diagnostics. + return SQL_ERROR; + } +} + +void TStatement::StartExecution() { + ExecutionState_.store(EExecutionState::Executing, std::memory_order_relaxed); +} + +void TStatement::CheckCancellation() const { + if (IsCancelRequested()) { + throw TOdbcException("HY008", 0, "Operation canceled"); + } +} + +void TStatement::CheckExecutionStatus(const TStatus& status) { + if (IsCancelRequested() && !status.IsSuccess()) { + // A requested cancel must stop retries without hiding other errors, + // particularly an unknown commit outcome. + NStatusHelpers::ThrowOnError(status); + } +} + +bool TStatement::CancelExecuting() { + auto expected = EExecutionState::Executing; + return ExecutionState_.compare_exchange_strong(expected, EExecutionState::CancelRequested, + std::memory_order_relaxed) || expected == EExecutionState::CancelRequested; +} + +bool TStatement::FinishExecution() noexcept { + const bool requested = ExecutionState_.exchange(EExecutionState::Idle, std::memory_order_relaxed) + == EExecutionState::CancelRequested; + if (requested) { + try { + ClearResults(); + } catch (const std::bad_alloc&) { + // Disposal already cleared the cursor; don't replace the original diagnostics. + InvalidatePreparedColumnMeta(); + } + InAtExec_ = false; + NeedDataParam_ = 0; + AtExecValues_.clear(); + } + return requested; +} + +SQLRETURN TStatement::SetCursorName(const std::string& name) { + CursorName_ = name; + return SQL_SUCCESS; +} + +SQLRETURN TStatement::GetCursorName(SQLCHAR* name, SQLSMALLINT bufferLength, SQLSMALLINT* nameLengthPtr) { + if (CursorName_.empty()) { + static std::atomic nextCursorId{0}; + char generated[18] = "SQL_CUR"; + const auto result = std::to_chars(generated + 7, generated + sizeof(generated), + nextCursorId.fetch_add(1, std::memory_order_relaxed), 36); + if (result.ec != std::errc{}) { + throw TOdbcException("HY000", 0, "Cursor name sequence exhausted"); + } + CursorName_.assign(generated, result.ptr); + } + return Diag::WriteOdbcString(*this, CursorName_, name, bufferLength, nameLengthPtr); +} + + +SQLRETURN TStatement::Close(bool force) { + if (!force && !Cursor_ && RemainingResultSets_.empty()) { + throw TOdbcException("24000", 0, "Invalid handle"); + } + + ClearResults(); + ClearErrors(); + return SQL_SUCCESS; +} + +void TStatement::UnbindColumns() { + GetAppRowDesc().Clear(); +} + +void TStatement::ResetParams() { + RefreshParamBindings(); + // Resetting bindings keeps the result schema learned by execution. + GetAppParamDesc().WithLock(ImpParamDesc_, [&](TDescriptor& app, TDescriptor& imp) { + app.ClearRecords(); + imp.ClearRecords(); + app.SnapshotUnlocked(ParamBindings_, ParamGeneration_); + imp.SnapshotUnlocked(ImpParamBindings_, ImpParamGeneration_); + }); + AtExecValues_.clear(); +} + +SQLRETURN TStatement::RowCount(SQLLEN* rowCount) { + if (!rowCount) { + throw TOdbcException("HY000", 0, "Invalid parameter"); + } + + *rowCount = RowCount_; + return SQL_SUCCESS; +} + +SQLRETURN TStatement::NumResultCols(SQLSMALLINT* colCount) { + if (!colCount) { + throw TOdbcException("HY000", 0, "Invalid parameter"); + } + const auto& columns = GetColumnMeta(); + *colCount = static_cast(columns.size()); + return SQL_SUCCESS; +} + +const std::vector& TStatement::GetColumnMeta() { + if (Cursor_) { + return Cursor_->GetColumnMeta(); + } + EnsurePreparedColumnMeta(); + return *PreparedColumnMeta_; +} + +void TStatement::EnsurePreparedColumnMeta() { + RefreshParamBindings(); + if (PreparedColumnMeta_) { + return; + } + if (!IsPrepared_) { + throw TOdbcException("HY010", 0, "Function sequence error"); + } + if (HasMultipleSqlStatements(PreparedQuery_)) { + throw TOdbcException( + "HYC00", 0, + "Result metadata before execution is unavailable for multiple statements"); + } + + if (!StartsWithSqlStatement(PreparedQuery_, {"SELECT"})) { + if (StartsWithSqlStatement( + PreparedQuery_, + {"INSERT", "UPDATE", "DELETE", "UPSERT", "REPLACE", "MERGE", + "CREATE", "DROP", "ALTER", "GRANT", "REVOKE", "COMMIT", "ROLLBACK"})) { + PreparedColumnMeta_.emplace(); + SetImpRowDesc(*PreparedColumnMeta_); + return; + } + throw TOdbcException( + "HYC00", 0, + "Result metadata before execution is supported only for SELECT statements"); + } + + // Use descriptor types and typed NULLs, never application parameter values. + std::vector activeParams; + NYdb::TParamsBuilder builder; + for (SQLUSMALLINT number = 1; number <= ParamCount_; ++number) { + const auto* imp = ImpParamBindings_.FindRecord(number); + const auto* app = ParamBindings_.FindRecord(number); + if (!imp || imp->Type == SQL_UNKNOWN_TYPE + || GetDeclaredParamOptionality(PreparedQuery_, number) == false) { + throw TOdbcException("HYC00", 0, "Result metadata requires known, nullable parameter types"); + } + activeParams.push_back({static_cast(number), + static_cast(app ? app->Type : SQL_C_DEFAULT), imp->Type, static_cast(imp->Length), + imp->Scale, nullptr, 0, nullptr, false, true, + imp->WideTemporalType.value_or(EWideTemporal::None)}); + if (ConvertParam(activeParams.back(), builder.AddParam("$p" + std::to_string(number))) != SQL_SUCCESS) { + throw TOdbcException("HYC00", 0, "Result metadata requires supported parameter types"); + } + } + + const TParamRewriteResult rewritten = RewriteOdbcSql( + BuildResultMetadataQuery(PreparedQuery_), activeParams, + Attributes_.GetNoScanMode() != SQL_NOSCAN_ON); + if (!rewritten.Success) { + throw TOdbcException(rewritten.SqlState, 0, rewritten.Message); + } + const auto params = builder.Build(); + PreparedColumnMeta_ = ReadQueryMetadata(rewritten.Sql, false, ¶ms); + SetImpRowDesc(*PreparedColumnMeta_); +} + +std::vector TStatement::ReadQueryMetadata( + const std::string& sql, bool parameters, const NYdb::TParams* suppliedParams) { + auto client = GetConnection().GetClient(); + if (!client) { + throw TOdbcException("HY000", 0, "No client connection"); + } + const NYdb::TParams params = suppliedParams ? *suppliedParams : NYdb::TParamsBuilder().Build(); + const std::string queryText = GetConnection().WrapQueryForCurrentCatalog(sql); + + NYdb::NRetry::TRetryOperationSettings retrySettings; + retrySettings.Idempotent(true); + const SQLUINTEGER queryTimeoutSec = Attributes_.GetQueryTimeoutSec(); + if (queryTimeoutSec > 0) { + const TDuration deadline = TDuration::Seconds(queryTimeoutSec); + retrySettings.MaxTimeout(deadline).GetSessionClientTimeout(deadline); + } + + std::optional> columns; + const NYdb::TStatus execStatus = client->RetryQuerySync( + [this, &queryText, ¶ms, &columns, queryTimeoutSec, parameters]( + NQuery::TSession session) -> NYdb::TStatus { + CheckCancellation(); + NQuery::TExecuteQuerySettings execSettings; + execSettings.SchemaInclusionMode(NQuery::ESchemaInclusionMode::Always); + if (queryTimeoutSec > 0) { + execSettings.ClientTimeout(TDuration::Seconds(queryTimeoutSec)); + } + NQuery::TExecuteQueryResult result = session.ExecuteQuery( + queryText, + NQuery::TTxControl::NoTx(), + params, + execSettings).ExtractValueSync(); + CheckExecutionStatus(result); + if (!result.IsSuccess()) { + return StatusFrom(result); + } + if (result.GetResultSets().size() != 1) { + return NYdb::TStatus( + EStatus::BAD_REQUEST, + NYdb::NIssue::TIssues{NYdb::NIssue::TIssue( + "Result metadata query did not return exactly one result set")}); + } + columns = MakeColumnMeta(result.GetResultSet(0), parameters); + return NYdb::TStatus(EStatus::SUCCESS, NYdb::NIssue::TIssues()); + }, + retrySettings); + NStatusHelpers::ThrowOnError(execStatus); + if (!columns) { + throw TOdbcException("HY000", 0, "Result metadata is unavailable"); + } + return std::move(*columns); +} + +void TStatement::InvalidateInferredParamMetadata() { + // The caller holds the exclusive connection lifecycle gate. + for (SQLSMALLINT i = ImpParamDesc_.GetRecordCount(); i > 0; --i) { + ImpParamDesc_.RemoveInferredRecord(i); + if (ImpParamDesc_.FindRecord(i)) { + ImpParamDesc_.Record(i).WideTemporalType.reset(); + } + } +} + +void TStatement::InvalidatePreparedColumnMeta() { + PreparedColumnMeta_.reset(); + if (!Cursor_) { + ImpRowDesc_.Clear(); + } +} + +void TStatement::SetCursor(std::unique_ptr cursor) { + Cursor_ = std::move(cursor); + GetDataColumn_ = 0; + static const std::vector EmptyColumns; + SetImpRowDesc(Cursor_ ? Cursor_->GetColumnMeta() + : PreparedColumnMeta_ ? *PreparedColumnMeta_ : EmptyColumns); +} + +void TStatement::SetImpRowDesc(const std::vector& columns) { + ImpRowDesc_.WithLock([&](TDescriptor& desc) { + desc.ClearRecords(); + SQLSMALLINT number = 0; + for (const TColumnMeta& column : columns) { + TDescRecord& record = desc.Record(++number); + record.Name = column.Name; + record.Type = column.SqlType; + record.Length = static_cast(column.Size); + record.OctetLength = static_cast(column.Size); + record.Precision = static_cast(column.Size); + record.Scale = column.DecimalDigits; + record.Nullable = column.Nullable; + record.Unsigned = column.Unsigned; + } + }); +} + +void TStatement::ClearResults() { + RemainingResultSets_.clear(); + SetCursor(nullptr); +} + +void TStatement::SetResults(const NQuery::TExecuteQueryResult& result) { + const auto& sets = result.GetResultSets(); + if (Cursor_) { + RemainingResultSets_.insert(RemainingResultSets_.end(), sets.begin(), sets.end()); + return; + } + auto cursor = sets.empty() ? nullptr : CreateExecCursor( + sets.front(), Attributes_.CursorType == SQL_CURSOR_STATIC); + if (cursor && IsPrepared_) { + PreparedColumnMeta_ = cursor->GetColumnMeta(); + } + if (!sets.empty()) { + RemainingResultSets_.assign(sets.begin() + 1, sets.end()); + } + SetCursor(std::move(cursor)); +} + +std::optional TStatement::ResolveDescriptorAttribute( + SQLINTEGER attr) { + switch (attr) { + case SQL_ATTR_PARAM_BIND_TYPE: + return TDescriptorAttribute{GetAppParamDesc(), SQL_DESC_BIND_TYPE}; + case SQL_ATTR_PARAMSET_SIZE: + return TDescriptorAttribute{GetAppParamDesc(), SQL_DESC_ARRAY_SIZE}; + case SQL_ATTR_PARAM_BIND_OFFSET_PTR: + return TDescriptorAttribute{GetAppParamDesc(), SQL_DESC_BIND_OFFSET_PTR}; + case SQL_ATTR_PARAM_OPERATION_PTR: + return TDescriptorAttribute{GetAppParamDesc(), SQL_DESC_ARRAY_STATUS_PTR}; + case SQL_ATTR_PARAM_STATUS_PTR: + return TDescriptorAttribute{ImpParamDesc_, SQL_DESC_ARRAY_STATUS_PTR}; + case SQL_ATTR_PARAMS_PROCESSED_PTR: + return TDescriptorAttribute{ImpParamDesc_, SQL_DESC_ROWS_PROCESSED_PTR}; + case SQL_ATTR_ROW_BIND_TYPE: + return TDescriptorAttribute{GetAppRowDesc(), SQL_DESC_BIND_TYPE}; + case SQL_ATTR_ROW_ARRAY_SIZE: + return TDescriptorAttribute{GetAppRowDesc(), SQL_DESC_ARRAY_SIZE}; + case SQL_ATTR_ROW_BIND_OFFSET_PTR: + return TDescriptorAttribute{GetAppRowDesc(), SQL_DESC_BIND_OFFSET_PTR}; + case SQL_ATTR_ROW_STATUS_PTR: + return TDescriptorAttribute{ImpRowDesc_, SQL_DESC_ARRAY_STATUS_PTR}; + case SQL_ATTR_ROWS_FETCHED_PTR: + return TDescriptorAttribute{ImpRowDesc_, SQL_DESC_ROWS_PROCESSED_PTR}; + default: + return std::nullopt; + } +} + +SQLRETURN TStatement::SetStmtAttr( + SQLINTEGER attr, + SQLPOINTER value, + SQLINTEGER /*stringLength*/) { + if (InAtExec_) { + return AddError("HY010", 0, "Function sequence error"); + } + if (attr == SQL_ATTR_APP_ROW_DESC || attr == SQL_ATTR_APP_PARAM_DESC) { + auto* descriptor = CheckedHandle(value); + if (value && !descriptor) { + return AddError("HY024", 0, "Invalid descriptor handle"); + } + auto& original = attr == SQL_ATTR_APP_ROW_DESC ? AppRowDesc_ : AppParamDesc_; + if (descriptor == &original) { + descriptor = nullptr; + } else if (descriptor && descriptor->GetDescType() != EDescType::Explicit) { + return AddError("HY017", 0, "Cannot assign an automatically allocated descriptor"); + } + if (descriptor && &descriptor->GetConnection() != &GetConnection()) { + return AddError("HY024", 0, "Descriptor belongs to another connection"); + } + SetAppDescriptor(attr, descriptor); + return SQL_SUCCESS; + } + if (attr == SQL_ATTR_IMP_ROW_DESC || attr == SQL_ATTR_IMP_PARAM_DESC) { + return AddError("HY017", 0, "Cannot assign an implementation descriptor"); + } + if ((attr == SQL_ATTR_PARAMSET_SIZE || attr == SQL_ATTR_ROW_ARRAY_SIZE) + && ReadIntegerAttr(value) == 0) { + return Diag::AddInvalidAttrValue( + *this, + attr == SQL_ATTR_PARAMSET_SIZE ? "SQL_ATTR_PARAMSET_SIZE" : "SQL_ATTR_ROW_ARRAY_SIZE"); + } + if (auto descriptorAttr = ResolveDescriptorAttribute(attr)) { + return descriptorAttr->Descriptor.WithLock([&](TDescriptor& desc) { + return desc.SetDescField(0, descriptorAttr->Field, value, 0); + }); + } + const auto setCursorType = [&](SQLULEN cursorType, std::string_view name) -> SQLRETURN { + if (Cursor_) { + return AddError("24000", 0, std::string(name) + " cannot be changed while a cursor is open"); + } + if (cursorType == SQL_CURSOR_FORWARD_ONLY || cursorType == SQL_CURSOR_STATIC) { + Attributes_.CursorType = cursorType; + return SQL_SUCCESS; + } + if (cursorType == SQL_CURSOR_KEYSET_DRIVEN || cursorType == SQL_CURSOR_DYNAMIC) { + Attributes_.CursorType = SQL_CURSOR_STATIC; + return AddError("01S02", 0, std::string(name) + " was changed to static", + SQL_SUCCESS_WITH_INFO); + } + return Diag::AddInvalidAttrValue(*this, name); + }; + switch (attr) { + case SQL_ROWSET_SIZE: + return SetCheckedAttribute( + value, Attributes_.RowsetSize, *this, "SQL_ROWSET_SIZE", + [](SQLULEN input) { return input > 0; }); + case SQL_ATTR_QUERY_TIMEOUT: + return SetCheckedAttribute( + value, Attributes_.QueryTimeoutSec, *this, "SQL_ATTR_QUERY_TIMEOUT", + [](SQLINTEGER input) { return input >= 0; }); + case SQL_ATTR_MAX_ROWS: + return SetCheckedAttribute( + value, Attributes_.MaxRows, *this, "SQL_ATTR_MAX_ROWS", + [](SQLLEN input) { return input >= 0; }); + case SQL_ATTR_NOSCAN: { + const SQLULEN previous = Attributes_.NoScan; + const SQLRETURN result = SetCheckedAttribute( + value, Attributes_.NoScan, *this, "SQL_ATTR_NOSCAN", + [](SQLULEN input) { + return input == SQL_NOSCAN_OFF || input == SQL_NOSCAN_ON; + }); + if (result == SQL_SUCCESS && Attributes_.NoScan != previous) { + InvalidatePreparedColumnMeta(); + } + return result; + } + case SQL_ATTR_METADATA_ID: + return SetCheckedAttribute( + value, Attributes_.MetadataId, *this, "SQL_ATTR_METADATA_ID", + [](SQLULEN input) { return input == SQL_FALSE || input == SQL_TRUE; }); + case SQL_ATTR_CONCURRENCY: { + if (Cursor_) { + return AddError( + "24000", 0, + "SQL_ATTR_CONCURRENCY cannot be changed while a cursor is open"); + } + const SQLULEN concurrency = ReadIntegerAttr(value); + if (concurrency == SQL_CONCUR_READ_ONLY) { + Attributes_.Concurrency = concurrency; + return SQL_SUCCESS; + } + if (concurrency == SQL_CONCUR_LOCK + || concurrency == SQL_CONCUR_ROWVER + || concurrency == SQL_CONCUR_VALUES) { + Attributes_.Concurrency = SQL_CONCUR_READ_ONLY; + return AddError( + "01S02", 0, + "SQL_ATTR_CONCURRENCY was changed to read-only", + SQL_SUCCESS_WITH_INFO); + } + return Diag::AddInvalidAttrValue(*this, "SQL_ATTR_CONCURRENCY"); + } + case SQL_ATTR_CURSOR_TYPE: + return setCursorType( + ReadIntegerAttr(value), "SQL_ATTR_CURSOR_TYPE"); + case SQL_ATTR_CURSOR_SCROLLABLE: { + const SQLULEN scrollable = ReadIntegerAttr(value); + if (scrollable != SQL_NONSCROLLABLE && scrollable != SQL_SCROLLABLE) { + return Diag::AddInvalidAttrValue(*this, "SQL_ATTR_CURSOR_SCROLLABLE"); + } + return setCursorType( + scrollable == SQL_NONSCROLLABLE + ? SQL_CURSOR_FORWARD_ONLY + : SQL_CURSOR_STATIC, + "SQL_ATTR_CURSOR_SCROLLABLE"); + } + case SQL_ATTR_CURSOR_SENSITIVITY: { + const SQLULEN sensitivity = ReadIntegerAttr(value); + if (sensitivity == SQL_UNSPECIFIED) { + return SQL_SUCCESS; + } + if (sensitivity == SQL_INSENSITIVE) { + return setCursorType(SQL_CURSOR_STATIC, "SQL_ATTR_CURSOR_SENSITIVITY"); + } + if (sensitivity == SQL_SENSITIVE) { + const SQLRETURN result = setCursorType( + SQL_CURSOR_STATIC, "SQL_ATTR_CURSOR_SENSITIVITY"); + return result == SQL_SUCCESS + ? AddError("01S02", 0, + "SQL_ATTR_CURSOR_SENSITIVITY was changed to insensitive", + SQL_SUCCESS_WITH_INFO) + : result; + } + return Diag::AddInvalidAttrValue(*this, "SQL_ATTR_CURSOR_SENSITIVITY"); + } + case SQL_ATTR_USE_BOOKMARKS: { + const SQLULEN bookmarks = ReadIntegerAttr(value); + if (bookmarks == SQL_UB_OFF) { + return SQL_SUCCESS; + } + if (bookmarks == SQL_UB_ON || bookmarks == SQL_UB_VARIABLE) { + return AddError("01S02", 0, "SQL_ATTR_USE_BOOKMARKS was changed to off", + SQL_SUCCESS_WITH_INFO); + } + return Diag::AddInvalidAttrValue(*this, "SQL_ATTR_USE_BOOKMARKS"); + } + default: + return Diag::AddNotImplemented(*this); + } +} + +SQLRETURN TStatement::GetStmtAttr( + SQLINTEGER attr, + SQLPOINTER value, + SQLINTEGER /*bufferLength*/, + SQLINTEGER* stringLengthPtr) { + if (!value) { + return AddError("HY009", 0, "Invalid use of null pointer"); + } + switch (attr) { + case SQL_ATTR_APP_ROW_DESC: + *reinterpret_cast(value) = static_cast(&GetAppRowDesc()); + return SQL_SUCCESS; + case SQL_ATTR_APP_PARAM_DESC: + *reinterpret_cast(value) = static_cast(&GetAppParamDesc()); + return SQL_SUCCESS; + case SQL_ATTR_IMP_ROW_DESC: + *reinterpret_cast(value) = static_cast(&ImpRowDesc_); + return SQL_SUCCESS; + case SQL_ATTR_IMP_PARAM_DESC: + *reinterpret_cast(value) = static_cast(&ImpParamDesc_); + return SQL_SUCCESS; + default: + break; + } + if (auto descriptorAttr = ResolveDescriptorAttribute(attr)) { + return descriptorAttr->Descriptor.WithLock([&](TDescriptor& desc) { + return desc.GetDescField(0, descriptorAttr->Field, value, 0, nullptr); + }); + } + if (stringLengthPtr) { + *stringLengthPtr = 0; + } + if (attr == SQL_ATTR_ROW_NUMBER) { + *static_cast(value) = Cursor_ ? Cursor_->GetRowNumber() : 0; + return SQL_SUCCESS; + } + if (attr == SQL_ATTR_CURSOR_SCROLLABLE) { + *static_cast(value) = Attributes_.CursorType == SQL_CURSOR_FORWARD_ONLY + ? SQL_NONSCROLLABLE + : SQL_SCROLLABLE; + return SQL_SUCCESS; + } + if (attr == SQL_ATTR_CURSOR_SENSITIVITY) { + *static_cast(value) = Attributes_.CursorType == SQL_CURSOR_FORWARD_ONLY + ? SQL_UNSPECIFIED + : SQL_INSENSITIVE; + return SQL_SUCCESS; + } + if (attr == SQL_ATTR_USE_BOOKMARKS) { + *static_cast(value) = SQL_UB_OFF; + return SQL_SUCCESS; + } + if (auto result = TDirectAttributes::Get(attr, Attributes_, value)) { + return *result; + } + return Diag::AddNotImplemented(*this); +} + +SQLRETURN TStatement::GetDiagField( + SQLSMALLINT recNumber, + SQLSMALLINT diagIdentifier, + SQLPOINTER diagInfoPtr, + SQLSMALLINT bufferLength, + SQLSMALLINT* stringLengthPtr) { + if (diagIdentifier == SQL_DIAG_ROW_COUNT) { + return RowCount(static_cast(diagInfoPtr)); + } + return TErrorManager::GetDiagField(recNumber, diagIdentifier, diagInfoPtr, bufferLength, stringLengthPtr); +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/statement.h b/odbc/src/statement.h new file mode 100644 index 00000000000..320b0b4f3d4 --- /dev/null +++ b/odbc/src/statement.h @@ -0,0 +1,226 @@ +#pragma once + +#include "connection.h" +#include "descriptor.h" +#include "utils/attr.h" +#include "utils/bindings.h" +#include "utils/cursor.h" + +#include + +#include "odbc_compat.h" + +#include +#include +#include +#include +#include +#include + + +namespace NYdb::NOdbc { + +using TMetadataArgument = std::optional; + +class TStatement : public THandle { +public: + explicit TStatement(TConnection* conn); + TConnection& GetConnection() const noexcept { return static_cast(*GetParent()); } + void ResetDescriptor(TDescriptor& descriptor); + + SQLRETURN Prepare(const std::string& statementText); + SQLRETURN Execute(); + SQLRETURN MoreResults(); + + SQLRETURN Fetch(); + SQLRETURN FetchScroll(SQLSMALLINT orientation, SQLLEN offset); + SQLRETURN ExtendedFetch(SQLUSMALLINT orientation, SQLLEN offset, + SQLULEN* fetched, SQLUSMALLINT* statuses); + SQLRETURN GetData(SQLUSMALLINT columnNumber, SQLSMALLINT targetType, + SQLPOINTER targetValue, SQLLEN bufferLength, SQLLEN* strLenOrInd); + + SQLRETURN Close(bool force = false); + void UnbindColumns(); + void ResetParams(); + + SQLRETURN BindCol(SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLLEN bufferLength, SQLLEN* strLenOrInd); + SQLRETURN BindParameter(SQLUSMALLINT paramNumber, SQLSMALLINT inputOutputType, SQLSMALLINT valueType, SQLSMALLINT parameterType, SQLULEN columnSize, SQLSMALLINT decimalDigits, SQLPOINTER parameterValuePtr, SQLLEN bufferLength, SQLLEN* strLenOrIndPtr); + + SQLRETURN Columns(const TMetadataArgument& catalogName, const TMetadataArgument& schemaName, + const TMetadataArgument& tableName, const TMetadataArgument& columnName); + + SQLRETURN Tables(const TMetadataArgument& catalogName, const TMetadataArgument& schemaName, + const TMetadataArgument& tableName, const TMetadataArgument& tableType); + + SQLRETURN GetTypeInfo(SQLSMALLINT dataType); + SQLRETURN Statistics(const TMetadataArgument& catalogName, + const TMetadataArgument& schemaName, + const TMetadataArgument& tableName, + SQLUSMALLINT unique, + SQLUSMALLINT accuracy); + SQLRETURN SpecialColumns(const TMetadataArgument& catalogName, + const TMetadataArgument& schemaName, + const TMetadataArgument& tableName, + SQLUSMALLINT identifierType, + SQLUSMALLINT scope, + SQLUSMALLINT nullable); + SQLRETURN PrimaryKeys(const TMetadataArgument& catalogName, const TMetadataArgument& schemaName, + const TMetadataArgument& tableName); + SQLRETURN ForeignKeys(const std::string& pkCatalogName, + const std::string& pkSchemaName, + const std::string& pkTableName, + const std::string& fkCatalogName, + const std::string& fkSchemaName, + const std::string& fkTableName); + SQLRETURN ColumnPrivileges(const std::string& catalogName, + const std::string& schemaName, + const std::string& tableName, + const std::string& columnName); + SQLRETURN NumParams(SQLSMALLINT* paramCount); + SQLRETURN DescribeParam(SQLUSMALLINT paramNumber, SQLSMALLINT* dataTypePtr, SQLULEN* paramSizePtr, + SQLSMALLINT* decimalDigitsPtr, SQLSMALLINT* nullablePtr); + SQLRETURN ParamData(SQLPOINTER* valuePtr); + SQLRETURN PutData(SQLPOINTER data, SQLLEN strLenOrInd); + SQLRETURN Cancel(); + bool NeedsData() const { return InAtExec_; } + bool IsExecuting() const { return ExecutionState_.load(std::memory_order_relaxed) != EExecutionState::Idle; } + bool IsCancelRequested() const { return ExecutionState_.load(std::memory_order_relaxed) == EExecutionState::CancelRequested; } + SQLRETURN SetCursorName(const std::string& name); + SQLRETURN GetCursorName(SQLCHAR* name, SQLSMALLINT bufferLength, SQLSMALLINT* nameLengthPtr); + + + SQLRETURN RowCount(SQLLEN* rowCount); + SQLRETURN NumResultCols(SQLSMALLINT* colCount); + const std::vector& GetColumnMeta(); + SQLRETURN SetStmtAttr(SQLINTEGER attr, SQLPOINTER value, SQLINTEGER stringLength); + SQLRETURN GetStmtAttr(SQLINTEGER attr, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLengthPtr); + + SQLRETURN GetDiagField(SQLSMALLINT recNumber, SQLSMALLINT diagIdentifier, SQLPOINTER diagInfoPtr, SQLSMALLINT bufferLength, + SQLSMALLINT* stringLengthPtr) override; + +private: + friend class TConnection; + template + friend SQLRETURN CallOdbc(SQLHANDLE handlePtr, Fn&& func); + + enum class EExecutionState : unsigned char { Idle, Executing, CancelRequested }; + + struct TAttributes { + SQLUINTEGER QueryTimeoutSec = 0; + SQLULEN MaxRows = 0; + SQLULEN NoScan = SQL_NOSCAN_OFF; + SQLULEN MetadataId = SQL_FALSE; + SQLULEN CursorType = SQL_CURSOR_FORWARD_ONLY; + SQLULEN Concurrency = SQL_CONCUR_READ_ONLY; + SQLULEN RowsetSize = 1; + + SQLUINTEGER GetQueryTimeoutSec() const noexcept { return QueryTimeoutSec; } + SQLULEN GetMaxRows() const noexcept { return MaxRows; } + SQLULEN GetNoScanMode() const noexcept { return NoScan; } + SQLULEN GetMetadataId() const noexcept { return MetadataId; } + }; + + using TDirectAttributes = TScalarProperties< + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty, + TScalarProperty>; + + struct TAtExecValue { + std::string Data; + SQLLEN Indicator = 0; + bool Complete = false; + }; + + std::unique_ptr Cursor_; + std::deque RemainingResultSets_; + std::optional> PreparedColumnMeta_; + std::string PreparedQuery_; + bool IsPrepared_ = false; + SQLSMALLINT ParamCount_ = 0; + + SQLLEN RowCount_ = -1; + TAttributes Attributes_; + std::string CursorName_; + TDescriptor AppRowDesc_; + TDescriptor AppParamDesc_; + TDescriptor ImpRowDesc_; + TDescriptor ImpParamDesc_; + TDescriptor* AppRowDescPtr_ = nullptr; + TDescriptor* AppParamDescPtr_ = nullptr; + TDescriptorState RowBindings_; + TDescriptorState ParamBindings_; + TDescriptorState ImpParamBindings_; + TDescriptorState ImpRowBindings_; + uint64_t RowGeneration_ = 0; + uint64_t ParamGeneration_ = 0; + uint64_t ImpParamGeneration_ = 0; + uint64_t ImpRowGeneration_ = 0; + std::atomic ExecutionState_ = EExecutionState::Idle; + SQLUSMALLINT NeedDataParam_ = 0; + bool InAtExec_ = false; + std::vector AtExecValues_; // indexed by parameter number + SQLUSMALLINT GetDataColumn_ = 0; + SQLLEN GetDataOffset_ = 0; + + SQLRETURN BuildParams(NYdb::TParams& out, SQLULEN paramSet); + SQLRETURN ExecuteParamSet(SQLULEN paramSet, std::optional& affectedRows); + SQLRETURN ExecuteInternal(); + SQLRETURN FillBoundColumns(SQLULEN row, bool useOffset); + SQLRETURN FetchRows(SQLSMALLINT orientation, SQLLEN offset, SQLULEN rowArraySize, + SQLULEN* fetched, SQLUSMALLINT* statuses, bool extended); + std::vector GetBoundParams(SQLULEN paramSet) const; + void EnsurePreparedColumnMeta(); + std::vector ReadQueryMetadata(const std::string& sql, bool parameters = false, + const NYdb::TParams* suppliedParams = nullptr); + void InvalidateInferredParamMetadata(); + void InvalidatePreparedColumnMeta(); + void SetImpRowDesc(const std::vector& columns); + void SetAppDescriptor(SQLINTEGER attr, TDescriptor* descriptor); + TDescriptor& GetAppRowDesc() { return AppRowDescPtr_ ? *AppRowDescPtr_ : AppRowDesc_; } + TDescriptor& GetAppParamDesc() { return AppParamDescPtr_ ? *AppParamDescPtr_ : AppParamDesc_; } + void RefreshRowBindings(); + void RefreshParamBindings(); + void StartExecution(); + bool FinishExecution() noexcept; + void CheckCancellation() const; + bool CancelExecuting(); + void CheckExecutionStatus(const TStatus& status); + void SetCursor(std::unique_ptr cursor); + void ClearResults(); + void SetResults(const NQuery::TExecuteQueryResult& result); + + void ResetForMetadata(); + struct TDescriptorAttribute { + TDescriptor& Descriptor; + SQLSMALLINT Field; + }; + std::optional ResolveDescriptorAttribute(SQLINTEGER attr); + + SQLUSMALLINT FindNextNeedDataParam(SQLULEN paramSet = 0) const; + std::string GetMetadataTableName(const std::string& path) const; + bool MetadataNamespaceMatches(const TMetadataArgument& catalog, + const TMetadataArgument& schema, + bool catalogPatternsAllowed, + bool schemaPatternsAllowed) const; + +protected: + virtual NQuery::TExecuteQueryResult ExecuteQuery( + NQuery::TSession& session, + const NYdb::TParams& params, + SQLULEN paramSet); + +private: + NYdb::NRetry::TRetryOperationSettings MakeAutocommitRetrySettings(); + std::vector GetMetadataEntries(const TMetadataArgument& tableName, + bool patternsAllowed); + void VisitEntry(const std::string& path, const std::string& tableName, + bool patternsAllowed, std::string_view literalPrefix, bool hasWildcard, + std::vector& resultEntries); + std::optional GetTableType(NScheme::ESchemeEntryType type); +}; + +} // namespace NYdb::NOdbc diff --git a/odbc/src/statement_metadata.cpp b/odbc/src/statement_metadata.cpp new file mode 100644 index 00000000000..b9b33b15ed1 --- /dev/null +++ b/odbc/src/statement_metadata.cpp @@ -0,0 +1,735 @@ +#include "statement.h" + +#include "utils/sql_like.h" +#include "utils/sql_type_map.h" +#include "utils/types.h" +#include "utils/util.h" + +#include +#include +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { +namespace { + +TColumnMeta C(std::string_view name, SQLSMALLINT type, SQLULEN size, + SQLSMALLINT nullable = SQL_NULLABLE) { + return {std::string(name), type, size, nullable}; +} + +TColumnMeta V(std::string_view name, SQLULEN size = 128, + SQLSMALLINT nullable = SQL_NULLABLE) { + return C(name, SQL_VARCHAR, size, nullable); +} + +TColumnMeta N(std::string_view name, SQLSMALLINT type, + SQLSMALLINT nullable = SQL_NULLABLE) { + const auto* spec = FindSqlTypeSpec(type); + return C(name, type, spec ? spec->ColumnSize : 0, nullable); +} + +const TColumnMeta kColumnsSchema[] = { + V("TABLE_CAT"), + V("TABLE_SCHEM"), + V("TABLE_NAME", 128, SQL_NO_NULLS), + V("COLUMN_NAME", 128, SQL_NO_NULLS), + N("DATA_TYPE", SQL_SMALLINT, SQL_NO_NULLS), + V("TYPE_NAME", 128, SQL_NO_NULLS), + N("COLUMN_SIZE", SQL_INTEGER), + N("BUFFER_LENGTH", SQL_INTEGER), + N("DECIMAL_DIGITS", SQL_SMALLINT), + N("NUM_PREC_RADIX", SQL_SMALLINT), + N("NULLABLE", SQL_SMALLINT, SQL_NO_NULLS), + V("REMARKS", 762), + V("COLUMN_DEF", 254), + N("SQL_DATA_TYPE", SQL_SMALLINT, SQL_NO_NULLS), + N("SQL_DATETIME_SUB", SQL_SMALLINT), + N("CHAR_OCTET_LENGTH", SQL_INTEGER), + N("ORDINAL_POSITION", SQL_INTEGER, SQL_NO_NULLS), + V("IS_NULLABLE", 254, SQL_NO_NULLS), +}; + +const TColumnMeta kTablesSchema[] = { + V("TABLE_CAT"), + V("TABLE_SCHEM"), + V("TABLE_NAME", 128, SQL_NO_NULLS), + V("TABLE_TYPE", 128, SQL_NO_NULLS), + V("REMARKS", 254), +}; + +const TColumnMeta kTypeInfoSchema[] = { + V("TYPE_NAME", 128, SQL_NO_NULLS), + N("DATA_TYPE", SQL_SMALLINT, SQL_NO_NULLS), + N("COLUMN_SIZE", SQL_INTEGER), + V("LITERAL_PREFIX"), + V("LITERAL_SUFFIX"), + V("CREATE_PARAMS"), + N("NULLABLE", SQL_SMALLINT, SQL_NO_NULLS), + N("CASE_SENSITIVE", SQL_SMALLINT, SQL_NO_NULLS), + N("SEARCHABLE", SQL_SMALLINT, SQL_NO_NULLS), + N("UNSIGNED_ATTRIBUTE", SQL_SMALLINT), + N("FIXED_PREC_SCALE", SQL_SMALLINT, SQL_NO_NULLS), + N("AUTO_UNIQUE_VALUE", SQL_SMALLINT), + V("LOCAL_TYPE_NAME"), + N("MINIMUM_SCALE", SQL_SMALLINT), + N("MAXIMUM_SCALE", SQL_SMALLINT), + N("SQL_DATA_TYPE", SQL_SMALLINT, SQL_NO_NULLS), + N("SQL_DATETIME_SUB", SQL_SMALLINT), + N("NUM_PREC_RADIX", SQL_INTEGER), + N("INTERVAL_PRECISION", SQL_SMALLINT), +}; + +const TColumnMeta kStatisticsSchema[] = { + V("TABLE_CAT"), + V("TABLE_SCHEM"), + V("TABLE_NAME", 128, SQL_NO_NULLS), + N("NON_UNIQUE", SQL_SMALLINT), + V("INDEX_QUALIFIER"), + V("INDEX_NAME"), + N("TYPE", SQL_SMALLINT, SQL_NO_NULLS), + N("ORDINAL_POSITION", SQL_SMALLINT), + V("COLUMN_NAME"), + C("ASC_OR_DESC", SQL_CHAR, 1), + N("CARDINALITY", SQL_INTEGER), + N("PAGES", SQL_INTEGER), + V("FILTER_CONDITION"), +}; + +using EEntry = NScheme::ESchemeEntryType; +constexpr std::pair kTableTypes[] = { + {EEntry::Table, "TABLE"}, {EEntry::View, "VIEW"}, + {EEntry::ColumnTable, "COLUMN_TABLE"}, {EEntry::ExternalTable, "EXTERNAL_TABLE"}, + {EEntry::SysView, "SYSTEM VIEW"}, +}; + +bool IsTable(EEntry type) { + return type == EEntry::Table || type == EEntry::ColumnTable; +} + +const TColumnMeta kSpecialColumnsSchema[] = { + N("SCOPE", SQL_SMALLINT), + V("COLUMN_NAME", 128, SQL_NO_NULLS), + N("DATA_TYPE", SQL_SMALLINT, SQL_NO_NULLS), + V("TYPE_NAME", 128, SQL_NO_NULLS), + N("COLUMN_SIZE", SQL_INTEGER), + N("BUFFER_LENGTH", SQL_INTEGER), + N("DECIMAL_DIGITS", SQL_SMALLINT), + N("PSEUDO_COLUMN", SQL_SMALLINT, SQL_NO_NULLS), +}; + +const TColumnMeta kPrimaryKeysSchema[] = { + V("TABLE_CAT"), + V("TABLE_SCHEM"), + V("TABLE_NAME", 128, SQL_NO_NULLS), + V("COLUMN_NAME", 128, SQL_NO_NULLS), + N("KEY_SEQ", SQL_SMALLINT, SQL_NO_NULLS), + V("PK_NAME"), +}; + +const TColumnMeta kForeignKeysSchema[] = { + V("PKTABLE_CAT"), + V("PKTABLE_SCHEM"), + V("PKTABLE_NAME", 128, SQL_NO_NULLS), + V("PKCOLUMN_NAME", 128, SQL_NO_NULLS), + V("FKTABLE_CAT"), + V("FKTABLE_SCHEM"), + V("FKTABLE_NAME", 128, SQL_NO_NULLS), + V("FKCOLUMN_NAME", 128, SQL_NO_NULLS), + N("KEY_SEQ", SQL_SMALLINT, SQL_NO_NULLS), + N("UPDATE_RULE", SQL_SMALLINT), + N("DELETE_RULE", SQL_SMALLINT), + V("FK_NAME"), + V("PK_NAME"), + N("DEFERRABILITY", SQL_SMALLINT), +}; + +const TColumnMeta kColumnPrivilegesSchema[] = { + V("TABLE_CAT"), + V("TABLE_SCHEM"), + V("TABLE_NAME", 128, SQL_NO_NULLS), + V("COLUMN_NAME", 128, SQL_NO_NULLS), + V("GRANTOR"), + V("GRANTEE", 128, SQL_NO_NULLS), + V("PRIVILEGE", 128, SQL_NO_NULLS), + V("IS_GRANTABLE"), +}; + +TOdbcScalar Null() { + return std::monostate{}; +} + +template +TOdbcScalar I(T value) { + return static_cast(value); +} + +template +TOdbcScalar Maybe(const std::optional& value) { + return value ? I(*value) : Null(); +} + +TOdbcScalar Int32OrNull(uint64_t value) { + // CARDINALITY is SQL_INTEGER; NULL is safer than reporting a clipped row count. + return value <= static_cast(std::numeric_limits::max()) + ? I(static_cast(value)) + : Null(); +} + +std::pair GetLiteralPrefix(std::string_view pattern) { + std::string prefix; + for (size_t i = 0; i < pattern.size(); ++i) { + const char ch = pattern[i]; + if (ch == '\\' && i + 1 < pattern.size() + && (pattern[i + 1] == '%' || pattern[i + 1] == '_' + || pattern[i + 1] == '\\')) { + prefix.push_back(pattern[++i]); + } else if (ch == '%' || ch == '_') { + return {prefix, true}; + } else { + prefix.push_back(ch); + } + } + return {prefix, false}; +} + +bool IsExplicitEmpty(const TMetadataArgument& value) { + return value && value->empty(); +} + +bool IsSpecialValue(const TMetadataArgument& value, std::string_view special) { + return value && *value == special; +} + +bool IsDateTimeType(SQLSMALLINT type) { + return type == SQL_TYPE_DATE || type == SQL_TYPE_TIME || type == SQL_TYPE_TIMESTAMP; +} + +TOdbcScalar GetSqlDataType(SQLSMALLINT type) { + return I(IsDateTimeType(type) ? SQL_DATETIME : type); +} + +TOdbcScalar GetDateTimeSub(SQLSMALLINT type) { + switch (type) { + case SQL_TYPE_DATE: return I(SQL_CODE_DATE); + case SQL_TYPE_TIME: return I(SQL_CODE_TIME); + case SQL_TYPE_TIMESTAMP: return I(SQL_CODE_TIMESTAMP); + default: return Null(); + } +} + +TOdbcScalar GetColumnSize(const TYdbTypeInfo& type) { + return I(static_cast(type.ColumnSize)); +} + +bool ColumnIsNotNull(const NTable::TTableColumn& column, const TYdbTypeInfo& type) { + return type.Nullable == SQL_NO_NULLS || column.NotNull.value_or(false); +} + +TOdbcScalar GetBufferLength(const TYdbTypeInfo& type) { + switch (type.SqlType) { + case SQL_BIT: case SQL_TINYINT: return I(sizeof(SQLCHAR)); + case SQL_SMALLINT: return I(sizeof(SQLSMALLINT)); + case SQL_INTEGER: case SQL_REAL: return I(sizeof(SQLINTEGER)); + case SQL_BIGINT: case SQL_DOUBLE: return I(sizeof(SQLBIGINT)); + case SQL_TYPE_DATE: return I(sizeof(SQL_DATE_STRUCT)); + case SQL_TYPE_TIME: return I(sizeof(SQL_TIME_STRUCT)); + case SQL_TYPE_TIMESTAMP: return I(sizeof(SQL_TIMESTAMP_STRUCT)); + case SQL_GUID: return I(sizeof(SQLGUID)); + default: return GetColumnSize(type); + } +} + +TOdbcScalar GetCharOctetLength(const TYdbTypeInfo& type) { + switch (type.SqlType) { + case SQL_CHAR: case SQL_VARCHAR: case SQL_LONGVARCHAR: + case SQL_WCHAR: case SQL_WVARCHAR: case SQL_WLONGVARCHAR: + case SQL_BINARY: case SQL_VARBINARY: + case SQL_LONGVARBINARY: + return GetColumnSize(type); + default: return Null(); + } +} + +std::string GetMetadataCatalogName(const TConnection& connection) { + std::string catalog = connection.GetCatalogBinding().Catalog; + // TABLE_CAT is an identifier. The leading slash belongs to YDB's absolute + // path syntax and is supplied separately as SQL_CATALOG_NAME_SEPARATOR. + if (catalog.starts_with('/')) { + catalog.erase(0, 1); + } + return catalog; +} + +template +void DescribeTable(TConnection& connection, const std::string& path, + Visitor&& visitor, bool withTableStatistics = false) { + auto client = connection.GetTableClient(); + if (!client) { + throw TOdbcException("HY000", 0, "No client connection"); + } + auto status = client->RetryOperationSync( + [path, withTableStatistics, &visitor](NTable::TSession session) -> TStatus { + auto settings = NTable::TDescribeTableSettings() + .WithTableStatistics(withTableStatistics); + auto result = session.DescribeTable(path, settings).ExtractValueSync(); + NStatusHelpers::ThrowOnError(result); + visitor(result.GetTableDescription()); + return TStatus(EStatus::SUCCESS, {}); + }); + NStatusHelpers::ThrowOnError(status); +} + +bool MatchesTableTypeFilter(std::string_view filter, std::string_view entryType) { + if (filter.empty()) { + return true; + } + while (true) { + const size_t comma = filter.find(','); + std::string_view token = filter.substr(0, comma); + while (!token.empty() && std::isspace(static_cast(token.front()))) { + token.remove_prefix(1); + } + while (!token.empty() && std::isspace(static_cast(token.back()))) { + token.remove_suffix(1); + } + if (token.size() >= 2 && token.front() == '\'' && token.back() == '\'') { + token = token.substr(1, token.size() - 2); + } + if (token.size() == entryType.size() + && StartsWithPrefix(entryType.data(), entryType.size(), token.data(), token.size())) { + return true; + } + if (comma == std::string_view::npos) { + return false; + } + filter.remove_prefix(comma + 1); + } +} + +TTable BuildTypeInfoRows(SQLSMALLINT dataType) { + if (dataType == SQL_DATE) { + dataType = SQL_TYPE_DATE; + } else if (dataType == SQL_TIME) { + dataType = SQL_TYPE_TIME; + } else if (dataType == SQL_TIMESTAMP) { + dataType = SQL_TYPE_TIMESTAMP; + } + + TTable table; + for (const TSqlTypeSpec& spec : GetSqlTypeSpecs()) { + if ((dataType == SQL_ALL_TYPES && !spec.Advertise) + || (dataType != SQL_ALL_TYPES && spec.Type != dataType)) { + continue; + } + const bool text = spec.ParamType == EParamType::Utf8; + const bool decimal = spec.ParamType == EParamType::Decimal; + const std::string typeName(decimal ? "Decimal" : spec.YqlType); + const bool numeric = decimal + || (spec.ParamType >= EParamType::Int8 && spec.ParamType <= EParamType::Double); + const TOdbcScalar literalPrefix = spec.Type == SQL_TYPE_DATE ? TOdbcScalar("{d '") + : spec.Type == SQL_TYPE_TIME ? TOdbcScalar("{t '") + : spec.Type == SQL_TYPE_TIMESTAMP ? TOdbcScalar("{ts '") + : text ? TOdbcScalar("'") : Null(); + const TOdbcScalar literalSuffix = IsDateTimeType(spec.Type) ? TOdbcScalar("'}") + : text ? TOdbcScalar("'") : Null(); + table.push_back({ + typeName, I(spec.Type), I(decimal ? 35 : static_cast(spec.ColumnSize)), + literalPrefix, literalSuffix, + decimal ? TOdbcScalar("precision,scale") : Null(), I(SQL_NULLABLE), + I(text), I(SQL_PRED_SEARCHABLE), numeric ? I(SQL_FALSE) : Null(), I(SQL_FALSE), I(SQL_FALSE), typeName, + numeric ? I(0) : Null(), numeric ? I(decimal ? 35 : 0) : Null(), + GetSqlDataType(spec.Type), GetDateTimeSub(spec.Type), numeric ? I(10) : Null(), Null(), + }); + } + std::ranges::sort(table, {}, [](const auto& row) { + return std::tie(std::get(row[1]), std::get(row[0])); + }); + return table; +} + +} // namespace + +SQLRETURN TStatement::Columns(const TMetadataArgument& catalogName, + const TMetadataArgument& schemaName, + const TMetadataArgument& tableName, + const TMetadataArgument& columnName) { + if (Attributes_.GetMetadataId() == SQL_TRUE + && (!catalogName || !schemaName || !tableName || !columnName)) { + return AddError("HY009", 0, "Identifier arguments must not be null"); + } + ResetForMetadata(); + const bool patternsAllowed = Attributes_.GetMetadataId() != SQL_TRUE; + if (!MetadataNamespaceMatches(catalogName, schemaName, false, patternsAllowed)) { + SetCursor(CreateVirtualCursor(kColumnsSchema)); + return SQL_SUCCESS; + } + + const std::string catalog = GetMetadataCatalogName(GetConnection()); + TTable table; + for (const auto& entry : GetMetadataEntries(tableName, patternsAllowed)) { + if (!IsTable(entry.Type) && entry.Type != EEntry::SysView) { + continue; + } + DescribeTable(GetConnection(), entry.Name, [&](const auto& description) { + const auto& columns = description.GetTableColumns(); + for (size_t index = 0; index < columns.size(); ++index) { + const auto& column = columns[index]; + const bool matches = !columnName + || (patternsAllowed ? SqlLikeMatch(column.Name, *columnName) + : column.Name == *columnName); + if (!matches) { + continue; + } + const TYdbTypeInfo type = DescribeYdbType(column.Type); + const TOdbcScalar size = GetColumnSize(type); + const bool notNull = ColumnIsNotNull(column, type); + table.push_back({ + catalog, Null(), GetMetadataTableName(entry.Name), column.Name, I(type.SqlType), + type.TypeName, size, GetBufferLength(type), Maybe(type.DecimalDigits), + Maybe(type.Radix), I(notNull ? SQL_NO_NULLS : SQL_NULLABLE), Null(), Null(), + GetSqlDataType(type.SqlType), GetDateTimeSub(type.SqlType), + GetCharOctetLength(type), I(static_cast(index + 1)), + std::string(notNull ? "NO" : "YES"), + }); + } + }); + } + SetCursor(CreateVirtualCursor(kColumnsSchema, std::move(table))); + return SQL_SUCCESS; +} + +SQLRETURN TStatement::Tables(const TMetadataArgument& catalogName, + const TMetadataArgument& schemaName, + const TMetadataArgument& tableName, + const TMetadataArgument& tableType) { + if (Attributes_.GetMetadataId() == SQL_TRUE + && (!catalogName || !schemaName || !tableName)) { + return AddError("HY009", 0, "Identifier arguments must not be null"); + } + ResetForMetadata(); + + const bool emptySchema = IsExplicitEmpty(schemaName); + const bool emptyTable = IsExplicitEmpty(tableName); + const bool emptyType = IsExplicitEmpty(tableType); + const bool patternsAllowed = Attributes_.GetMetadataId() != SQL_TRUE; + if (patternsAllowed && IsSpecialValue(catalogName, SQL_ALL_CATALOGS) + && emptySchema && emptyTable && emptyType) { + SetCursor(CreateVirtualCursor(kTablesSchema, {{ + GetMetadataCatalogName(GetConnection()), Null(), Null(), Null(), Null(), + }})); + return SQL_SUCCESS; + } + if (patternsAllowed && IsSpecialValue(schemaName, SQL_ALL_SCHEMAS) + && IsExplicitEmpty(catalogName) && emptyTable && emptyType) { + SetCursor(CreateVirtualCursor(kTablesSchema)); + return SQL_SUCCESS; + } + if (IsSpecialValue(tableType, SQL_ALL_TABLE_TYPES) + && IsExplicitEmpty(catalogName) && emptySchema && emptyTable) { + std::vector types; + for (const auto& [_, type] : kTableTypes) { + types.push_back(type); + } + std::ranges::sort(types); + TTable table; + for (const std::string_view type : types) { + table.push_back({Null(), Null(), Null(), std::string(type), Null()}); + } + SetCursor(CreateVirtualCursor(kTablesSchema, std::move(table))); + return SQL_SUCCESS; + } + + if (emptyType) { + SetCursor(CreateVirtualCursor(kTablesSchema)); + return SQL_SUCCESS; + } + + if (!MetadataNamespaceMatches(catalogName, schemaName, + patternsAllowed, patternsAllowed)) { + SetCursor(CreateVirtualCursor(kTablesSchema)); + return SQL_SUCCESS; + } + + const std::string catalog = GetMetadataCatalogName(GetConnection()); + TTable table; + const std::string_view typeFilter = tableType ? std::string_view(*tableType) : std::string_view{}; + for (const auto& entry : GetMetadataEntries(tableName, patternsAllowed)) { + const auto type = GetTableType(entry.Type); + if (type && MatchesTableTypeFilter(typeFilter, *type)) { + table.push_back({catalog, Null(), GetMetadataTableName(entry.Name), *type, Null()}); + } + } + std::ranges::sort(table, {}, [](const auto& row) { + return std::tie(std::get(row[3]), std::get(row[2])); + }); + SetCursor(CreateVirtualCursor(kTablesSchema, std::move(table))); + return SQL_SUCCESS; +} + +SQLRETURN TStatement::GetTypeInfo(SQLSMALLINT dataType) { + ResetForMetadata(); + SetCursor(CreateVirtualCursor(kTypeInfoSchema, BuildTypeInfoRows(dataType))); + return SQL_SUCCESS; +} + +SQLRETURN TStatement::Statistics(const TMetadataArgument& catalogName, + const TMetadataArgument& schemaName, + const TMetadataArgument& tableName, + SQLUSMALLINT unique, SQLUSMALLINT accuracy) { + if (unique != SQL_INDEX_UNIQUE && unique != SQL_INDEX_ALL) { + return AddError("HY100", 0, "Invalid index uniqueness option"); + } + if (accuracy != SQL_QUICK && accuracy != SQL_ENSURE) { + return AddError("HY101", 0, "Invalid statistics accuracy option"); + } + if (!tableName) { + return AddError("HY009", 0, "TableName must not be null"); + } + if (Attributes_.GetMetadataId() == SQL_TRUE && (!catalogName || !schemaName)) { + return AddError("HY009", 0, "Identifier arguments must not be null"); + } + ResetForMetadata(); + if (!MetadataNamespaceMatches(catalogName, schemaName, false, false) + || tableName->empty()) { + SetCursor(CreateVirtualCursor(kStatisticsSchema)); + return SQL_SUCCESS; + } + + auto entries = GetMetadataEntries(tableName, false); + TTable table; + if (!entries.empty() && IsTable(entries.front().Type)) { + const auto& entry = entries.front(); + const std::string catalog = GetMetadataCatalogName(GetConnection()); + const std::string tableNameResult = GetMetadataTableName(entry.Name); + const bool withTableStatistics = accuracy == SQL_ENSURE; + DescribeTable(GetConnection(), entry.Name, [&](const auto& description) { + table.push_back({ + catalog, Null(), tableNameResult, Null(), Null(), Null(), I(SQL_TABLE_STAT), + Null(), Null(), Null(), + withTableStatistics ? Int32OrNull(description.GetTableRows()) : Null(), + Null(), Null(), + }); + + auto indexes = description.GetIndexDescriptions(); + const auto indexOrder = [](const auto& index) { + return std::pair{index.GetIndexType() != NTable::EIndexType::GlobalUnique, + index.GetIndexName()}; + }; + std::ranges::sort(indexes, {}, indexOrder); + for (const auto& index : indexes) { + const bool isUnique = index.GetIndexType() == NTable::EIndexType::GlobalUnique; + if (unique == SQL_INDEX_UNIQUE && !isUnique) { + continue; + } + SQLSMALLINT ordinal = 1; + for (const auto& column : index.GetIndexColumns()) { + table.push_back({ + catalog, Null(), tableNameResult, I(isUnique ? SQL_FALSE : SQL_TRUE), + Null(), index.GetIndexName(), I(SQL_INDEX_OTHER), I(ordinal++), column, + Null(), Null(), Null(), Null(), + }); + } + } + }, withTableStatistics); + } + SetCursor(CreateVirtualCursor(kStatisticsSchema, std::move(table))); + return SQL_SUCCESS; +} + +SQLRETURN TStatement::SpecialColumns(const TMetadataArgument& catalogName, + const TMetadataArgument& schemaName, + const TMetadataArgument& tableName, SQLUSMALLINT identifierType, + SQLUSMALLINT, SQLUSMALLINT nullable) { + if (identifierType != SQL_BEST_ROWID) { + return AddError("HYC00", 0, "Optional feature not implemented"); + } + if (nullable != SQL_NO_NULLS && nullable != SQL_NULLABLE) { + return AddError("HY099", 0, "Nullable type out of range"); + } + if (!tableName) { + return AddError("HY009", 0, "TableName must not be null"); + } + if (Attributes_.GetMetadataId() == SQL_TRUE && (!catalogName || !schemaName)) { + return AddError("HY009", 0, "Identifier arguments must not be null"); + } + ResetForMetadata(); + if (!MetadataNamespaceMatches(catalogName, schemaName, false, false)) { + SetCursor(CreateVirtualCursor(kSpecialColumnsSchema)); + return SQL_SUCCESS; + } + + auto entries = GetMetadataEntries(tableName, false); + if (entries.size() > 1) { + throw TOdbcException("HY000", 0, "Ambiguous table name"); + } + TTable table; + if (!entries.empty()) { + DescribeTable(GetConnection(), entries.front().Name, [&](const auto& description) { + const auto& columns = description.GetTableColumns(); + // A partial primary key cannot uniquely identify a row. + TTable identifierColumns; + for (const auto& pkName : description.GetPrimaryKeyColumns()) { + const auto column = std::ranges::find_if( + columns, [&](const auto& item) { return item.Name == pkName; }); + if (column == columns.end()) { + return; + } + const TYdbTypeInfo type = DescribeYdbType(column->Type); + if (nullable == SQL_NO_NULLS && !ColumnIsNotNull(*column, type)) { + return; + } + const TOdbcScalar size = GetColumnSize(type); + identifierColumns.push_back({I(SQL_SCOPE_SESSION), pkName, I(type.SqlType), type.TypeName, + size, size, Maybe(type.DecimalDigits), I(SQL_PC_NOT_PSEUDO)}); + } + table = std::move(identifierColumns); + }); + } + SetCursor(CreateVirtualCursor(kSpecialColumnsSchema, std::move(table))); + return SQL_SUCCESS; +} + +SQLRETURN TStatement::PrimaryKeys(const TMetadataArgument& catalogName, + const TMetadataArgument& schemaName, + const TMetadataArgument& tableName) { + if (!tableName) { + return AddError("HY009", 0, "TableName must not be null"); + } + if (Attributes_.GetMetadataId() == SQL_TRUE && (!catalogName || !schemaName)) { + return AddError("HY009", 0, "Identifier arguments must not be null"); + } + ResetForMetadata(); + if (!MetadataNamespaceMatches(catalogName, schemaName, false, false) + || tableName->empty()) { + SetCursor(CreateVirtualCursor(kPrimaryKeysSchema)); + return SQL_SUCCESS; + } + + auto entries = GetMetadataEntries(tableName, false); + TTable table; + if (!entries.empty()) { + const std::string catalog = GetMetadataCatalogName(GetConnection()); + DescribeTable(GetConnection(), entries.front().Name, [&](const auto& description) { + SQLSMALLINT sequence = 1; + for (const auto& name : description.GetPrimaryKeyColumns()) { + table.push_back({catalog, Null(), GetMetadataTableName(entries.front().Name), + name, I(sequence++), Null()}); + } + }); + } + SetCursor(CreateVirtualCursor(kPrimaryKeysSchema, std::move(table))); + return SQL_SUCCESS; +} + +SQLRETURN TStatement::ForeignKeys(const std::string&, const std::string&, const std::string&, + const std::string&, const std::string&, const std::string&) { + ResetForMetadata(); + SetCursor(CreateVirtualCursor(kForeignKeysSchema)); + return SQL_SUCCESS; +} + +SQLRETURN TStatement::ColumnPrivileges(const std::string&, const std::string&, + const std::string&, const std::string&) { + ResetForMetadata(); + SetCursor(CreateVirtualCursor(kColumnPrivilegesSchema)); + return SQL_SUCCESS; +} + +std::vector TStatement::GetMetadataEntries( + const TMetadataArgument& tableName, bool patternsAllowed) { + std::vector entries; + if (tableName && tableName->empty()) { + return entries; + } + + const std::string catalog = GetConnection().GetCatalogBinding().Catalog; + const std::string prefix = catalog.empty() || catalog == "/" ? "/" : catalog + "/"; + const std::string qualifiedName = tableName + ? (tableName->starts_with('/') ? *tableName : prefix + *tableName) : std::string{}; + if (tableName) { + if (catalog != "/" && qualifiedName != catalog && !qualifiedName.starts_with(prefix)) { + return entries; + } + } + + const auto [literalPrefix, hasWildcard] = patternsAllowed + ? GetLiteralPrefix(qualifiedName) : std::pair{qualifiedName, false}; + VisitEntry(catalog.empty() ? "/" : catalog, qualifiedName, + patternsAllowed, literalPrefix, hasWildcard, entries); + std::ranges::sort(entries, {}, &NScheme::TSchemeEntry::Name); + return entries; +} + +std::string TStatement::GetMetadataTableName(const std::string& path) const { + const std::string catalog = GetConnection().GetCatalogBinding().Catalog; + if (catalog == "/" && path.starts_with('/')) { + return path.substr(1); + } + const std::string prefix = catalog + "/"; + return path.starts_with(prefix) ? path.substr(prefix.size()) : path; +} + +bool TStatement::MetadataNamespaceMatches( + const TMetadataArgument& catalog, + const TMetadataArgument& schema, + bool catalogPatternsAllowed, + bool schemaPatternsAllowed) const { + const auto matches = [](std::string_view value, std::string_view argument, bool patterns) { + return patterns ? SqlLikeMatch(value, argument) : value == argument; + }; + const bool schemaMatches = !schema || matches("", *schema, schemaPatternsAllowed); + if (!catalog) { + return schemaMatches; + } + std::string_view catalogArgument = *catalog; + if (catalogArgument.starts_with('/')) { + catalogArgument.remove_prefix(1); + } + return schemaMatches + && matches(GetMetadataCatalogName(GetConnection()), catalogArgument, catalogPatternsAllowed); +} + +void TStatement::VisitEntry(const std::string& path, const std::string& tableName, + bool patternsAllowed, std::string_view literalPrefix, + bool hasWildcard, + std::vector& result) { + auto client = GetConnection().GetSchemeClient(); + if (!client) { + throw TOdbcException("HY000", 0, "No client connection"); + } + auto listing = client->ListDirectory(path).ExtractValueSync(); + NStatusHelpers::ThrowOnError(listing); + for (const auto& entry : listing.GetChildren()) { + const std::string fullPath = path == "/" ? path + entry.Name : path + "/" + entry.Name; + if (entry.Type == NScheme::ESchemeEntryType::Directory + || entry.Type == NScheme::ESchemeEntryType::SubDomain) { + if (tableName.empty() + || (literalPrefix.size() > fullPath.size() + && literalPrefix.starts_with(fullPath) + && literalPrefix[fullPath.size()] == '/') + || (hasWildcard && fullPath.starts_with(literalPrefix))) { + VisitEntry(fullPath, tableName, patternsAllowed, literalPrefix, hasWildcard, result); + } + } else if (tableName.empty() + || (patternsAllowed ? SqlLikeMatch(fullPath, tableName) + : fullPath == tableName)) { + result.push_back(entry); + result.back().Name = fullPath; + } + } +} + +std::optional TStatement::GetTableType(NScheme::ESchemeEntryType type) { + for (const auto& [entryType, name] : kTableTypes) { + if (entryType == type) { + return std::string(name); + } + } + return std::nullopt; +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/attr.h b/odbc/src/utils/attr.h new file mode 100644 index 00000000000..2a74fcaa011 --- /dev/null +++ b/odbc/src/utils/attr.h @@ -0,0 +1,120 @@ +#pragma once + +#include "diag.h" + +#include +#include +#include +#include +#include +#include + +#include "odbc_compat.h" + +namespace NYdb::NOdbc { + +inline std::string ReadAttributeString(SQLPOINTER value, SQLINTEGER length) { + const char* text = static_cast(value); + if (length == SQL_NTS) { + return std::string(text); + } + return length < 0 ? std::string() : std::string(text, static_cast(length)); +} + +template +T ReadIntegerAttr(SQLPOINTER value) noexcept { + if constexpr (std::is_pointer_v) { + return static_cast(value); + } else { + return static_cast(reinterpret_cast(value)); + } +} + +template +SQLRETURN SetCheckedAttribute( + SQLPOINTER value, + TOutput& output, + TErrorManager& errors, + std::string_view name, + TValid valid) { + const TInput input = ReadIntegerAttr(value); + if (!valid(input)) { + return Diag::AddInvalidAttrValue(errors, name); + } + output = static_cast(input); + return SQL_SUCCESS; +} + +template +struct TScalarProperty { + static constexpr SQLINTEGER Id = IdValue; + static constexpr auto Member = MemberValue; + static constexpr bool Readable = ReadableValue; + static constexpr bool Writable = WritableValue; +}; + +template +const T* ScalarValue(const T& value) { + return &value; +} + +template +const T* ScalarValue(const std::optional& value) { + return value ? &*value : nullptr; +} + +template +void SetScalarValue(T& property, SQLPOINTER value) { + property = ReadIntegerAttr(value); +} + +template +void SetScalarValue(std::optional& property, SQLPOINTER value) { + property = ReadIntegerAttr(value); +} + +template +class TScalarProperties { + template + static bool Visit(SQLINTEGER id, TObject& object, TCallback&& callback) { + return (((Write ? TProperties::Writable : TProperties::Readable) + && id == TProperties::Id + && (callback(object.*TProperties::Member), true)) || ...); + } + +public: + static bool CanSet(SQLINTEGER id) { + return ((TProperties::Writable && id == TProperties::Id) || ...); + } + + template + static std::optional Get( + SQLINTEGER id, + const TObject& object, + SQLPOINTER output, + SQLINTEGER* length = nullptr) { + SQLRETURN result = SQL_SUCCESS; + const bool found = Visit(id, object, [&](const auto& property) { + const auto* scalar = ScalarValue(property); + if (!scalar) { + result = SQL_NO_DATA; + return; + } + using TValue = std::remove_cvref_t; + *static_cast(output) = *scalar; + if (length) { + *length = sizeof(TValue); + } + }); + return found ? std::optional(result) : std::nullopt; + } + + template + static bool Set(SQLINTEGER id, TObject& object, SQLPOINTER value) { + return Visit(id, object, [&](auto& property) { + SetScalarValue(property, value); + }); + } +}; + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/bindings.h b/odbc/src/utils/bindings.h new file mode 100644 index 00000000000..80be3a7aaea --- /dev/null +++ b/odbc/src/utils/bindings.h @@ -0,0 +1,33 @@ +#pragma once + +#include "odbc_compat.h" + +namespace NYdb::NOdbc { + +enum class EWideTemporal { + None, + Date32, + Datetime64, + Timestamp64, +}; + +struct TBoundParam { + SQLUSMALLINT ParamNumber; + SQLSMALLINT ValueType; + SQLSMALLINT ParameterType; + SQLULEN ColumnSize; + SQLSMALLINT DecimalDigits; + SQLPOINTER ParameterValuePtr; + SQLLEN BufferLength; + SQLLEN* StrLenOrIndPtr; + bool AtExec = false; + bool IsNullData = false; + EWideTemporal WideTemporal = EWideTemporal::None; +}; + +inline bool BoundParamIsNull(const TBoundParam& param) noexcept { + return param.IsNullData + || (param.StrLenOrIndPtr && *param.StrLenOrIndPtr == SQL_NULL_DATA); +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/convert.cpp b/odbc/src/utils/convert.cpp new file mode 100644 index 00000000000..253991755c2 --- /dev/null +++ b/odbc/src/utils/convert.cpp @@ -0,0 +1,1087 @@ +#include "convert.h" +#include "sql_type_map.h" +#include "util.h" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { +namespace { + +thread_local const char* LastConvertSqlState = nullptr; + +SQLRETURN Error(const char* state = nullptr) { + LastConvertSqlState = state; + return SQL_ERROR; +} + +template +std::optional CheckedInteger(From value) { + if (!std::in_range(value)) { + Error("22003"); + return std::nullopt; + } + return static_cast(value); +} + +template +std::optional ReadInteger(const TBoundParam& param) { + if (!param.ParameterValuePtr) { + return std::nullopt; + } + const auto value = VisitCInteger(param.ValueType, [&](auto type) { + using T = typename decltype(type)::type; + return CheckedInteger(*static_cast(param.ParameterValuePtr)); + }); + return value ? *value : std::nullopt; +} + +template +std::optional ReadReal(const TBoundParam& param) { + if (!param.ParameterValuePtr) { + return std::nullopt; + } + if (param.ValueType == SQL_C_FLOAT) { + return static_cast(*static_cast(param.ParameterValuePtr)); + } + if (param.ValueType == SQL_C_DOUBLE) { + return static_cast(*static_cast(param.ParameterValuePtr)); + } + return std::nullopt; +} + +std::optional ReadBytes(const TBoundParam& param) { + if (!param.ParameterValuePtr) { + return std::nullopt; + } + const char* data = static_cast(param.ParameterValuePtr); + SQLLEN length = param.StrLenOrIndPtr ? *param.StrLenOrIndPtr : param.BufferLength; + if (length == SQL_NTS) { + return std::string(data); + } + if (length < 0) { + length = param.BufferLength; + } + if (length < 0) { + return std::nullopt; + } + return std::string(data, static_cast(length)); +} + +std::optional ReadCharacterText(const TBoundParam& param) { + if (param.ValueType == SQL_C_CHAR) { + return ReadBytes(param); + } + if (param.ValueType != SQL_C_WCHAR || !param.ParameterValuePtr) { + return std::nullopt; + } + const SQLLEN length = param.StrLenOrIndPtr ? *param.StrLenOrIndPtr : param.BufferLength; + if (length == SQL_NTS) { + return GetString(static_cast(param.ParameterValuePtr), SQL_NTS); + } + if (length < 0 || length % static_cast(sizeof(SQLWCHAR))) { + Error("22018"); + return std::nullopt; + } + return GetString(static_cast(param.ParameterValuePtr), + static_cast(length / sizeof(SQLWCHAR))); +} + +std::optional NormalizeIntegerText(std::string_view text) { + std::string digits(text); + int exponent = 0; + bool largeExponent = false; + const auto e = digits.find_first_of("eE"); + if (e != std::string::npos) { + const char* begin = digits.data() + e + 1; + const char* end = digits.data() + digits.size(); + const bool negative = begin != end && *begin == '-'; + if (begin != end && (*begin == '+' || *begin == '-')) ++begin; + if (begin == end || !std::isdigit(static_cast(*begin))) { + Error("22018"); + return std::nullopt; + } + const auto parsed = std::from_chars(begin, end, exponent); + if (parsed.ptr != end || parsed.ec == std::errc::invalid_argument) { + Error("22018"); + return std::nullopt; + } + largeExponent = parsed.ec == std::errc::result_out_of_range; + if (negative) exponent = -exponent; + digits.resize(e); + } + const auto dot = digits.find('.'); + const auto fraction = dot == std::string::npos ? 0 : digits.size() - dot - 1; + if (dot != std::string::npos) digits.erase(dot, 1); + const size_t sign = digits.starts_with('-') ? 1 : 0; + if (digits.size() == sign || !std::all_of(digits.begin() + sign, digits.end(), [](unsigned char ch) { return std::isdigit(ch); })) { + Error("22018"); + return std::nullopt; + } + const auto first = digits.find_first_not_of('0', sign); + if (first == std::string::npos) return "0"; + digits.erase(sign, first - sign); + const int64_t shift = static_cast(exponent) - static_cast(fraction); + if (largeExponent || shift > 20 || (shift < 0 && (static_cast(-shift) >= digits.size() - sign + || digits.find_first_not_of('0', digits.size() - static_cast(-shift)) != std::string::npos))) { + Error("22001"); + return std::nullopt; + } + if (shift < 0) digits.resize(digits.size() - static_cast(-shift)); + else digits.append(static_cast(shift), '0'); + return digits; +} + +std::string ReadNumericStruct(const SQL_NUMERIC_STRUCT& numeric) { + unsigned __int128 magnitude = 0; + for (size_t i = 0; i < SQL_MAX_NUMERIC_LEN; ++i) { + magnitude |= static_cast(numeric.val[i]) << (i * 8); + } + std::string digits; + do { + digits.push_back(static_cast('0' + magnitude % 10)); + magnitude /= 10; + } while (magnitude); + std::reverse(digits.begin(), digits.end()); + const int scale = numeric.scale; + if (scale < 0) { + digits.append(static_cast(-scale), '0'); + } else if (scale > 0) { + if (digits.size() <= static_cast(scale)) { + digits.insert(0, static_cast(scale) + 1 - digits.size(), '0'); + } + digits.insert(digits.size() - static_cast(scale), 1, '.'); + } + if (numeric.sign == 0 && digits != "0") { + digits.insert(digits.begin(), '-'); + } + return digits; +} + +std::string FormatInstant(TInstant value, const char* format, bool fraction); + +std::optional ReadText(const TBoundParam& param) { + if (!param.ParameterValuePtr) { + return std::nullopt; + } + if (auto text = ReadCharacterText(param)) { + return text; + } + if (param.ValueType == SQL_C_NUMERIC) { + return ReadNumericStruct(*static_cast(param.ParameterValuePtr)); + } + if (const auto value = VisitCInteger(param.ValueType, [&](auto type) { + return std::to_string(*static_cast(param.ParameterValuePtr)); + })) { + return value; + } + if (param.ValueType == SQL_C_TYPE_DATE || param.ValueType == SQL_C_DATE + || param.ValueType == SQL_C_TYPE_TIMESTAMP || param.ValueType == SQL_C_TIMESTAMP) { + const bool date = param.ValueType == SQL_C_TYPE_DATE || param.ValueType == SQL_C_DATE; + SQL_TIMESTAMP_STRUCT value{}; + if (date) { + const auto& v = *static_cast(param.ParameterValuePtr); + value = {v.year, v.month, v.day, 0, 0, 0, 0}; + } else { + value = *static_cast(param.ParameterValuePtr); + } + if (value.year < 1 || value.year > 9999 || value.month > 12 || value.day > 31 + || !std::chrono::year_month_day(std::chrono::year(value.year), + std::chrono::month(value.month), std::chrono::day(value.day)).ok() + || value.hour > 23 || value.minute > 59 || value.second > 59 || value.fraction >= 1000000000U) { + Error("22008"); + return std::nullopt; + } + char buffer[64]; + std::snprintf(buffer, sizeof(buffer), "%04d-%02u-%02u %02u:%02u:%02u", + value.year, value.month, value.day, value.hour, value.minute, value.second); + std::string text(buffer, date ? 10 : 19); + if (value.fraction) { + char suffix[11]; + std::snprintf(suffix, sizeof(suffix), ".%09u", value.fraction); + text += suffix; + while (text.back() == '0') text.pop_back(); + } + return text; + } + if (param.ValueType == SQL_C_TYPE_TIME || param.ValueType == SQL_C_TIME) { + const auto time = *static_cast(param.ParameterValuePtr); + if (time.hour > 23 || time.minute > 59 || time.second > 59) { + Error("22008"); + return std::nullopt; + } + char text[32]; + std::snprintf(text, sizeof(text), "%02u:%02u:%02u", time.hour, time.minute, time.second); + return text; + } + if (param.ValueType == SQL_C_FLOAT || param.ValueType == SQL_C_DOUBLE) { + const auto text = param.ValueType == SQL_C_FLOAT + ? FloatToString(*static_cast(param.ParameterValuePtr)) + : FloatToString(*static_cast(param.ParameterValuePtr)); + return std::string(text.data(), text.size()); + } + return std::nullopt; +} + +std::string FormatDecimalText(const TDecimalValue& decimal) { + std::string text = decimal.ToString(); + const size_t point = text.find('.'); + const size_t fraction = point == std::string::npos ? 0 : text.size() - point - 1; + if (decimal.DecimalType_.Scale > fraction) { + if (point == std::string::npos) { + text.push_back('.'); + } + text.append(decimal.DecimalType_.Scale - fraction, '0'); + } + return text; +} + +using TSqlTime = std::chrono::sys_time; + +std::optional ReadTemporal(const TBoundParam& param, EParamType type) { + if (!param.ParameterValuePtr) return std::nullopt; + const bool date = type == EParamType::Date || type == EParamType::Date32; + const bool time = type == EParamType::Datetime; + int year = 1970; + unsigned month = 1, day = 1, hour = 0, minute = 0, second = 0, fraction = 0; + if (param.ValueType == SQL_C_CHAR || param.ValueType == SQL_C_WCHAR) { + auto text = ReadCharacterText(param); + if (!text) return std::nullopt; + const auto first = text->find_first_not_of(" \t\r\n"); + if (first == std::string::npos) { Error("22018"); return std::nullopt; } + text->erase(text->find_last_not_of(" \t\r\n") + 1); + text->erase(0, first); + if (text->size() >= 8 && (*text)[2] == ':' && (*text)[5] == ':') { + *text = (time ? "1970-01-01T" : FormatInstant(TInstant::Now(), "%Y-%m-%dT", false)) + *text; + } + std::tm parts = {}; + std::istringstream input(*text); + const auto next = [&] { return input.eof() ? EOF : input.peek(); }; + input >> std::get_time(&parts, "%Y-%m-%d"); + if (!input.fail() && next() != EOF && (next() == 'T' || next() == ' ')) { + input.get(); + input >> std::get_time(&parts, "%H:%M:%S"); + } else if (time) { + Error("22018"); return std::nullopt; + } + if (input.fail()) { Error("22018"); return std::nullopt; } + if (next() == '.') { + input.get(); + unsigned digits = 0; + while (next() >= '0' && next() <= '9') { + const unsigned digit = input.get() - '0'; + if (digits < 6) fraction = fraction * 10 + digit; + else if (digit != 0) { Error("22008"); return std::nullopt; } + ++digits; + } + if (!digits) { Error("22018"); return std::nullopt; } + while (digits++ < 6) fraction *= 10; + fraction *= 1000; + } + if (next() == 'Z') input.get(); + if (next() != EOF) { Error("22018"); return std::nullopt; } + year = parts.tm_year + 1900; month = parts.tm_mon + 1; day = parts.tm_mday; + hour = parts.tm_hour; minute = parts.tm_min; second = parts.tm_sec; + if ((date && (hour || minute || second || fraction)) || (time && fraction)) { + Error("22008"); return std::nullopt; + } + if (time) { year = 1970; month = day = 1; } + } else if (date && (param.ValueType == SQL_C_TYPE_DATE || param.ValueType == SQL_C_DATE)) { + const auto& v = *static_cast(param.ParameterValuePtr); + year = v.year; month = v.month; day = v.day; + } else if (time && (param.ValueType == SQL_C_TYPE_TIME || param.ValueType == SQL_C_TIME)) { + const auto& v = *static_cast(param.ParameterValuePtr); + hour = v.hour; minute = v.minute; second = v.second; + } else if (!date && !time && (param.ValueType == SQL_C_TYPE_TIMESTAMP || param.ValueType == SQL_C_TIMESTAMP)) { + const auto& v = *static_cast(param.ParameterValuePtr); + year = v.year; month = v.month; day = v.day; + hour = v.hour; minute = v.minute; second = v.second; fraction = v.fraction; + } else { Error("22007"); return std::nullopt; } + const std::chrono::year_month_day civil{std::chrono::year(year), std::chrono::month(month), std::chrono::day(day)}; + if (year < 1 || year > 32767 || !civil.ok() || hour > 23 || minute > 59 || second > 59 + || fraction >= 1000000000) { + Error("22007"); return std::nullopt; + } + if (fraction % 1000 || (type == EParamType::Datetime64 && fraction)) { + Error("22008"); return std::nullopt; + } + const auto value = std::chrono::sys_days(civil) + std::chrono::hours(hour) + std::chrono::minutes(minute) + + std::chrono::seconds(second) + std::chrono::microseconds(fraction / 1000); + if ((type == EParamType::Date || type == EParamType::Datetime || type == EParamType::Timestamp) + && (value.time_since_epoch().count() < 0 || year >= 2106)) { + Error("22008"); return std::nullopt; + } + return value; +} + +template +SQLRETURN CopyVariable(SQLLEN size, SQLLEN terminator, SQLLEN unit, + SQLPOINTER target, SQLLEN bufferLength, SQLLEN* indicator, + SQLLEN* offset, Copy copy) { + if (offset && *offset < 0) { + return SQL_NO_DATA; + } + const SQLLEN start = offset ? *offset : 0; + if (start < 0 || start > size || start % unit) { + return Error("HY090"); + } + const SQLLEN remaining = size - start; + SQLLEN copied = 0; + if (target && bufferLength >= terminator) { + SQLLEN capacity = bufferLength - terminator; + capacity -= capacity % unit; + copied = std::min(remaining, capacity); + if (copied) { + copy(target, start, copied); + } + if (terminator) { + std::memset(static_cast(target) + copied, 0, terminator); + } + } + if (offset) { + *offset = copied == remaining ? -1 : start + copied; + } + if (indicator) { + *indicator = remaining; + } + return target && copied < remaining ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS; +} + +SQLRETURN CopyVariable(const void* data, SQLLEN size, SQLLEN terminator, SQLLEN unit, + SQLPOINTER target, SQLLEN bufferLength, SQLLEN* indicator, + SQLLEN* offset) { + return CopyVariable(size, terminator, unit, target, bufferLength, indicator, offset, + [data](SQLPOINTER destination, SQLLEN start, SQLLEN copied) { + std::memcpy(destination, static_cast(data) + start, copied); + }); +} + +template +SQLRETURN WriteScalar(Value value, SQLPOINTER target, SQLLEN* indicator) { + if (target) { + *static_cast(target) = value; + } + if (indicator) { + *indicator = sizeof(Value); + } + return SQL_SUCCESS; +} + +template +SQLRETURN WriteCheckedInteger(Source value, SQLPOINTER target, SQLLEN* indicator) { + const auto converted = CheckedInteger(value); + return converted ? WriteScalar(*converted, target, indicator) : SQL_ERROR; +} + +bool IsUnsignedIntegerTarget(SQLSMALLINT type) { + return type == SQL_C_UTINYINT || type == SQL_C_USHORT + || type == SQL_C_ULONG || type == SQL_C_UBIGINT; +} + +bool IsIntegerTarget(SQLSMALLINT type) { + return IsUnsignedIntegerTarget(type) || type == SQL_C_TINYINT || type == SQL_C_STINYINT + || type == SQL_C_SHORT || type == SQL_C_SSHORT || type == SQL_C_LONG + || type == SQL_C_SLONG || type == SQL_C_SBIGINT || type == SQL_C_BIT; +} + +template +SQLRETURN WriteInteger(Source value, SQLSMALLINT type, SQLPOINTER target, SQLLEN* indicator) { + if (type == SQL_C_BIT) { + if (value != 0 && value != 1) { + return Error("22003"); + } + return WriteScalar(value != 0, target, indicator); + } + return VisitCInteger(type, [&](auto targetType) { + using T = typename decltype(targetType)::type; + return WriteCheckedInteger(value, target, indicator); + }).value_or(SQL_ERROR); +} + +SQLRETURN WriteReal(double value, SQLSMALLINT type, SQLPOINTER target, SQLLEN* indicator) { + return type == SQL_C_DOUBLE + ? WriteScalar(value, target, indicator) + : WriteScalar(static_cast(value), target, indicator); +} + +std::optional GetAsTime(TValueParser& parser, EPrimitiveType type) { + switch (type) { + case EPrimitiveType::Date: return TSqlTime(std::chrono::microseconds(parser.GetDate().MicroSeconds())); + case EPrimitiveType::Datetime: return TSqlTime(std::chrono::microseconds(parser.GetDatetime().MicroSeconds())); + case EPrimitiveType::Timestamp: return TSqlTime(std::chrono::microseconds(parser.GetTimestamp().MicroSeconds())); + case EPrimitiveType::Date32: return parser.GetDate32(); + case EPrimitiveType::Datetime64: return parser.GetDatetime64(); + case EPrimitiveType::Timestamp64: return parser.GetTimestamp64(); + case EPrimitiveType::TzDate: + case EPrimitiveType::TzDatetime: + case EPrimitiveType::TzTimestamp: { + const std::string value = type == EPrimitiveType::TzDate ? parser.GetTzDate() + : type == EPrimitiveType::TzDatetime ? parser.GetTzDatetime() + : parser.GetTzTimestamp(); + TInstant instant; + if (TInstant::TryParseIso8601(value, instant)) { + return TSqlTime(std::chrono::microseconds(instant.MicroSeconds())); + } + break; + } + default: return std::nullopt; + } + Error("22007"); + return std::nullopt; +} + +SQLRETURN WriteTemporal(TValueParser& parser, EPrimitiveType type, SQLSMALLINT targetType, + SQLPOINTER target, SQLLEN* indicator) { + const auto instant = GetAsTime(parser, type); + struct tm value = {}; + if (!instant) { + return SQL_ERROR; + } + const auto seconds = std::chrono::floor(*instant); + const time_t epoch = seconds.time_since_epoch().count(); + if (!GmTimeR(&epoch, &value) || value.tm_year + 1900 < 1 || value.tm_year + 1900 > 32767) { + return Error("22007"); + } + if (targetType == SQL_C_TYPE_DATE || targetType == SQL_C_DATE) { + SQL_DATE_STRUCT out{static_cast(value.tm_year + 1900), + static_cast(value.tm_mon + 1), + static_cast(value.tm_mday)}; + return WriteScalar(out, target, indicator); + } + if (targetType == SQL_C_TYPE_TIME || targetType == SQL_C_TIME) { + SQL_TIME_STRUCT out{static_cast(value.tm_hour), + static_cast(value.tm_min), + static_cast(value.tm_sec)}; + return WriteScalar(out, target, indicator); + } + SQL_TIMESTAMP_STRUCT out{static_cast(value.tm_year + 1900), + static_cast(value.tm_mon + 1), + static_cast(value.tm_mday), + static_cast(value.tm_hour), + static_cast(value.tm_min), + static_cast(value.tm_sec), + static_cast((*instant - seconds).count()) * 1000}; + return WriteScalar(out, target, indicator); +} + +SQLRETURN WriteNumericStruct(std::string text, SQLPOINTER target, SQLLEN* indicator, + SQLULEN precision, SQLSMALLINT scale) { + bool positive = true; + if (!text.empty() && (text.front() == '-' || text.front() == '+')) { + positive = text.front() != '-'; + text.erase(text.begin()); + } + const auto point = text.find('.'); + if (point != std::string::npos) { + text.erase(point, 1); + } + while (!text.empty() && text.front() == '0') { + text.erase(text.begin()); + } + if (text.empty()) { + text = "0"; + } + unsigned __int128 magnitude = 0; + for (const char ch : text) { + if (ch < '0' || ch > '9') { + return Error("22018"); + } + const auto previous = magnitude; + magnitude = magnitude * 10 + static_cast(ch - '0'); + if (magnitude < previous) { + return Error("22003"); + } + } + if (target) { + auto& out = *static_cast(target); + std::memset(&out, 0, sizeof(out)); + out.precision = static_cast(precision); + out.scale = static_cast(scale); + out.sign = positive ? 1 : 0; + for (size_t i = 0; i < SQL_MAX_NUMERIC_LEN; ++i) { + out.val[i] = static_cast(magnitude & 0xff); + magnitude >>= 8; + } + if (magnitude) { + return Error("22003"); + } + } + if (indicator) { + *indicator = sizeof(SQL_NUMERIC_STRUCT); + } + return SQL_SUCCESS; +} + +SQLRETURN WriteText(std::string_view text, SQLSMALLINT type, SQLPOINTER target, + SQLLEN bufferLength, SQLLEN* indicator, SQLLEN* offset) { + if (type == SQL_C_CHAR) { + return CopyVariable(text.data(), text.size(), 1, 1, target, bufferLength, indicator, offset); + } + if (type != SQL_C_WCHAR) { + return SQL_ERROR; + } + try { + const TUtf16String wide = UTF8ToWide(text); + static_assert(sizeof(SQLWCHAR) == 2 || sizeof(SQLWCHAR) == 4); + if constexpr (sizeof(TUtf16String::value_type) == sizeof(SQLWCHAR)) { + return CopyVariable(wide.data(), wide.size() * sizeof(SQLWCHAR), sizeof(SQLWCHAR), + sizeof(SQLWCHAR), target, bufferLength, indicator, offset); + } else { + std::basic_string odbcWide; + odbcWide.reserve(wide.size()); + for (size_t i = 0; i < wide.size(); ++i) { + uint32_t codePoint = wide[i]; + if (codePoint >= 0xd800 && codePoint <= 0xdbff) { + if (i + 1 >= wide.size() + || wide[i + 1] < 0xdc00 || wide[i + 1] > 0xdfff) { + return Error("22018"); + } + codePoint = 0x10000 + + ((codePoint - 0xd800) << 10) + + (wide[++i] - 0xdc00); + } else if (codePoint >= 0xdc00 && codePoint <= 0xdfff) { + return Error("22018"); + } + odbcWide.push_back(static_cast(codePoint)); + } + return CopyVariable(odbcWide.data(), odbcWide.size() * sizeof(SQLWCHAR), + sizeof(SQLWCHAR), sizeof(SQLWCHAR), target, bufferLength, + indicator, offset); + } + } catch (...) { + return Error("22018"); + } +} + +template +SQLRETURN WriteNumberText(Number value, SQLSMALLINT type, SQLPOINTER target, + SQLLEN bufferLength, SQLLEN* indicator, SQLLEN* offset) { + char text[128]; + const auto [end, error] = std::to_chars(text, text + sizeof(text), value); + if (error != std::errc{}) return Error("22003"); + return WriteText(std::string_view(text, end - text), type, target, bufferLength, indicator, offset); +} + +template +std::optional ParseDecimalInteger(const std::string& text) { + try { + const std::string integral = text.substr(0, text.find('.')); + if constexpr (std::is_unsigned_v) { + if (!integral.empty() && integral.front() == '-') { + throw std::out_of_range("negative"); + } + } + size_t parsed = 0; + const Integer value = std::is_unsigned_v + ? static_cast(std::stoull(integral, &parsed)) + : static_cast(std::stoll(integral, &parsed)); + if (parsed != integral.size()) { + throw std::invalid_argument("decimal"); + } + return value; + } catch (...) { + Error("22003"); + return std::nullopt; + } +} + +SQLRETURN ConvertDecimal(TValueParser& parser, SQLSMALLINT type, SQLPOINTER target, + SQLLEN bufferLength, SQLLEN* indicator, SQLLEN* offset) { + const TDecimalValue decimal = parser.GetDecimal(); + const std::string text = FormatDecimalText(decimal); + if (type == SQL_C_DOUBLE || type == SQL_C_FLOAT) { + try { + return WriteReal(std::stod(text), type, target, indicator); + } catch (...) { + return Error("22003"); + } + } + if (type == SQL_C_NUMERIC) { + return WriteNumericStruct(text, target, indicator, decimal.DecimalType_.Precision, + decimal.DecimalType_.Scale); + } + if (IsIntegerTarget(type)) { + if (IsUnsignedIntegerTarget(type)) { + const auto value = ParseDecimalInteger(text); + return value ? WriteInteger(*value, type, target, indicator) : SQL_ERROR; + } + const auto value = ParseDecimalInteger(text); + return value ? WriteInteger(*value, type, target, indicator) : SQL_ERROR; + } + return WriteText(text, type, target, bufferLength, indicator, offset); +} + +template +TOdbcScalar MakeScalar(Value value) { + if constexpr (std::is_floating_point_v) { + return double(value); + } else if constexpr (std::is_unsigned_v) { + return uint64_t(value); + } else { + return int64_t(value); + } +} + +template +std::optional ReadScalar(const TBoundParam& param) { + if (!param.ParameterValuePtr) return std::nullopt; + if (param.ValueType == SQL_C_CHAR || param.ValueType == SQL_C_WCHAR) { + const auto text = ReadCharacterText(param); + if (!text) { + return std::nullopt; + } + const auto first = text->find_first_not_of(" \t\r\n"); + const auto last = text->find_last_not_of(" \t\r\n"); + if (first != std::string::npos) { + const char* begin = text->data() + first; + const char* end = text->data() + last + 1; + if (*begin == '+') { + if (++begin == end || *begin == '+' || *begin == '-') { + Error("22018"); + return std::nullopt; + } + } + Value value{}; + if constexpr (std::is_floating_point_v) { + if (std::string_view(begin, end - begin).find_first_of("xX") == std::string_view::npos + && TryFromString(begin, end - begin, value)) { + if (std::isfinite(value)) return value; + Error("22003"); + return std::nullopt; + } + Error("22018"); + } else { + auto parsed = std::from_chars(begin, end, value); + if (parsed.ec == std::errc{} && parsed.ptr == end) { + return value; + } + if (parsed.ptr != end) { + const auto integer = NormalizeIntegerText(std::string_view(begin, end - begin)); + if (!integer) return std::nullopt; + parsed = std::from_chars(integer->data(), integer->data() + integer->size(), value); + if (parsed.ec == std::errc{} && parsed.ptr == integer->data() + integer->size()) return value; + } + Error(parsed.ec == std::errc::result_out_of_range ? "22001" : "22018"); + } + } else { + Error("22018"); + } + return std::nullopt; + } + if constexpr (std::is_floating_point_v) { + if (const auto value = ReadReal(param)) return value; + return VisitCInteger(param.ValueType, [&](auto type) { + return static_cast(*static_cast(param.ParameterValuePtr)); + }); + } else { + if (const auto real = ReadReal(param)) { + const double value = std::trunc(*real); + if (!std::isfinite(value) || value < static_cast(std::numeric_limits::lowest()) + || value >= std::ldexp(1.0, std::numeric_limits::digits)) { + Error("22003"); + return std::nullopt; + } + return static_cast(value); + } + return ReadInteger(param); + } +} + +template +void PutParamValue(TParamValueBuilder& builder, bool optional, Put&& put) { + if (optional) { + builder.BeginOptional(); + } + put(builder); + if (optional) { + builder.EndOptional(); + } +} + +template +std::optional VisitScalar(ScalarType type, Fn&& fn) { +#define ODBC_VISIT_SCALAR(name, cppType, sqlType, isUnsigned) \ + case ScalarType::name: \ + return fn.template operator()( \ + [](TValueParser& parser) { return parser.Get##name(); }, \ + [](TParamValueBuilder& builder, cppType value, bool optional) { \ + PutParamValue(builder, optional, \ + [&](TParamValueBuilder& item) { item.name(value); }); \ + }); + switch (type) { + YDB_ODBC_SCALAR_TYPES(ODBC_VISIT_SCALAR) + default: + return std::nullopt; + } +#undef ODBC_VISIT_SCALAR +} + +std::optional ParamPrimitive(EParamType type) { +#define ODBC_PARAM_PRIMITIVE(name, cppType, sqlType, isUnsigned) \ + case EParamType::name: \ + return EPrimitiveType::name; + switch (type) { + YDB_ODBC_SCALAR_TYPES(ODBC_PARAM_PRIMITIVE) + case EParamType::Bool: + return EPrimitiveType::Bool; + case EParamType::Utf8: + return EPrimitiveType::Utf8; + case EParamType::String: + return EPrimitiveType::String; + case EParamType::Date: + return EPrimitiveType::Date; + case EParamType::Datetime: + return EPrimitiveType::Datetime; + case EParamType::Timestamp: + return EPrimitiveType::Timestamp; + case EParamType::Date32: return EPrimitiveType::Date32; + case EParamType::Datetime64: return EPrimitiveType::Datetime64; + case EParamType::Timestamp64: return EPrimitiveType::Timestamp64; + case EParamType::Decimal: + return std::nullopt; + } +#undef ODBC_PARAM_PRIMITIVE + return std::nullopt; +} + +std::optional PrimitiveScalar(TValueParser& parser, EPrimitiveType type) { + if (auto scalar = VisitScalar(type, [&](auto get, auto) { + return MakeScalar(get(parser)); + })) { + return *scalar; + } + switch (type) { + case EPrimitiveType::Bool: return TOdbcScalar{int64_t(parser.GetBool())}; + case EPrimitiveType::Uuid: return TOdbcScalar{parser.GetUuid().ToString()}; + default: return std::nullopt; + } +} + +std::optional PrimitiveText(TValueParser& parser, EPrimitiveType type) { + switch (type) { + case EPrimitiveType::Utf8: return parser.GetUtf8(); + case EPrimitiveType::String: return parser.GetString(); + case EPrimitiveType::Yson: return parser.GetYson(); + case EPrimitiveType::Json: return parser.GetJson(); + case EPrimitiveType::JsonDocument: return parser.GetJsonDocument(); + case EPrimitiveType::DyNumber: return parser.GetDyNumber(); + default: return std::nullopt; + } +} + +std::string FormatInstant(TInstant value, const char* format, bool fraction) { + const TString formatted = value.FormatGmTime(format); + std::string text(formatted.data(), formatted.size()); + if (fraction && value.MicroSecondsOfSecond()) { + char suffix[8] = {}; + std::snprintf(suffix, sizeof(suffix), ".%06u", value.MicroSecondsOfSecond()); + text += suffix; + } + return text; +} + +std::optional TemporalText(TValueParser& parser, EPrimitiveType type) { + switch (type) { + case EPrimitiveType::Date: + return FormatInstant(parser.GetDate(), "%Y-%m-%d", false); + case EPrimitiveType::Datetime: + return FormatInstant(parser.GetDatetime(), "%Y-%m-%d %H:%M:%S", false); + case EPrimitiveType::Timestamp: + return FormatInstant(parser.GetTimestamp(), "%Y-%m-%d %H:%M:%S", true); + case EPrimitiveType::Date32: + case EPrimitiveType::Datetime64: + case EPrimitiveType::Timestamp64: { + SQL_TIMESTAMP_STRUCT value; + if (WriteTemporal(parser, type, SQL_C_TYPE_TIMESTAMP, &value, nullptr) != SQL_SUCCESS) return std::nullopt; + char text[48]; + if (type == EPrimitiveType::Date32) { + std::snprintf(text, sizeof(text), "%04d-%02u-%02u", value.year, value.month, value.day); + } else { + std::snprintf(text, sizeof(text), "%04d-%02u-%02u %02u:%02u:%02u.%06u", value.year, value.month, + value.day, value.hour, value.minute, value.second, value.fraction / 1000); + } + return text; + } + case EPrimitiveType::TzDate: return parser.GetTzDate(); + case EPrimitiveType::TzDatetime: return parser.GetTzDatetime(); + case EPrimitiveType::TzTimestamp: return parser.GetTzTimestamp(); + default: return std::nullopt; + } +} + +template +bool PutValue(std::optional value, Put put) { + if (!value) { + return false; + } + put(*value); + return true; +} + +bool ConvertParamValue( + const TBoundParam& param, + EParamType type, + TParamValueBuilder& builder, + bool optional) +{ + if (auto converted = VisitScalar(type, [&](auto, auto put) { + return PutValue(ReadScalar(param), [&](T value) { + put(builder, value, optional); + }); + })) { + return *converted; + } + switch (type) { + case EParamType::Bool: { + const auto value = ReadScalar(param); + if (!value) { + return false; + } + if (*value == 0 || *value == 1) { + if ((param.ValueType == SQL_C_CHAR || param.ValueType == SQL_C_WCHAR) + && !ReadScalar(param)) return false; + PutParamValue(builder, optional, + [&](TParamValueBuilder& item) { item.Bool(*value != 0); }); + return true; + } + Error(*value > 0 && *value < 2 ? "22001" : "22003"); + return false; + } + case EParamType::Utf8: + return PutValue(param.ValueType == SQL_C_BINARY ? ReadBytes(param) : ReadText(param), [&](const auto& v) { + PutParamValue(builder, optional, + [&](TParamValueBuilder& item) { item.Utf8(v); }); + }); + case EParamType::String: { + auto value = param.ValueType == SQL_C_BINARY ? ReadBytes(param) : ReadCharacterText(param); + if (value && param.ValueType != SQL_C_BINARY) { + try { + const auto bytes = HexDecode(value->data(), value->size()); + value = std::string(bytes.data(), bytes.size()); + } catch (const yexception&) { + Error("22018"); + return false; + } + } + if (value) { + PutParamValue(builder, optional, + [&](TParamValueBuilder& item) { item.String(*value); }); + } + return value.has_value(); + } + case EParamType::Date: + case EParamType::Datetime: + case EParamType::Timestamp: + case EParamType::Date32: + case EParamType::Datetime64: + case EParamType::Timestamp64: { + const auto value = ReadTemporal(param, type); + if (!value) { + return false; + } + PutParamValue(builder, optional, [&](TParamValueBuilder& item) { + if (type == EParamType::Date) { + item.Date(TInstant::MicroSeconds(value->time_since_epoch().count())); + } else if (type == EParamType::Datetime) { + item.Datetime(TInstant::MicroSeconds(value->time_since_epoch().count())); + } else if (type == EParamType::Date32) { + item.Date32(std::chrono::floor(*value)); + } else if (type == EParamType::Datetime64) { + item.Datetime64(std::chrono::floor(*value)); + } else if (type == EParamType::Timestamp64) { + item.Timestamp64(*value); + } else { + item.Timestamp(TInstant::MicroSeconds(value->time_since_epoch().count())); + } + }); + return true; + } + default: return false; + } +} + +} // namespace + +SQLRETURN ConvertParam( + const TBoundParam& param, + TParamValueBuilder& builder, + bool optional) +{ + LastConvertSqlState = nullptr; + const auto type = ResolveParamType(param); + if (!type) { + return SQL_ERROR; + } + if (BoundParamIsNull(param)) { + TTypeBuilder itemType; + if (type->Type == EParamType::Decimal) { + itemType.Decimal(TDecimalType(static_cast(type->Precision), + static_cast(type->Scale))); + } else { + const auto primitive = ParamPrimitive(type->Type); + if (!primitive) { + return SQL_ERROR; + } + itemType.Primitive(*primitive); + } + builder.EmptyOptional(itemType.Build()).Build(); + return SQL_SUCCESS; + } + if (type->Type == EParamType::Decimal) { + const auto text = ReadText(param); + if (!text) { + return SQL_ERROR; + } + try { + const TDecimalValue value(*text, static_cast(type->Precision), + static_cast(type->Scale)); + PutParamValue(builder, optional, + [&](TParamValueBuilder& item) { item.Decimal(value); }); + } catch (...) { + return Error("22018"); + } + builder.Build(); + return SQL_SUCCESS; + } + if (!ConvertParamValue(param, type->Type, builder, optional)) { + return SQL_ERROR; + } + builder.Build(); + return SQL_SUCCESS; +} + +SQLRETURN ConvertColumn(const TOdbcScalar& value, SQLSMALLINT targetType, SQLPOINTER targetValue, + SQLLEN bufferLength, SQLLEN* strLenOrInd, SQLLEN* offset) { + LastConvertSqlState = nullptr; + if (bufferLength < 0) { + return Error("HY090"); + } + if (std::holds_alternative(value)) { + if (!strLenOrInd) { + return Error("22002"); + } + *strLenOrInd = SQL_NULL_DATA; + return SQL_SUCCESS; + } + return std::visit( + [&](const auto& scalar) -> SQLRETURN { + using T = std::decay_t; + if constexpr (std::is_same_v) { + return WriteText( + scalar, targetType, targetValue, bufferLength, strLenOrInd, offset); + } else if constexpr (std::is_same_v) { + return SQL_ERROR; + } else { + if constexpr (!std::is_floating_point_v) { + if (IsIntegerTarget(targetType)) { + return WriteInteger(scalar, targetType, targetValue, strLenOrInd); + } + } + if (targetType == SQL_C_DOUBLE || targetType == SQL_C_FLOAT) { + return WriteReal(scalar, targetType, targetValue, strLenOrInd); + } + if (targetType == SQL_C_CHAR || targetType == SQL_C_WCHAR) { + return WriteNumberText(scalar, targetType, targetValue, bufferLength, strLenOrInd, offset); + } + return SQL_ERROR; + } + }, + value); +} + +SQLRETURN ConvertColumn(TValueParser& parser, SQLSMALLINT targetType, SQLPOINTER targetValue, + SQLLEN bufferLength, SQLLEN* strLenOrInd, SQLLEN* offset) { + LastConvertSqlState = nullptr; + if (bufferLength < 0) { + return Error("HY090"); + } + if (parser.GetKind() == TTypeParser::ETypeKind::Null || parser.IsNull()) { + if (!strLenOrInd) { + return Error("22002"); + } + *strLenOrInd = SQL_NULL_DATA; + return SQL_SUCCESS; + } + if (parser.GetKind() == TTypeParser::ETypeKind::Optional) { + parser.OpenOptional(); + const SQLRETURN result = ConvertColumn( + parser, targetType, targetValue, bufferLength, strLenOrInd, offset); + parser.CloseOptional(); + return result; + } + if (parser.GetKind() == TTypeParser::ETypeKind::Decimal) { + return ConvertDecimal(parser, targetType, targetValue, bufferLength, strLenOrInd, offset); + } + if (parser.GetKind() != TTypeParser::ETypeKind::Primitive) { + return SQL_ERROR; + } + const EPrimitiveType type = parser.GetPrimitiveType(); + if (targetType == SQL_C_TYPE_DATE || targetType == SQL_C_DATE + || targetType == SQL_C_TYPE_TIME || targetType == SQL_C_TIME + || targetType == SQL_C_TYPE_TIMESTAMP || targetType == SQL_C_TIMESTAMP) { + return WriteTemporal(parser, type, targetType, targetValue, strLenOrInd); + } + if (targetType == SQL_C_BINARY) { + if (type != EPrimitiveType::String) { + return SQL_ERROR; + } + const std::string& bytes = parser.GetString(); + return CopyVariable(bytes.data(), bytes.size(), 0, 1, targetValue, bufferLength, + strLenOrInd, offset); + } + if (type == EPrimitiveType::String && (targetType == SQL_C_CHAR || targetType == SQL_C_WCHAR)) { + const auto& bytes = parser.GetString(); + const SQLLEN unit = targetType == SQL_C_WCHAR ? sizeof(SQLWCHAR) : 1; + return CopyVariable(bytes.size() * 2 * unit, unit, unit, targetValue, bufferLength, + strLenOrInd, offset, [&](SQLPOINTER destination, SQLLEN start, SQLLEN copied) { + const auto fill = [&](Char* text) { + for (SQLLEN i = 0; i < copied / unit; ++i) { + const SQLLEN nibble = start / unit + i; + const unsigned char byte = bytes[nibble / 2]; + text[i] = "0123456789abcdef"[nibble % 2 ? byte & 15 : byte >> 4]; + } + }; + if (targetType == SQL_C_WCHAR) fill(static_cast(destination)); + else fill(static_cast(destination)); + }); + } + if (const auto text = PrimitiveText(parser, type)) { + return WriteText(*text, targetType, targetValue, bufferLength, strLenOrInd, offset); + } + if (type == EPrimitiveType::Float && (targetType == SQL_C_CHAR || targetType == SQL_C_WCHAR)) { + return WriteNumberText(parser.GetFloat(), targetType, targetValue, bufferLength, strLenOrInd, offset); + } + if (const auto scalar = PrimitiveScalar(parser, type)) { + return ConvertColumn(*scalar, targetType, targetValue, bufferLength, strLenOrInd, offset); + } + const auto text = TemporalText(parser, type); + return text ? WriteText(*text, targetType, targetValue, bufferLength, strLenOrInd, offset) + : SQL_ERROR; +} + +const char* ConsumeLastConvertSqlState() { + const char* result = LastConvertSqlState; + LastConvertSqlState = nullptr; + return result; +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/convert.h b/odbc/src/utils/convert.h new file mode 100644 index 00000000000..2050068576b --- /dev/null +++ b/odbc/src/utils/convert.h @@ -0,0 +1,26 @@ +#pragma once + +#include "bindings.h" + +#include + +#include "odbc_compat.h" + +#include +#include + +namespace NYdb::NOdbc { + +using TOdbcScalar = std::variant; + +SQLRETURN ConvertParam( + const TBoundParam& param, + TParamValueBuilder& builder, + bool optional = false); +SQLRETURN ConvertColumn(const TOdbcScalar& value, SQLSMALLINT targetType, SQLPOINTER targetValue, + SQLLEN bufferLength, SQLLEN* strLenOrInd, SQLLEN* offset = nullptr); +SQLRETURN ConvertColumn(TValueParser& parser, SQLSMALLINT targetType, SQLPOINTER targetValue, + SQLLEN bufferLength, SQLLEN* strLenOrInd, SQLLEN* offset = nullptr); +const char* ConsumeLastConvertSqlState(); + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/cursor.cpp b/odbc/src/utils/cursor.cpp new file mode 100644 index 00000000000..2f32df31ad3 --- /dev/null +++ b/odbc/src/utils/cursor.cpp @@ -0,0 +1,395 @@ +#include "cursor.h" +#include "error_manager.h" +#include "sql_type_map.h" +#include "types.h" + +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { + +std::vector MakeColumnMeta(const TResultSet& resultSet, bool parameters) { + std::vector columns; + columns.reserve(resultSet.GetColumnsMeta().size()); + for (const auto& column : resultSet.GetColumnsMeta()) { + const TYdbTypeInfo type = DescribeYdbType(column.Type); + SQLSMALLINT sqlType = type.SqlType; + const EWideTemporal wide = type.TypeName == "Date32" ? EWideTemporal::Date32 + : type.TypeName == "Datetime64" ? EWideTemporal::Datetime64 + : type.TypeName == "Timestamp64" ? EWideTemporal::Timestamp64 : EWideTemporal::None; + if (parameters) { + const auto* spec = FindSqlTypeSpec(sqlType); + // YDB Datetime contains a date, unlike SQL_TYPE_TIME. + if (!spec || sqlType == SQL_TYPE_TIME + || (sqlType != SQL_DECIMAL && spec->YqlType != type.TypeName && wide == EWideTemporal::None)) { + sqlType = SQL_UNKNOWN_TYPE; + } + } + // YQL qualifies unaliased JOIN projections; dots are forbidden in SQL aliases. + const size_t dot = column.Name.rfind('.'); + columns.push_back({dot == std::string::npos ? column.Name : column.Name.substr(dot + 1), + sqlType, type.ColumnSize, type.Nullable, + type.DecimalDigits.value_or(parameters && sqlType == SQL_TYPE_TIMESTAMP + && wide != EWideTemporal::Datetime64 ? 6 : 0), + type.Unsigned, wide}); + } + return columns; +} + +namespace { + +using TResultRow = std::vector; +using TResultRows = std::vector; + +TResultRow MaterializeRow(TResultSetParser& parser) { + TResultRow row; + row.reserve(parser.ColumnsCount()); + for (size_t column = 0; column < parser.ColumnsCount(); ++column) { + row.push_back(parser.GetValue(column)); + } + return row; +} + +size_t ToSize(SQLULEN value) { + const uintmax_t wide = static_cast(value); + return wide > std::numeric_limits::max() + ? std::numeric_limits::max() + : static_cast(wide); +} + +uintmax_t NegativeMagnitude(SQLLEN value) { + return static_cast(-(value + 1)) + 1; +} + +class TForwardCursor final : public ICursor { +public: + explicit TForwardCursor(const TResultSet& resultSet) + : ICursor(MakeColumnMeta(resultSet)) + , Parser_(resultSet) + {} + + TFetchResult Fetch( + SQLSMALLINT orientation, + SQLLEN, + SQLULEN rowsetSize, + SQLULEN maxRows) override + { + CurrentRows_.clear(); + if (orientation != SQL_FETCH_NEXT) { + return {}; + } + + const size_t wanted = ToSize(rowsetSize); + const size_t limit = maxRows == 0 + ? Parser_.RowsCount() + : std::min(Parser_.RowsCount(), ToSize(maxRows)); + const size_t remaining = limit - std::min(RowsRead_, limit); + CurrentRows_.reserve(std::min(wanted, remaining)); + while (CurrentRows_.size() < wanted && RowsRead_ < limit + && Parser_.TryNextRow()) { + CurrentRows_.push_back(MaterializeRow(Parser_)); + ++RowsRead_; + } + return {static_cast(CurrentRows_.size()), false}; + } + + SQLULEN GetRowNumber() const override { + return CurrentRows_.empty() + ? 0 + : static_cast(RowsRead_ - CurrentRows_.size() + 1); + } + + SQLRETURN GetData(SQLULEN row, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, + SQLPOINTER targetValue, SQLLEN bufferLength, SQLLEN* strLenOrInd, + SQLLEN* offset) override { + const size_t rowIndex = ToSize(row); + if (rowIndex >= CurrentRows_.size()) { + return SQL_NO_DATA; + } + if (columnNumber < 1 || columnNumber > Columns_.size()) { + return SQL_ERROR; + } + TValueParser parser(CurrentRows_[rowIndex][columnNumber - 1]); + return ConvertColumn( + parser, targetType, targetValue, bufferLength, strLenOrInd, offset); + } + +private: + TResultSetParser Parser_; + TResultRows CurrentRows_; + size_t RowsRead_ = 0; +}; + +class TStaticCursor final : public ICursor { +public: + explicit TStaticCursor(const TResultSet& resultSet) + : ICursor(MakeColumnMeta(resultSet), resultSet.RowsCount()) + , Parser_(resultSet) + {} + + SQLRETURN GetData(SQLULEN row, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, + SQLPOINTER targetValue, SQLLEN bufferLength, SQLLEN* strLenOrInd, + SQLLEN* offset) override { + const auto rowIndex = CurrentRow(row); + if (!rowIndex) { + return SQL_NO_DATA; + } + if (columnNumber < 1 || columnNumber > Columns_.size()) { + return SQL_ERROR; + } + EnsureRow(*rowIndex); + TValueParser parser(Rows_[*rowIndex][columnNumber - 1]); + return ConvertColumn( + parser, targetType, targetValue, bufferLength, strLenOrInd, offset); + } + +private: + void EnsureRow(size_t rowIndex) { + while (Rows_.size() <= rowIndex) { + if (!Parser_.TryNextRow()) { + throw TOdbcException( + "HY000", 0, + "ODBC cursor result ended before its declared row count"); + } + Rows_.push_back(MaterializeRow(Parser_)); + } + } + + TResultSetParser Parser_; + TResultRows Rows_; +}; + +class TVirtualCursor final : public ICursor { +public: + TVirtualCursor(TColumnSchema columns, TTable table) + : ICursor(std::vector(columns.begin(), columns.end()), table.size()) + , Table_(std::move(table)) + {} + + SQLRETURN GetData(SQLULEN row, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, + SQLPOINTER targetValue, SQLLEN bufferLength, SQLLEN* strLenOrInd, + SQLLEN* offset) override { + const auto rowIndex = CurrentRow(row); + if (!rowIndex) { + return SQL_NO_DATA; + } + if (columnNumber < 1 || columnNumber > Columns_.size()) { + return SQL_ERROR; + } + return ConvertColumn(Table_[*rowIndex][columnNumber - 1], targetType, + targetValue, bufferLength, strLenOrInd, offset); + } + +private: + TTable Table_; +}; + +} // namespace + +TCursorWindow::TCursorWindow(size_t totalRows) + : TotalRows_(totalRows) +{} + +class TCursorWindow::TPositionResolver { +public: + struct TTarget { + EPosition Position; + size_t Start = 0; + bool OverlappedStart = false; + }; + + TPositionResolver( + const TCursorWindow& window, + size_t rowsetSize, + SQLULEN requestedRowsetSize, + size_t visibleRows) + : Window_(window) + , RowsetSize_(rowsetSize) + , RequestedRowsetSize_(static_cast(requestedRowsetSize)) + , VisibleRows_(visibleRows) + {} + + TTarget Resolve(SQLSMALLINT orientation, SQLLEN offset) const { + switch (orientation) { + case SQL_FETCH_NEXT: { + if (Window_.Position_ == EPosition::Before) { + return Rowset(0); + } + return Window_.Position_ == EPosition::After + ? Boundary(EPosition::After) + : Forward(Window_.Start_, Window_.PreviousRowsetSize_); + } + case SQL_FETCH_PRIOR: { + if (Window_.Position_ == EPosition::Before) { + return Boundary(EPosition::Before); + } + const size_t origin = Window_.Position_ == EPosition::After + ? VisibleRows_ + : Window_.Start_; + return Backward(origin, RowsetSize_, origin > 0); + } + case SQL_FETCH_FIRST: + return Rowset(0); + case SQL_FETCH_LAST: + return VisibleRows_ == 0 + ? Boundary(EPosition::After) + : Rowset(VisibleRows_ > RowsetSize_ + ? VisibleRows_ - RowsetSize_ + : 0); + case SQL_FETCH_ABSOLUTE: + return Absolute(offset); + case SQL_FETCH_RELATIVE: { + if (Window_.Position_ == EPosition::Before) { + return offset > 0 ? Absolute(offset) : Boundary(EPosition::Before); + } + if (Window_.Position_ == EPosition::After) { + return offset < 0 ? Absolute(offset) : Boundary(EPosition::After); + } + if (offset >= 0) { + return Forward(Window_.Start_, static_cast(offset)); + } + return Backward( + Window_.Start_, NegativeMagnitude(offset), Window_.Start_ > 0); + } + default: + return Boundary(Window_.Position_ == EPosition::After + ? EPosition::After + : EPosition::Before); + } + } + +private: + static TTarget Boundary(EPosition position) { + return {position}; + } + + static TTarget Rowset(size_t start, bool overlappedStart = false) { + return {EPosition::Rowset, start, overlappedStart}; + } + + TTarget Positive(uintmax_t start) const { + return start > std::numeric_limits::max() + ? Boundary(EPosition::After) + : Rowset(static_cast(start)); + } + + TTarget Forward(size_t origin, uintmax_t distance) const { + return distance > std::numeric_limits::max() - origin + ? Boundary(EPosition::After) + : Positive(static_cast(origin) + distance); + } + + TTarget Backward(size_t origin, uintmax_t distance, bool allowOverlap) const { + if (distance <= origin) { + return Rowset(origin - static_cast(distance)); + } + const uintmax_t rowsBeforeStart = distance - origin; + return allowOverlap && rowsBeforeStart < RequestedRowsetSize_ + ? Rowset(0, true) + : Boundary(EPosition::Before); + } + + TTarget Absolute(SQLLEN offset) const { + if (offset > 0) { + return Positive(static_cast(offset) - 1); + } + if (offset == 0) { + return Boundary(EPosition::Before); + } + return Backward( + VisibleRows_, NegativeMagnitude(offset), VisibleRows_ > 0); + } + + const TCursorWindow& Window_; + size_t RowsetSize_; + uintmax_t RequestedRowsetSize_; + size_t VisibleRows_; +}; + +TFetchResult TCursorWindow::Fetch( + SQLSMALLINT orientation, + SQLLEN offset, + SQLULEN rowsetSize, + SQLULEN maxRows) +{ + if (rowsetSize == 0) { + SetBoundary(EPosition::Before); + return {}; + } + + const size_t rowset = ToSize(rowsetSize); + const size_t visibleRows = maxRows == 0 + ? TotalRows_ + : std::min(TotalRows_, ToSize(maxRows)); + const auto target = TPositionResolver(*this, rowset, rowsetSize, visibleRows) + .Resolve(orientation, offset); + + if (target.Position != EPosition::Rowset) { + SetBoundary(target.Position); + return {}; + } + if (target.Start >= visibleRows + || target.Start > static_cast(std::numeric_limits::max())) { + SetBoundary(EPosition::After); + return {}; + } + + Position_ = EPosition::Rowset; + Start_ = target.Start; + Size_ = std::min(rowset, visibleRows - target.Start); + PreviousRowsetSize_ = rowset; + return {static_cast(Size_), target.OverlappedStart}; +} + +std::optional TCursorWindow::Resolve(SQLULEN row) const { + if (Position_ != EPosition::Rowset + || static_cast(row) >= Size_) { + return std::nullopt; + } + return Start_ + static_cast(row); +} + +SQLULEN TCursorWindow::RowNumber() const { + return Position_ == EPosition::Rowset + ? static_cast(Start_) + 1 + : 0; +} + +void TCursorWindow::SetBoundary(EPosition position) { + Position_ = position; + Start_ = 0; + Size_ = 0; +} + +TFetchResult ICursor::Fetch( + SQLSMALLINT orientation, + SQLLEN offset, + SQLULEN rowsetSize, + SQLULEN maxRows) +{ + return Window_.Fetch(orientation, offset, rowsetSize, maxRows); +} + +SQLULEN ICursor::GetRowNumber() const { + return Window_.RowNumber(); +} + +std::optional ICursor::CurrentRow(SQLULEN row) const { + return Window_.Resolve(row); +} + +std::unique_ptr CreateExecCursor(TResultSet resultSet, bool scrollable) { + if (scrollable) { + return std::make_unique(resultSet); + } + return std::make_unique(resultSet); +} + +std::unique_ptr CreateVirtualCursor(TColumnSchema columns, TTable table) { + return std::make_unique(columns, std::move(table)); +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/cursor.h b/odbc/src/utils/cursor.h new file mode 100644 index 00000000000..a93b0734c88 --- /dev/null +++ b/odbc/src/utils/cursor.h @@ -0,0 +1,69 @@ +#pragma once + +#include "convert.h" +#include "cursor_window.h" + +#include +#include "odbc_compat.h" + +#include +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { + +struct TColumnMeta { + std::string Name; + SQLSMALLINT SqlType; + SQLULEN Size; + SQLSMALLINT Nullable; + SQLSMALLINT DecimalDigits = 0; + bool Unsigned = false; + EWideTemporal WideTemporal = EWideTemporal::None; +}; + +using TColumnSchema = std::span; +using TTable = std::vector>; + +class ICursor { +public: + virtual ~ICursor() = default; + virtual TFetchResult Fetch( + SQLSMALLINT orientation, + SQLLEN offset, + SQLULEN rowsetSize, + SQLULEN maxRows); + virtual SQLULEN GetRowNumber() const; + virtual SQLRETURN GetData(SQLULEN row, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, + SQLPOINTER targetValue, SQLLEN bufferLength, SQLLEN* strLenOrInd, + SQLLEN* offset = nullptr) = 0; + const std::vector& GetColumnMeta() const { + return Columns_; + } + +protected: + explicit ICursor(std::vector columns = {}, size_t rows = 0) + : Columns_(std::move(columns)) + , Window_(rows) + {} + + std::optional CurrentRow(SQLULEN row) const; + + std::vector Columns_; + +private: + TCursorWindow Window_; +}; + +std::vector MakeColumnMeta(const TResultSet& resultSet, bool parameters = false); + +std::unique_ptr CreateExecCursor(TResultSet resultSet, bool scrollable); + +std::unique_ptr CreateVirtualCursor( + TColumnSchema columns, + TTable table = {}); + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/cursor_window.h b/odbc/src/utils/cursor_window.h new file mode 100644 index 00000000000..14891cc421e --- /dev/null +++ b/odbc/src/utils/cursor_window.h @@ -0,0 +1,45 @@ +#pragma once + +#include "odbc_compat.h" + +#include +#include + +namespace NYdb::NOdbc { + +struct TFetchResult { + SQLULEN Rows = 0; + bool OverlappedStart = false; +}; + +class TCursorWindow { +public: + explicit TCursorWindow(size_t totalRows = 0); + + TFetchResult Fetch( + SQLSMALLINT orientation, + SQLLEN offset, + SQLULEN rowsetSize, + SQLULEN maxRows); + std::optional Resolve(SQLULEN row) const; + SQLULEN RowNumber() const; + +private: + enum class EPosition { + Before, + Rowset, + After, + }; + + class TPositionResolver; + + void SetBoundary(EPosition position); + + size_t TotalRows_ = 0; + EPosition Position_ = EPosition::Before; + size_t Start_ = 0; + size_t Size_ = 0; + size_t PreviousRowsetSize_ = 0; +}; + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/diag.h b/odbc/src/utils/diag.h new file mode 100644 index 00000000000..c5c0371b42a --- /dev/null +++ b/odbc/src/utils/diag.h @@ -0,0 +1,139 @@ +#pragma once + +#include "error_manager.h" + +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { +namespace Diag { + +inline SQLRETURN AddNullPointer(TErrorManager& errors) { + return errors.AddError("HY009", 0, "Invalid use of null pointer"); +} + +inline SQLRETURN AddNotImplemented(TErrorManager& errors) { + return errors.AddError("HYC00", 0, "Optional feature not implemented"); +} + +inline SQLRETURN AddInvalidAttrValue(TErrorManager& errors, std::string_view name) { + return errors.AddError("HY024", 0, "Invalid " + std::string(name) + " value"); +} + +inline SQLRETURN AddInvalidBufferLength(TErrorManager& errors) { + return errors.AddError("HY090", 0, "Invalid string or buffer length"); +} + +inline SQLRETURN AddRightTruncated(TErrorManager& errors) { + return errors.AddError("01004", 0, "String data, right truncated", SQL_SUCCESS_WITH_INFO); +} + +enum class EStringWriteMode : unsigned char { + Odbc, + OptionalOdbc, + Diagnostic, + ConnectionAttribute, + Descriptor, + ColumnAttribute, +}; + +template +SQLRETURN WriteString(TErrorManager* errors, std::string_view value, SQLPOINTER output, + TLength bufferLength, TLength* length) { + const SQLLEN fullLength = static_cast(value.size()); + const auto reportLength = [&] { + if (length) { + if constexpr (Mode == EStringWriteMode::Odbc + || Mode == EStringWriteMode::Diagnostic + || Mode == EStringWriteMode::ColumnAttribute) { + *length = static_cast(std::min( + fullLength, std::numeric_limits::max())); + } else { + *length = static_cast(fullLength); + } + } + }; + if constexpr (Mode == EStringWriteMode::OptionalOdbc) { + if (bufferLength < 0) { + return AddInvalidBufferLength(*errors); + } + reportLength(); + if (!output) { + return SQL_SUCCESS; + } + } + if constexpr (Mode == EStringWriteMode::Diagnostic + || Mode == EStringWriteMode::ConnectionAttribute + || Mode == EStringWriteMode::Descriptor) { + reportLength(); + } + if constexpr (Mode == EStringWriteMode::ColumnAttribute) { + if (bufferLength < 0 || (!output && bufferLength != 0)) { + return AddInvalidBufferLength(*errors); + } + } + if (!output) { + if constexpr (Mode == EStringWriteMode::Diagnostic + || Mode == EStringWriteMode::ConnectionAttribute + || Mode == EStringWriteMode::Descriptor) { + return SQL_SUCCESS; + } else if constexpr (Mode == EStringWriteMode::Odbc) { + return AddNullPointer(*errors); + } + } + if (bufferLength < 0) { + if constexpr (Mode == EStringWriteMode::Diagnostic) { + return SQL_ERROR; + } + return AddInvalidBufferLength(*errors); + } + if constexpr (Mode == EStringWriteMode::Odbc + || Mode == EStringWriteMode::ColumnAttribute) { + reportLength(); + } + if constexpr (Mode == EStringWriteMode::ConnectionAttribute) { + if (bufferLength == 0) { + return AddInvalidBufferLength(*errors); + } + } + if (bufferLength == 0) { + if (!fullLength) { + return SQL_SUCCESS; + } + if constexpr (Mode == EStringWriteMode::Diagnostic) { + return SQL_SUCCESS_WITH_INFO; + } + return AddRightTruncated(*errors); + } + const SQLLEN copied = std::min(fullLength, bufferLength - 1); + if (copied) { + std::memcpy(output, value.data(), static_cast(copied)); + } + static_cast(output)[copied] = 0; + if (copied == fullLength) { + return SQL_SUCCESS; + } + if constexpr (Mode == EStringWriteMode::Diagnostic) { + return SQL_SUCCESS_WITH_INFO; + } + return AddRightTruncated(*errors); +} + +inline SQLRETURN WriteOdbcString(TErrorManager& errors, std::string_view value, SQLPOINTER output, + SQLSMALLINT bufferLength, SQLSMALLINT* length) { + return WriteString(&errors, value, output, bufferLength, length); +} + +template +SQLRETURN WriteOptionalOdbcString(TErrorManager& errors, std::string_view value, SQLPOINTER output, + TLength bufferLength, TLength* length) { + return WriteString( + &errors, value, output, bufferLength, length); +} + +} // namespace Diag + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/error_manager.cpp b/odbc/src/utils/error_manager.cpp new file mode 100644 index 00000000000..eee81ca3971 --- /dev/null +++ b/odbc/src/utils/error_manager.cpp @@ -0,0 +1,180 @@ +#include "error_manager.h" +#include "diag.h" + +#include + +namespace NYdb::NOdbc { + +namespace { + struct OdbcErrorMapping { + const char* sqlState; + const char* description; + SQLRETURN returnCode; + }; + + OdbcErrorMapping GetErrorMappingForStatus(EStatus status) { +#define ODBC_STATUS(name, state, text, result) case EStatus::name: return {state, text, result} + switch (status) { + ODBC_STATUS(SUCCESS, "00000", "Success", SQL_SUCCESS); + ODBC_STATUS(BAD_REQUEST, "42000", "Syntax error or access rule violation", SQL_ERROR); + ODBC_STATUS(UNAUTHORIZED, "28000", "Invalid authorization specification", SQL_ERROR); + ODBC_STATUS(INTERNAL_ERROR, "HY000", "General error", SQL_ERROR); + ODBC_STATUS(ABORTED, "40001", "Serialization failure", SQL_ERROR); + ODBC_STATUS(UNAVAILABLE, "08S01", "Communication link failure", SQL_ERROR); + ODBC_STATUS(OVERLOADED, "HY000", "General error - server overloaded", SQL_ERROR); + ODBC_STATUS(SCHEME_ERROR, "42S02", "Base table or view not found", SQL_ERROR); + ODBC_STATUS(GENERIC_ERROR, "HY000", "General error", SQL_ERROR); + ODBC_STATUS(TIMEOUT, "HYT00", "Timeout expired", SQL_ERROR); + ODBC_STATUS(BAD_SESSION, "08003", "Connection does not exist", SQL_ERROR); + ODBC_STATUS(PRECONDITION_FAILED, "23000", "Integrity constraint violation", SQL_ERROR); + ODBC_STATUS(ALREADY_EXISTS, "23000", "Integrity constraint violation", SQL_ERROR); + ODBC_STATUS(NOT_FOUND, "02000", "No data found", SQL_NO_DATA); + ODBC_STATUS(SESSION_EXPIRED, "08003", "Connection does not exist", SQL_ERROR); + ODBC_STATUS(CANCELLED, "HY008", "Operation canceled", SQL_ERROR); + ODBC_STATUS(UNDETERMINED, "40003", "Statement completion unknown", SQL_ERROR); + ODBC_STATUS(UNSUPPORTED, "HYC00", "Optional feature not implemented", SQL_ERROR); + ODBC_STATUS(SESSION_BUSY, "HY000", "General error - session busy", SQL_ERROR); + ODBC_STATUS(TRANSPORT_UNAVAILABLE, "08S01", "Communication link failure", SQL_ERROR); + ODBC_STATUS(CLIENT_RESOURCE_EXHAUSTED, "HY000", "General error - resource exhausted", SQL_ERROR); + ODBC_STATUS(CLIENT_DEADLINE_EXCEEDED, "HYT00", "Timeout expired", SQL_ERROR); + ODBC_STATUS(CLIENT_INTERNAL_ERROR, "HY000", "General error", SQL_ERROR); + ODBC_STATUS(CLIENT_CANCELLED, "HY008", "Operation canceled", SQL_ERROR); + ODBC_STATUS(CLIENT_UNAUTHENTICATED, "28000", "Invalid authorization specification", SQL_ERROR); + ODBC_STATUS(CLIENT_LIMITS_REACHED, "HY000", "General error - limits reached", SQL_ERROR); + ODBC_STATUS(CLIENT_DISCOVERY_FAILED, "08001", "Client unable to establish connection", SQL_ERROR); + ODBC_STATUS(CLIENT_CALL_UNIMPLEMENTED, "HYC00", "Optional feature not implemented", SQL_ERROR); + ODBC_STATUS(CLIENT_OUT_OF_RANGE, "22003", "Numeric value out of range", SQL_ERROR); + default: return {"HY000", "Unknown YDB error", SQL_ERROR}; + } +#undef ODBC_STATUS + } + + SQLRETURN WriteDiagCStr(std::string_view value, SQLPOINTER output, SQLSMALLINT bufferLength, + SQLSMALLINT* length, bool sqlState = false) { + std::string normalized; + if (sqlState) { + normalized = value; + normalized.resize(5, ' '); + value = normalized; + } + return Diag::WriteString( + nullptr, value, output, bufferLength, length); + } + +} // namespace + +SQLRETURN RecordCurrentException(TErrorManager& errors) { + try { + throw; + } catch (const NStatusHelpers::TYdbErrorException& ex) { + return errors.AddError(ex.GetStatus()); + } catch (const TOdbcException& ex) { + return errors.AddError(ex); + } catch (const std::exception& ex) { + return errors.AddError("HY000", 0, ex.what()); + } catch (...) { + return errors.AddError("HY000", 0, "Unknown error"); + } +} + +SQLRETURN TErrorManager::AddError(const std::string& sqlState, SQLINTEGER nativeError, const std::string& message, SQLRETURN returnCode) { + Errors_.push_back({sqlState, nativeError, message}); + LastReturnCode_ = returnCode; + return returnCode; +} + +SQLRETURN TErrorManager::AddError(const TOdbcException& ex) { + Errors_.push_back({ex.GetSqlState(), ex.GetNativeError(), ex.GetMessage()}); + LastReturnCode_ = ex.GetReturnCode(); + return ex.GetReturnCode(); +} + +SQLRETURN TErrorManager::AddError(const TStatus& status) { + auto mapping = GetErrorMappingForStatus(status.GetStatus()); + std::string message = mapping.description; + if (!status.GetIssues().Empty()) { + message += ": " + status.GetIssues().ToString(); + } + Errors_.push_back({mapping.sqlState, static_cast(status.GetStatus()), message}); + LastReturnCode_ = mapping.returnCode; + return mapping.returnCode; +} + +void TErrorManager::ClearErrors() { + Errors_.clear(); +} + +SQLRETURN TErrorManager::GetDiagRec(SQLSMALLINT recNumber, SQLCHAR* sqlState, SQLINTEGER* nativeError, + SQLCHAR* messageText, SQLSMALLINT bufferLength, SQLSMALLINT* textLength) { + if (recNumber < 1 || recNumber > (SQLSMALLINT)Errors_.size()) { + return SQL_NO_DATA; + } + + const auto& err = Errors_[recNumber-1]; + + if (sqlState) { + WriteDiagCStr(err.SqlState, sqlState, 6, nullptr, true); + } + + if (nativeError) { + *nativeError = err.NativeError; + } + + return WriteDiagCStr(err.Message, messageText, bufferLength, textLength, false); +} + +SQLRETURN TErrorManager::GetDiagField(SQLSMALLINT recNumber, SQLSMALLINT diagIdentifier, SQLPOINTER diagInfoPtr, + SQLSMALLINT bufferLength, SQLSMALLINT* stringLengthPtr) { + const SQLSMALLINT count = static_cast(Errors_.size()); + if (diagInfoPtr == nullptr) { + return SQL_ERROR; + } + if (recNumber == 0) { + switch (diagIdentifier) { + case SQL_DIAG_RETURNCODE: + *static_cast(diagInfoPtr) = LastReturnCode_; + return SQL_SUCCESS; + case SQL_DIAG_NUMBER: { + *static_cast(diagInfoPtr) = static_cast(count); + return SQL_SUCCESS; + } + case SQL_DIAG_ROW_COUNT: + return SQL_ERROR; + default: + return SQL_ERROR; + } + } + + if (recNumber < 1 || recNumber > count) { + return SQL_NO_DATA; + } + + const auto& err = Errors_[recNumber - 1]; + switch (diagIdentifier) { + case SQL_DIAG_SQLSTATE: + return WriteDiagCStr(err.SqlState, diagInfoPtr, bufferLength, stringLengthPtr, true); + case SQL_DIAG_NATIVE: { + *static_cast(diagInfoPtr) = err.NativeError; + return SQL_SUCCESS; + } + case SQL_DIAG_MESSAGE_TEXT: + return WriteDiagCStr(err.Message, diagInfoPtr, bufferLength, stringLengthPtr); + case SQL_DIAG_CLASS_ORIGIN: + return WriteDiagCStr("ODBC 3.0", diagInfoPtr, bufferLength, stringLengthPtr); + case SQL_DIAG_SUBCLASS_ORIGIN: + return WriteDiagCStr("ODBC 3.0", diagInfoPtr, bufferLength, stringLengthPtr); + case SQL_DIAG_CONNECTION_NAME: + case SQL_DIAG_SERVER_NAME: + return WriteDiagCStr("", diagInfoPtr, bufferLength, stringLengthPtr); + case SQL_DIAG_COLUMN_NUMBER: + *static_cast(diagInfoPtr) = SQL_COLUMN_NUMBER_UNKNOWN; + return SQL_SUCCESS; + case SQL_DIAG_ROW_NUMBER: + *static_cast(diagInfoPtr) = SQL_ROW_NUMBER_UNKNOWN; + return SQL_SUCCESS; + default: + return SQL_ERROR; + } +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/error_manager.h b/odbc/src/utils/error_manager.h new file mode 100644 index 00000000000..808bb0ffb02 --- /dev/null +++ b/odbc/src/utils/error_manager.h @@ -0,0 +1,80 @@ +#pragma once + +#include "odbc_compat.h" +#include +#include +#include + +#include + +namespace NYdb::NOdbc { + +struct TErrorInfo { + std::string SqlState; + SQLINTEGER NativeError; + std::string Message; +}; + +class TOdbcException : public std::exception { +public: + TOdbcException(const std::string& sqlState, SQLINTEGER nativeError, + const std::string& message, SQLRETURN returnCode = SQL_ERROR) + : SqlState_(sqlState) + , NativeError_(nativeError) + , Message_(message) + , ReturnCode_(returnCode) + {} + + const std::string& GetSqlState() const { + return SqlState_; + } + + SQLINTEGER GetNativeError() const { + return NativeError_; + } + + const std::string& GetMessage() const { + return Message_; + } + + SQLRETURN GetReturnCode() const { + return ReturnCode_; + } + + const char* what() const noexcept override { + return Message_.c_str(); + } + +private: + std::string SqlState_; + SQLINTEGER NativeError_; + std::string Message_; + SQLRETURN ReturnCode_; +}; + +class TErrorManager { +public: + virtual ~TErrorManager() = default; + SQLRETURN AddError(const std::string& sqlState, SQLINTEGER nativeError, const std::string& message, SQLRETURN returnCode = SQL_ERROR); + SQLRETURN AddError(const TOdbcException& ex); + SQLRETURN AddError(const TStatus& status); + + void ClearErrors(); + + void SetLastReturnCode(SQLRETURN code) { + LastReturnCode_ = code; + } + + SQLRETURN GetDiagRec(SQLSMALLINT recNumber, SQLCHAR* sqlState, SQLINTEGER* nativeError, + SQLCHAR* messageText, SQLSMALLINT bufferLength, SQLSMALLINT* textLength); + virtual SQLRETURN GetDiagField(SQLSMALLINT recNumber, SQLSMALLINT diagIdentifier, + SQLPOINTER diagInfoPtr, SQLSMALLINT bufferLength, SQLSMALLINT* stringLengthPtr); + +private: + std::vector Errors_; + SQLRETURN LastReturnCode_ = SQL_SUCCESS; +}; + +SQLRETURN RecordCurrentException(TErrorManager& errors); + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/escape.cpp b/odbc/src/utils/escape.cpp new file mode 100644 index 00000000000..158c0c8b041 --- /dev/null +++ b/odbc/src/utils/escape.cpp @@ -0,0 +1,783 @@ +#include "escape.h" + +#include "sql_type_map.h" + +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { +namespace { + +bool EqualNoCase(std::string_view lhs, std::string_view rhs) { + return lhs.size() == rhs.size() && std::ranges::equal(lhs, rhs, [](unsigned char lhs, unsigned char rhs) { + return std::tolower(lhs) == std::tolower(rhs); + }); +} + +bool StartsWithKeyword(std::string_view sql, size_t pos, std::string_view keyword) { + if (pos > sql.size() + || (pos > 0 && (std::isalnum(static_cast(sql[pos - 1])) + || sql[pos - 1] == '_')) + || sql.size() - pos < keyword.size() + || !EqualNoCase(sql.substr(pos, keyword.size()), keyword)) { + return false; + } + const size_t end = pos + keyword.size(); + return end == sql.size() + || (!std::isalnum(static_cast(sql[end])) && sql[end] != '_'); +} + +struct TSqlScanner { + static constexpr auto MaxParameters = std::numeric_limits::max(); + std::string_view Sql_; + std::string* Output_; + bool RewriteEscapes_; + bool AnsiQuotes_ = Sql_.substr(0, SkipSqlTrivia(0, Sql_.size())).find("--!ansi_lexer") + != std::string_view::npos; + + size_t QuestionCount = 0; + SQLSMALLINT MaxDollarIndex = 0; + std::bitset Indices; + + void Append(std::string_view text) { + if (Output_) { + Output_->append(text); + } + } + + void Append(char ch) { + if (Output_) { + Output_->push_back(ch); + } + } + + size_t SkipTrivia(size_t pos, size_t end) const { + while (pos < end && std::isspace(static_cast(Sql_[pos]))) { + ++pos; + } + return pos; + } + + size_t SkipQuoted(size_t pos, size_t end, bool backslashEscapes = true) const { + const char quote = Sql_[pos++]; + backslashEscapes = backslashEscapes && (!AnsiQuotes_ || quote == '`'); + while (pos < end) { + const char ch = Sql_[pos++]; + if (backslashEscapes && ch == '\\' && pos < end) { + ++pos; + continue; + } + if (ch != quote) { + continue; + } + if (pos < end && Sql_[pos] == quote) { + ++pos; + } else { + return pos; + } + } + return std::string_view::npos; + } + + size_t SkipComment(size_t pos, size_t end) const { + if (pos + 1 >= end) { + return pos; + } + if (Sql_[pos] == '-' && Sql_[pos + 1] == '-') { + const size_t newline = Sql_.find('\n', pos + 2); + return newline == std::string_view::npos || newline >= end ? end : newline + 1; + } + if (Sql_[pos] == '/' && Sql_[pos + 1] == '*') { + const size_t close = Sql_.find("*/", pos + 2); + return close == std::string_view::npos || close + 2 > end ? end : close + 2; + } + return pos; + } + + size_t SkipSqlTrivia(size_t pos, size_t end) const { + while (pos < end) { + pos = SkipTrivia(pos, end); + const size_t commentEnd = SkipComment(pos, end); + if (commentEnd == pos) { + break; + } + pos = commentEnd; + } + return pos; + } + + size_t FindStatementEnd(size_t pos, size_t end) const { + while (pos < end) { + const size_t commentEnd = SkipComment(pos, end); + if (commentEnd != pos) { + pos = commentEnd; + } else if (Sql_[pos] == '\'' || Sql_[pos] == '"' || Sql_[pos] == '`') { + pos = std::min(SkipQuoted(pos, end), end); + } else if (Sql_[pos] == ';') { + return pos; + } else { + ++pos; + } + } + return std::string_view::npos; + } + + size_t FindDefineEnd(size_t pos, size_t end) const { + while (pos < end) { + const size_t commentEnd = SkipComment(pos, end); + if (commentEnd != pos) { + pos = commentEnd; + continue; + } + if (Sql_[pos] == '\'' || Sql_[pos] == '"' || Sql_[pos] == '`') { + pos = std::min(SkipQuoted(pos, end), end); + continue; + } + if (StartsWithKeyword(Sql_, pos, "END")) { + const size_t define = SkipSqlTrivia(pos + 3, end); + if (StartsWithKeyword(Sql_, define, "DEFINE")) { + const size_t semicolon = SkipSqlTrivia(define + 6, end); + if (semicolon < end && Sql_[semicolon] == ';') { + return semicolon; + } + } + } + ++pos; + } + return std::string_view::npos; + } + + bool IsNamedExpressionAssignment(size_t pos, size_t end) const { + if (pos >= end || Sql_[pos++] != '$' || pos >= end + || (!std::isalpha(static_cast(Sql_[pos])) && Sql_[pos] != '_')) { + return false; + } + while (++pos < end + && (std::isalnum(static_cast(Sql_[pos])) || Sql_[pos] == '_')) { + } + pos = SkipSqlTrivia(pos, end); + return pos < end && Sql_[pos] == '='; + } + + size_t FindPrologueEnd(size_t pos, size_t end) const { + if (StartsWithKeyword(Sql_, pos, "DEFINE")) { + return FindDefineEnd(pos + 6, end); + } + if (StartsWithKeyword(Sql_, pos, "DECLARE") + || StartsWithKeyword(Sql_, pos, "PRAGMA") + || IsNamedExpressionAssignment(pos, end)) { + return FindStatementEnd(pos, end); + } + return std::string_view::npos; + } + + size_t FindClose( + size_t open, + size_t end, + char left, + char right, + bool backslashEscapes = true) const { + size_t depth = 1; + for (size_t pos = open + 1; pos < end;) { + const size_t commentEnd = SkipComment(pos, end); + if (commentEnd != pos) { + pos = commentEnd; + continue; + } + if (Sql_[pos] == '\'' || Sql_[pos] == '"' || Sql_[pos] == '`') { + pos = SkipQuoted(pos, end, backslashEscapes); + continue; + } + if (Sql_[pos] == left) { + ++depth; + } else if (Sql_[pos] == right && --depth == 0) { + return pos; + } + ++pos; + } + return std::string_view::npos; + } + + std::string_view ReadIdent(size_t& pos, size_t end) const { + pos = SkipTrivia(pos, end); + const size_t start = pos; + while (pos < end && (std::isalpha(static_cast(Sql_[pos])) || Sql_[pos] == '_')) { + ++pos; + } + return Sql_.substr(start, pos - start); + } + + bool ReadQuoted( + size_t& pos, + size_t end, + size_t& valueBegin, + size_t& valueEnd, + bool backslashEscapes = true) const { + pos = SkipTrivia(pos, end); + if (pos >= end || Sql_[pos] != '\'') { + return false; + } + valueBegin = pos + 1; + pos = SkipQuoted(pos, end, backslashEscapes); + if (pos != std::string_view::npos) { + valueEnd = pos - 1; + return true; + } + return false; + } + + void AppendDecoded(size_t begin, size_t end, bool timestamp = false) { + bool hasZulu = false; + bool changedSpace = false; + for (size_t pos = begin; pos < end; ++pos) { + char ch = Sql_[pos]; + if (ch == '\'' && pos + 1 < end && Sql_[pos + 1] == '\'') { + ++pos; + } + if (timestamp && ch == ' ' && !changedSpace) { + ch = 'T'; + changedSpace = true; + } + hasZulu = hasZulu || ch == 'Z'; + Append(ch); + } + if (timestamp && !hasZulu) { + Append('Z'); + } + } + + bool RewriteBrace(size_t& pos, size_t end, bool parameters) { + size_t inner = SkipTrivia(pos + 1, end); + const bool outputCall = inner + 1 < end && Sql_[inner] == '?' && Sql_[inner + 1] == '='; + if (outputCall) { + inner += 2; + } + const std::string_view keyword = ReadIdent(inner, end); + const bool escapeClause = EqualNoCase(keyword, "escape"); + const size_t close = FindClose(pos, end, '{', '}', !escapeClause); + if (close == std::string_view::npos || inner > close) { + return false; + } + if (outputCall && !EqualNoCase(keyword, "call")) { + return false; + } + const bool body = EqualNoCase(keyword, "fn") || EqualNoCase(keyword, "oj") + || EqualNoCase(keyword, "call"); + if (body) { + inner = SkipTrivia(inner, close); + if (EqualNoCase(keyword, "call")) { + Append("CALL "); + } + Scan(inner, close, parameters); + pos = close + 1; + return true; + } + size_t valueBegin = 0, valueEnd = 0; + if ((!EqualNoCase(keyword, "d") && !EqualNoCase(keyword, "t") + && !EqualNoCase(keyword, "ts") && !EqualNoCase(keyword, "escape")) + || !ReadQuoted(inner, close, valueBegin, valueEnd, !escapeClause) + || SkipTrivia(inner, close) != close) { + return false; + } + if (EqualNoCase(keyword, "escape")) { + Append(" ESCAPE '"); + AppendDecoded(valueBegin, valueEnd); + Append('\''); + } else { + Append("CAST('"); + if (EqualNoCase(keyword, "t")) { + Append("1970-01-01T"); + } + AppendDecoded(valueBegin, valueEnd, !EqualNoCase(keyword, "d")); + Append(EqualNoCase(keyword, "d") ? "'s AS Date)" + : EqualNoCase(keyword, "t") ? "'s AS Datetime)" : "'s AS Timestamp)"); + } + pos = close + 1; + return true; + } + + bool RewriteConvert(size_t& pos, size_t end, bool parameters) { + constexpr std::string_view Token = "CONVERT"; + if (pos + Token.size() > end || !EqualNoCase(Sql_.substr(pos, Token.size()), Token)) { + return false; + } + size_t open = SkipTrivia(pos + Token.size(), end); + if (open >= end || Sql_[open] != '(') { + return false; + } + const size_t close = FindClose(open, end, '(', ')'); + if (close == std::string_view::npos) { + return false; + } + size_t comma = open + 1; + size_t depth = 1; + for (; comma < close;) { + const size_t commentEnd = SkipComment(comma, close); + if (commentEnd != comma) { + comma = commentEnd; + continue; + } + if (Sql_[comma] == '\'' || Sql_[comma] == '"' || Sql_[comma] == '`') { + comma = SkipQuoted(comma, close); + continue; + } + if (Sql_[comma] == '(') { + ++depth; + } else if (Sql_[comma] == ')') { + --depth; + } else if (Sql_[comma] == ',' && depth == 1) { + break; + } + ++comma; + } + size_t typePos = comma < close ? comma + 1 : close; + const std::string_view type = ReadIdent(typePos, close); + if (comma == close || type.empty() || SkipTrivia(typePos, close) != close) { + return false; + } + Append("CAST("); + Scan(open + 1, comma, parameters); + Append(" AS "); + Append(MapSqlTypeToken(type)); + Append(')'); + pos = close + 1; + return true; + } + + bool IsQuestionMark(size_t pos) const { + const unsigned char previous = pos == 0 ? 0 : Sql_[pos - 1]; + return Sql_[pos] == '?' && (pos == 0 || ((!std::isalnum(previous) && previous != '_') && previous != ')')); + } + + bool ReadDollar(size_t pos, size_t end, SQLUSMALLINT& index) const { + if (pos + 2 >= end || Sql_[pos] != '$' || Sql_[pos + 1] != 'p' + || !std::isdigit(static_cast(Sql_[pos + 2]))) { + return false; + } + unsigned value = 0; + for (size_t i = pos + 2; i < end && std::isdigit(static_cast(Sql_[i])); ++i) { + value = value * 10 + static_cast(Sql_[i] - '0'); + if (value > MaxParameters) { + throw std::length_error("Too many parameters (maximum 32767)"); + } + } + index = static_cast(value); + return true; + } + + void Scan(size_t begin, size_t end, bool parameters) { + for (size_t pos = begin; pos < end;) { + const size_t commentEnd = SkipComment(pos, end); + if (commentEnd != pos) { + Append(Sql_.substr(pos, commentEnd - pos)); + pos = commentEnd; + continue; + } + if (Sql_[pos] == '\'' || Sql_[pos] == '"' || Sql_[pos] == '`') { + const size_t next = std::min(SkipQuoted(pos, end), end); + Append(Sql_.substr(pos, next - pos)); + pos = next; + continue; + } + if (Sql_[pos] == '{') { + if (RewriteEscapes_ && RewriteBrace(pos, end, parameters)) { + continue; + } + const size_t close = FindClose(pos, end, '{', '}'); + const size_t next = close == std::string_view::npos ? end : close + 1; + Append(Sql_.substr(pos, next - pos)); + pos = next; + continue; + } + if (RewriteEscapes_ && RewriteConvert(pos, end, parameters)) { + continue; + } + if (parameters && IsQuestionMark(pos)) { + if (++QuestionCount > MaxParameters) { + throw std::length_error("Too many parameters (maximum 32767)"); + } + const auto index = static_cast(QuestionCount); + if (Output_) { + Indices.set(index); + Append("$p"); + Append(std::to_string(index)); + } + ++pos; + continue; + } + SQLUSMALLINT index = 0; + if (parameters && ReadDollar(pos, end, index)) { + MaxDollarIndex = std::max(MaxDollarIndex, static_cast(index)); + if (Output_) { + Indices.set(index); + } + } + Append(Sql_[pos++]); + } + } + +}; + +TParamRewriteResult RewriteSql( + std::string_view sql, + const std::vector& boundParams, + bool escapes) { + std::string body; + body.reserve(sql.size()); + TSqlScanner scanner{sql, &body, escapes}; + scanner.Scan(0, sql.size(), true); + if (scanner.Indices.none()) { + return {.Sql = std::move(body)}; + } + if (scanner.QuestionCount > 0 && scanner.QuestionCount != boundParams.size()) { + return {.Success = false, .SqlState = "07002", .Message = "COUNT field incorrect: unbound ? placeholders"}; + } + std::string declarations; + for (size_t rawIndex = 0; rawIndex < scanner.Indices.size(); ++rawIndex) { + if (!scanner.Indices.test(rawIndex)) { + continue; + } + const auto index = static_cast(rawIndex); + const std::string prefix = "DECLARE $p" + std::to_string(index) + " AS"; + if (GetDeclaredParamOptionality(sql, index).has_value()) { + continue; + } + const auto bound = std::ranges::find(boundParams, index, &TBoundParam::ParamNumber); + if (bound == boundParams.end()) { + return {.Success = false, .SqlState = "07002", .Message = "COUNT field incorrect"}; + } + const auto type = ResolveParamType(*bound); + if (!type) { + return {.Success = false, .SqlState = "07006", .Message = "Restricted data type attribute violation"}; + } + declarations += prefix + " " + type->YqlType + + (BoundParamIsNull(*bound) ? "?;\n" : ";\n"); + } + return {.Sql = declarations.empty() ? std::move(body) : AddSqlPreamble(body, declarations)}; +} + +} // namespace + +std::string AddSqlPreamble(std::string_view sql, std::string_view preamble) { + // Lexer directives must precede generated statements. + const TSqlScanner scanner{sql, nullptr, false}; + const size_t pos = scanner.SkipSqlTrivia(0, sql.size()); + std::string result; + result.reserve(sql.size() + preamble.size()); + result.append(sql.substr(0, pos)); + result.append(preamble); + result.append(sql.substr(pos)); + return result; +} + +std::string RewriteOdbcEscapes(const std::string& sql) { + std::string result; + result.reserve(sql.size()); + TSqlScanner scanner{sql, &result, true}; + scanner.Scan(0, sql.size(), false); + return result; +} + +TParamRewriteResult RewriteOdbcSql( + std::string_view sql, + const std::vector& boundParams, + bool rewriteEscapes) { + return RewriteSql(sql, boundParams, rewriteEscapes); +} + +std::optional GetDeclaredParamOptionality( + std::string_view sql, + SQLUSMALLINT paramNumber) +{ + const std::string param = "$p" + std::to_string(paramNumber); + const TSqlScanner scanner{sql, nullptr, false}; + for (size_t pos = scanner.SkipSqlTrivia(0, sql.size()); pos < sql.size();) { + const bool isDeclare = StartsWithKeyword(sql, pos, "DECLARE"); + if (!isDeclare && !StartsWithKeyword(sql, pos, "PRAGMA")) { + break; + } + const size_t semicolon = scanner.FindStatementEnd(pos, sql.size()); + if (semicolon == std::string_view::npos) { + break; + } + size_t token = scanner.SkipSqlTrivia(pos + (isDeclare ? 7 : 6), semicolon); + if (isDeclare && semicolon - token >= param.size() + && sql.substr(token, param.size()) == param + && (token + param.size() == semicolon + || (!std::isalnum(static_cast(sql[token + param.size()])) + && sql[token + param.size()] != '_'))) { + token = scanner.SkipSqlTrivia(token + param.size(), semicolon); + if (StartsWithKeyword(sql, token, "AS")) { + const std::string_view type = TrimTrailingSqlTrivia( + sql.substr(token + 2, semicolon - token - 2)); + return !type.empty() && type.back() == '?'; + } + } + pos = scanner.SkipSqlTrivia(semicolon + 1, sql.size()); + } + return std::nullopt; +} + +std::string_view TrimTrailingSqlTrivia(std::string_view sql) { + const TSqlScanner scanner{sql, nullptr, false}; + size_t codeEnd = 0; + for (size_t pos = 0; pos < sql.size();) { + const size_t commentEnd = scanner.SkipComment(pos, sql.size()); + if (commentEnd != pos) { + if (sql[pos] == '/' && sql.find("*/", pos + 2) == std::string_view::npos) { + return sql; + } + pos = commentEnd; + } else if (std::isspace(static_cast(sql[pos]))) { + ++pos; + } else if (sql[pos] == '\'' || sql[pos] == '"' || sql[pos] == '`') { + pos = std::min(scanner.SkipQuoted(pos, sql.size()), sql.size()); + codeEnd = pos; + } else { + codeEnd = ++pos; + } + } + return sql.substr(0, codeEnd); +} + +std::string_view GetSqlStatement(std::string_view sql) { + const TSqlScanner scanner{sql, nullptr, false}; + size_t statement = scanner.SkipSqlTrivia(0, sql.size()); + while (statement < sql.size()) { + const size_t prologueEnd = scanner.FindPrologueEnd(statement, sql.size()); + if (prologueEnd == std::string_view::npos) { + break; + } + const size_t next = scanner.SkipSqlTrivia(prologueEnd + 1, sql.size()); + if (next == sql.size()) { + break; + } + statement = next; + } + return sql.substr(statement); +} + +bool HasMultipleSqlStatements(std::string_view sql) { + const TSqlScanner scanner{sql, nullptr, false}; + const std::string_view statement = GetSqlStatement(sql); + const size_t statementBegin = sql.size() - statement.size(); + const size_t statementEnd = scanner.FindStatementEnd(statementBegin, sql.size()); + return statementEnd != std::string_view::npos + && scanner.SkipSqlTrivia(statementEnd + 1, sql.size()) < sql.size(); +} + +SQLSMALLINT CountOdbcParams(std::string_view sql) { + TSqlScanner scanner{sql, nullptr, false}; + scanner.Scan(0, sql.size(), true); + return scanner.QuestionCount > 0 + ? static_cast(scanner.QuestionCount) + : scanner.MaxDollarIndex; +} + +bool StartsWithSqlStatement( + std::string_view sql, + std::initializer_list keywords) { + sql = GetSqlStatement(sql); + return std::ranges::any_of(keywords, [&](std::string_view keyword) { + return StartsWithKeyword(sql, 0, keyword); + }); +} + +std::optional BuildParamMetadataQuery( + std::string_view input, bool rewriteEscapes, SQLUSMALLINT paramNumber, SQLSMALLINT paramCount) { + const std::string sql = rewriteEscapes ? RewriteOdbcEscapes(std::string(input)) : std::string(input); + if (HasMultipleSqlStatements(sql)) { + return std::nullopt; + } + const auto count = CountOdbcParams(sql); + if (count != paramCount || paramNumber < 1 || paramNumber > count) { + return std::nullopt; + } + const TSqlScanner scanner{sql, nullptr, false}; + struct TToken { + std::string_view Text; + SQLUSMALLINT Parameter = 0; + }; + std::vector tokens; + SQLUSMALLINT question = 0; + const size_t bodyOffset = sql.size() - GetSqlStatement(sql).size(); + const size_t trivia = scanner.SkipSqlTrivia(0, sql.size()); + const auto prologue = TrimTrailingSqlTrivia(std::string_view(sql).substr(trivia, bodyOffset - trivia)); + if (!prologue.empty() && (!scanner.AnsiQuotes_ || prologue != "PRAGMA UnicodeLiterals;")) { + return std::nullopt; + } + for (size_t pos = bodyOffset; (pos = scanner.SkipSqlTrivia(pos, sql.size())) < sql.size();) { + const size_t begin = pos; + SQLUSMALLINT parameter = 0; + const unsigned char ch = sql[pos++]; + if (ch == '\'' || ch == '"' || ch == '`') { + pos = scanner.SkipQuoted(begin, sql.size()); + if (pos == std::string_view::npos) { + return std::nullopt; + } + } else if (ch == '?' && scanner.IsQuestionMark(begin)) { + parameter = ++question; + } else if (std::isalnum(ch) || ch == '_' || ch == '$') { + while (pos < sql.size() && (std::isalnum(static_cast(sql[pos])) + || sql[pos] == '_' || (std::isdigit(ch) && sql[pos] == '.') + || (std::isdigit(ch) && (sql[pos - 1] == 'e' || sql[pos - 1] == 'E') + && (sql[pos] == '+' || sql[pos] == '-')))) { + ++pos; + } + scanner.ReadDollar(begin, pos, parameter); + } else if (pos < sql.size() && (ch == '<' || ch == '>' || ch == '!') + && (sql[pos] == '=' || (ch == '<' && sql[pos] == '>'))) { + ++pos; + } + tokens.push_back({std::string_view(sql).substr(begin, pos - begin), parameter}); + } + const auto is = [&](size_t i, std::string_view text) { + return i < tokens.size() && EqualNoCase(tokens[i].Text, text); + }; + const auto identifier = [&](size_t i) { + return i < tokens.size() && !tokens[i].Parameter + && (std::isalpha(static_cast(tokens[i].Text.front())) + || tokens[i].Text.front() == '_' || tokens[i].Text.front() == '`'); + }; + const auto nameEnd = [&](size_t i) { + if (!identifier(i)) { + return i; + } + while (is(i + 1, ".") && identifier(i + 2)) { + i += 2; + } + return i + 1; + }; + const auto span = [&](size_t begin, size_t end) { + return std::string(tokens[begin].Text.data(), + tokens[end - 1].Text.data() + tokens[end - 1].Text.size()); + }; + std::vector sources(static_cast(count)); + const auto assign = [&](SQLUSMALLINT parameter, std::string expression) { + if (parameter > 0 && parameter <= sources.size() && !expression.empty()) { + auto& source = sources[parameter - 1]; + source = source.empty() || source == expression ? std::move(expression) : "NULL"; + } + }; + constexpr size_t body = 0; + if (!is(body, "SELECT") && !is(body, "INSERT") && !is(body, "UPSERT") && !is(body, "REPLACE") + && !is(body, "UPDATE") && !is(body, "DELETE")) { + return std::nullopt; + } + std::string table; + size_t tableEnd = 0; + int depth = 0; + for (size_t i = body; i < tokens.size(); ++i) { + if (is(i, "(")) ++depth; + if (is(i, ")")) --depth; + if (depth == 0 && (is(i, "FROM") || is(i, "INTO") || (i == body && is(i, "UPDATE")))) { + const auto end = nameEnd(i + 1); + if (end == i + 1 || !table.empty()) { + return std::nullopt; + } + table = span(i + 1, end); + tableEnd = end; + if (is(body, "SELECT") || is(body, "DELETE")) { + const auto clause = [&](size_t i) { + return i == tokens.size() || is(i, ";") || is(i, "WHERE") || is(i, "ORDER") + || is(i, "GROUP") || is(i, "HAVING") || is(i, "LIMIT") || is(i, "OFFSET") + || is(i, "UNION") || is(i, "WINDOW"); + }; + size_t tail = end; + if (is(tail, "AS")) { + if (!identifier(++tail)) return std::nullopt; + table += " AS " + std::string(tokens[tail++].Text); + } else if (identifier(tail) && !clause(tail)) { + table += " AS " + std::string(tokens[tail++].Text); + } + if (!clause(tail)) return std::nullopt; + } + } + if (is(i, "JOIN") || (is(i, "SELECT") && i != body)) { + return std::nullopt; + } + } + if (depth != 0) return std::nullopt; + if ((is(body, "INSERT") || is(body, "UPSERT") || is(body, "REPLACE")) && is(tableEnd, "(")) { + std::vector columns; + size_t pos = tableEnd + 1; + while (identifier(pos)) { + columns.emplace_back(tokens[pos++].Text); + if (!is(pos, ",")) break; + ++pos; + } + if (!columns.empty() && is(pos, ")") && is(pos + 1, "VALUES")) { + for (pos += 2; is(pos, "("); ++pos) { + size_t start = ++pos, column = 0; + int nested = 0; + for (; pos < tokens.size(); ++pos) { + if (nested == 0 && (is(pos, ",") || is(pos, ")"))) { + if (column < columns.size() && pos == start + 1) { + assign(tokens[start].Parameter, columns[column]); + } + ++column; + start = pos + 1; + if (is(pos, ")")) break; + } + if (is(pos, "(")) ++nested; + if (is(pos, ")")) --nested; + } + if (!is(pos + 1, ",")) break; + ++pos; + } + } + } + const auto boundary = [&](size_t i) { + return i >= tokens.size() || is(i, "(") || is(i, ")") || is(i, ",") || is(i, ";") + || is(i, "WHERE") || is(i, "SET") || is(i, "AND") || is(i, "OR") + || is(i, "WHEN") || is(i, "THEN") || is(i, "ORDER") || is(i, "LIMIT") + || is(i, "SELECT") || is(i, "AS"); + }; + const auto comparison = [&](size_t i) { + return is(i, "=") || is(i, "<>") || is(i, "!=") || is(i, "<") || is(i, "<=") || is(i, ">") || is(i, ">="); + }; + for (size_t i = body; i < tokens.size(); ++i) { + size_t end = i + 1; + std::string expression; + const auto text = tokens[i].Text; + if (std::isdigit(static_cast(text.front())) || is(i, "TRUE") || is(i, "FALSE")) { + expression = "Just(" + std::string(text) + ")"; + } else if ((is(i, "-") || is(i, "+")) && i + 1 < tokens.size() + && std::isdigit(static_cast(tokens[i + 1].Text.front()))) { + expression = "Just(" + span(i, ++end) + ")"; + } else if (!table.empty() && identifier(i)) { + end = nameEnd(i); + expression = span(i, end); + } + if (expression.empty()) continue; + // A floating literal fixes the arithmetic result type without narrowing integer inputs. + const auto operation = [&](size_t op) { + return comparison(op) || (text.find_first_of(".eE") != std::string_view::npos + && std::isdigit(static_cast(text.front())) + && (is(op, "+") || is(op, "-") || is(op, "*") || is(op, "/"))); + }; + if ((i == body || boundary(i - 1)) && operation(end) && end + 1 < tokens.size() + && tokens[end + 1].Parameter && boundary(end + 2)) { + assign(tokens[end + 1].Parameter, expression); + } + if (i >= body + 3 && (i == body + 3 || boundary(i - 3)) + && tokens[i - 2].Parameter && operation(i - 1) && !is(end, "(") && boundary(end)) { + assign(tokens[i - 2].Parameter, expression); + } + } + if (sources[paramNumber - 1].empty() || sources[paramNumber - 1] == "NULL") { + return std::nullopt; + } + std::string query = "SELECT "; + for (size_t i = 0; i < sources.size(); ++i) { + if (i) query += ", "; + query += (sources[i].empty() ? "NULL" : sources[i]) + " AS __p" + std::to_string(i + 1); + } + return (scanner.AnsiQuotes_ ? sql.substr(0, bodyOffset) : std::string{}) + + query + (table.empty() ? "" : " FROM " + table) + " LIMIT 0"; +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/escape.h b/odbc/src/utils/escape.h new file mode 100644 index 00000000000..0b37374b83a --- /dev/null +++ b/odbc/src/utils/escape.h @@ -0,0 +1,3 @@ +#pragma once + +#include "param_rewrite.h" diff --git a/odbc/src/utils/handle.cpp b/odbc/src/utils/handle.cpp new file mode 100644 index 00000000000..60801aaa794 --- /dev/null +++ b/odbc/src/utils/handle.cpp @@ -0,0 +1,15 @@ +#include "handle.h" + +#include + +namespace NYdb::NOdbc { + +void THandle::AddChild(THandle* child) { + Children_.push_back(child); +} + +void THandle::RemoveChild(THandle* child) { + std::erase(Children_, child); +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/handle.h b/odbc/src/utils/handle.h new file mode 100644 index 00000000000..22807617f85 --- /dev/null +++ b/odbc/src/utils/handle.h @@ -0,0 +1,121 @@ +#pragma once + +#include "error_manager.h" + +#include + +#include +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { + +class TEnvironment; +class TConnection; +class TStatement; + +enum class ECallMode : unsigned char { Ordinary, Diagnostic, Consuming }; + +class THandle : public TErrorManager { +public: + explicit THandle(THandle* parent = nullptr) : Parent_(parent) {} + THandle* GetParent() const { return Parent_; } + // The caller holds this parent's operation lock for child-list access. + void AddChild(THandle* child); + void RemoveChild(THandle* child); + bool HasChildren() const { return !Children_.empty(); } + const std::vector& GetChildren() const { return Children_; } + std::vector ReleaseChildren() { return std::exchange(Children_, {}); } + std::unique_lock LockOperation() const { return std::unique_lock(OperationMutex_); } + +protected: + // API calls hold the connection lifecycle gate before this lock. It protects + // this handle's mutable state and diagnostics; SDK objects need no extra lock. + mutable std::mutex OperationMutex_; + +private: + THandle* const Parent_; + std::vector Children_; +}; + +template +Handle* CheckedHandle(SQLHANDLE handle) { + // Applications must keep handles alive until all uses have completed. + return dynamic_cast(static_cast(handle)); +} + +template +SQLRETURN InvokeOdbc(Fn&& fn, Args&&... args) { + if constexpr (std::is_void_v>) { + std::invoke(std::forward(fn), std::forward(args)...); + return SQL_SUCCESS; + } else { + return std::invoke(std::forward(fn), std::forward(args)...); + } +} + +template +SQLRETURN CallOdbc(SQLHANDLE handlePtr, Fn&& func) { + auto* owner = CheckedHandle(handlePtr); + if (!owner) { + return SQL_INVALID_HANDLE; + } + // ENV traversal and DBC removal acquire parent ownership in the same order. + std::unique_lock parent; + if constexpr (Mode == ECallMode::Consuming && std::is_same_v) { + parent = owner->GetParent()->LockOperation(); + } + std::conditional_t, + std::shared_lock> connection; + if constexpr (!std::is_same_v) { + if constexpr (Exclusive) { + connection = owner->GetConnection().LockExclusive(); + } else { + connection = owner->GetConnection().LockShared(); + } + } + if constexpr (Mode == ECallMode::Consuming + && !std::is_same_v + && !std::is_same_v) { + parent = owner->GetParent()->LockOperation(); + } + auto lock = owner->LockOperation(); + if constexpr (Mode == ECallMode::Ordinary && std::is_same_v) { + owner->StartExecution(); + } + bool executionFinished = false; + Y_DEFER { + if (!executionFinished) { + if constexpr (Mode == ECallMode::Ordinary && std::is_same_v) { + owner->FinishExecution(); + } + } + }; + if constexpr (Mode != ECallMode::Diagnostic) { + owner->ClearErrors(); + } + try { + SQLRETURN ret = InvokeOdbc(std::forward(func), owner); + if constexpr (Mode == ECallMode::Ordinary && std::is_same_v) { + const bool canceled = owner->FinishExecution(); + executionFinished = true; + if (canceled && ret == SQL_NEED_DATA) { + ret = owner->AddError("HY008", 0, "Operation canceled"); + } + } + if constexpr (Mode == ECallMode::Ordinary) { + owner->SetLastReturnCode(ret); + } + return ret; + } catch (...) { + if constexpr (Mode == ECallMode::Diagnostic) { + return SQL_ERROR; + } + return RecordCurrentException(*owner); + } +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/param_rewrite.h b/odbc/src/utils/param_rewrite.h new file mode 100644 index 00000000000..fd619e57c57 --- /dev/null +++ b/odbc/src/utils/param_rewrite.h @@ -0,0 +1,45 @@ +#pragma once + +#include "bindings.h" + +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { + +struct TParamRewriteResult { + std::string Sql; + bool Success = true; + std::string SqlState; + std::string Message; +}; + +std::string RewriteOdbcEscapes(const std::string& sql); +std::string AddSqlPreamble(std::string_view sql, std::string_view preamble); + +TParamRewriteResult RewriteOdbcSql( + std::string_view sql, + const std::vector& boundParams, + bool rewriteEscapes); + +std::optional GetDeclaredParamOptionality( + std::string_view sql, + SQLUSMALLINT paramNumber); + +std::optional BuildParamMetadataQuery( + std::string_view sql, bool rewriteEscapes, SQLUSMALLINT paramNumber, SQLSMALLINT paramCount); + +std::string_view TrimTrailingSqlTrivia(std::string_view sql); +std::string_view GetSqlStatement(std::string_view sql); +bool HasMultipleSqlStatements(std::string_view sql); + +SQLSMALLINT CountOdbcParams(std::string_view sql); + +bool StartsWithSqlStatement( + std::string_view sql, + std::initializer_list keywords); + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/sql_like.h b/odbc/src/utils/sql_like.h new file mode 100644 index 00000000000..33d14188375 --- /dev/null +++ b/odbc/src/utils/sql_like.h @@ -0,0 +1,56 @@ +#pragma once + +#include + +namespace NYdb::NOdbc { + +// SQL LIKE β€” '%' is any substring, '_' is any single character. +inline bool SqlLikeMatch(std::string_view text, std::string_view pattern) { + size_t textPos = 0; + size_t patPos = 0; + size_t retryPat = std::string_view::npos; + size_t retryText = 0; + + const size_t textLen = text.size(); + const size_t patLen = pattern.size(); + + while (textPos < textLen) { + if (patPos < patLen && pattern[patPos] == '%') { + retryPat = ++patPos; + retryText = textPos; + continue; + } + + if (patPos < patLen) { + size_t nextPat = patPos + 1; + char expected = pattern[patPos]; + bool anyCharacter = expected == '_'; + if (expected == '\\' && nextPat < patLen + && (pattern[nextPat] == '%' || pattern[nextPat] == '_' + || pattern[nextPat] == '\\')) { + expected = pattern[nextPat++]; + anyCharacter = false; + } + if (anyCharacter || expected == text[textPos]) { + ++textPos; + patPos = nextPat; + continue; + } + } + + if (retryPat != std::string_view::npos) { + patPos = retryPat; + textPos = ++retryText; + continue; + } + + return false; + } + + while (patPos < patLen && pattern[patPos] == '%') { + ++patPos; + } + return patPos == patLen; +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/sql_type_map.cpp b/odbc/src/utils/sql_type_map.cpp new file mode 100644 index 00000000000..51a2b8e758f --- /dev/null +++ b/odbc/src/utils/sql_type_map.cpp @@ -0,0 +1,158 @@ +#include "sql_type_map.h" + +#include +#include +#include + +namespace NYdb::NOdbc { +namespace { + +constexpr std::array TypeSpecs{ + TSqlTypeSpec{SQL_BIGINT, "BIGINT", EParamType::Int64, "Int64", 19, true}, + TSqlTypeSpec{SQL_INTEGER, "INTEGER", EParamType::Int32, "Int32", 10, true}, + TSqlTypeSpec{SQL_SMALLINT, "SMALLINT", EParamType::Int16, "Int16", 5, true}, + TSqlTypeSpec{SQL_DOUBLE, "DOUBLE", EParamType::Double, "Double", 15, true}, + TSqlTypeSpec{SQL_REAL, "REAL", EParamType::Float, "Float", 7, true}, + TSqlTypeSpec{SQL_VARCHAR, "VARCHAR", EParamType::Utf8, "Utf8", 0, true}, + TSqlTypeSpec{SQL_CHAR, "CHAR", EParamType::Utf8, "Utf8", 0, true}, + TSqlTypeSpec{SQL_LONGVARCHAR, "LONGVARCHAR", EParamType::Utf8, "Utf8", 0, false}, + TSqlTypeSpec{SQL_WCHAR, "WCHAR", EParamType::Utf8, "Utf8", 0, false}, + TSqlTypeSpec{SQL_WVARCHAR, "WVARCHAR", EParamType::Utf8, "Utf8", 0, false}, + TSqlTypeSpec{SQL_WLONGVARCHAR, "WLONGVARCHAR", EParamType::Utf8, "Utf8", 0, false}, + TSqlTypeSpec{SQL_BIT, "BIT", EParamType::Bool, "Bool", 1, true}, + TSqlTypeSpec{SQL_TINYINT, "TINYINT", EParamType::Int8, "Int8", 3, true}, + TSqlTypeSpec{SQL_FLOAT, "FLOAT", EParamType::Double, "Double", 15, false}, + TSqlTypeSpec{SQL_DECIMAL, "DECIMAL", EParamType::Decimal, "Decimal(22, 9)", 22, true}, + TSqlTypeSpec{SQL_NUMERIC, "NUMERIC", EParamType::Decimal, "Decimal(22, 9)", 22, false}, + TSqlTypeSpec{SQL_BINARY, "BINARY", EParamType::String, "String", 0, false}, + TSqlTypeSpec{SQL_VARBINARY, "VARBINARY", EParamType::String, "String", 0, true}, + TSqlTypeSpec{SQL_LONGVARBINARY, "LONGVARBINARY", EParamType::String, "String", 0, false}, + TSqlTypeSpec{SQL_TYPE_DATE, "DATE", EParamType::Date, "Date", 10, true}, + TSqlTypeSpec{SQL_TYPE_TIME, "TIME", EParamType::Datetime, "Datetime", 8, true}, + TSqlTypeSpec{SQL_TYPE_TIMESTAMP, "TIMESTAMP", EParamType::Timestamp, "Timestamp", 26, true}, +}; + +std::optional UnsignedType(SQLSMALLINT type) { + switch (type) { + case SQL_C_UTINYINT: return TParamTypeSpec{EParamType::Uint8, "Uint8"}; + case SQL_C_USHORT: return TParamTypeSpec{EParamType::Uint16, "Uint16"}; + case SQL_C_ULONG: return TParamTypeSpec{EParamType::Uint32, "Uint32"}; + case SQL_C_UBIGINT: return TParamTypeSpec{EParamType::Uint64, "Uint64"}; + default: return std::nullopt; + } +} + +SQLSMALLINT CanonicalType(SQLSMALLINT type) { + if (type == SQL_DATE) { + return SQL_TYPE_DATE; + } + if (type == SQL_TIME) { + return SQL_TYPE_TIME; + } + return type == SQL_TIMESTAMP ? SQL_TYPE_TIMESTAMP : type; +} + +bool IsIntegerType(SQLSMALLINT type) { + return type == SQL_BIGINT || type == SQL_INTEGER || type == SQL_SMALLINT + || type == SQL_TINYINT; +} + +} // namespace + +std::span GetSqlTypeSpecs() { + return TypeSpecs; +} + +const TSqlTypeSpec* FindSqlTypeSpec(SQLSMALLINT sqlType) { + const auto it = std::ranges::find(TypeSpecs, sqlType, &TSqlTypeSpec::Type); + return it == TypeSpecs.end() ? nullptr : &*it; +} + +SQLLEN GetDisplaySize(SQLSMALLINT sqlType, SQLLEN size, bool isUnsigned) { + switch (sqlType) { + case SQL_TINYINT: case SQL_SMALLINT: case SQL_INTEGER: case SQL_BIGINT: + return size + !isUnsigned; + case SQL_REAL: return 14; + case SQL_FLOAT: case SQL_DOUBLE: return 24; + case SQL_DECIMAL: case SQL_NUMERIC: return size + 2; + default: return size; + } +} + +SQLULEN GetCTypeSize(SQLSMALLINT cType, SQLLEN variableLength) { + if (cType == SQL_C_CHAR || cType == SQL_C_WCHAR || cType == SQL_C_BINARY) { + return static_cast(std::max(variableLength, 0)); + } + if (const auto size = VisitCInteger(cType, [](auto type) { + return sizeof(typename decltype(type)::type); + })) { + return *size; + } + switch (cType) { + case SQL_C_FLOAT: return sizeof(SQLREAL); + case SQL_C_DOUBLE: return sizeof(SQLDOUBLE); + case SQL_C_TYPE_DATE: return sizeof(SQL_DATE_STRUCT); +#if defined(SQL_C_DATE) && SQL_C_DATE != SQL_C_TYPE_DATE + case SQL_C_DATE: return sizeof(SQL_DATE_STRUCT); +#endif + case SQL_C_TYPE_TIME: return sizeof(SQL_TIME_STRUCT); +#if defined(SQL_C_TIME) && SQL_C_TIME != SQL_C_TYPE_TIME + case SQL_C_TIME: return sizeof(SQL_TIME_STRUCT); +#endif + case SQL_C_TYPE_TIMESTAMP: return sizeof(SQL_TIMESTAMP_STRUCT); +#if defined(SQL_C_TIMESTAMP) && SQL_C_TIMESTAMP != SQL_C_TYPE_TIMESTAMP + case SQL_C_TIMESTAMP: return sizeof(SQL_TIMESTAMP_STRUCT); +#endif + case SQL_C_GUID: return sizeof(SQLGUID); + default: return static_cast(std::max(variableLength, 0)); + } +} + +std::string MapSqlTypeToken(std::string_view sqlType) { + std::string key(sqlType); + std::ranges::transform(key, key.begin(), [](unsigned char byte) { + return static_cast(std::toupper(byte)); + }); + if (key.starts_with("SQL_")) { + key.erase(0, 4); + } + if (key.starts_with("TYPE_")) { + key.erase(0, 5); + } + const auto it = std::ranges::find(TypeSpecs, key, &TSqlTypeSpec::Name); + return it == TypeSpecs.end() ? key : std::string(it->YqlType); +} + +std::optional ResolveParamType(const TBoundParam& param) { + const SQLSMALLINT sqlType = CanonicalType(param.ParameterType); + const TSqlTypeSpec* spec = FindSqlTypeSpec(sqlType); + if (!spec) { + return std::nullopt; + } + if (param.WideTemporal == EWideTemporal::Date32 && sqlType == SQL_TYPE_DATE) + return TParamTypeSpec{EParamType::Date32, "Date32"}; + if (param.WideTemporal == EWideTemporal::Datetime64 && sqlType == SQL_TYPE_TIMESTAMP) + return TParamTypeSpec{EParamType::Datetime64, "Datetime64"}; + if (param.WideTemporal == EWideTemporal::Timestamp64 && sqlType == SQL_TYPE_TIMESTAMP) + return TParamTypeSpec{EParamType::Timestamp64, "Timestamp64"}; + const bool decimal = sqlType == SQL_DECIMAL || sqlType == SQL_NUMERIC; + if ((IsIntegerType(sqlType) || (decimal && param.DecimalDigits == 0))) { + if (auto type = UnsignedType(param.ValueType)) { + return type; + } + } + if (decimal) { + const SQLULEN precision = param.ColumnSize ? param.ColumnSize : 22; + const SQLSMALLINT scale = param.ColumnSize ? param.DecimalDigits : 9; + if (!precision || precision > 35 || scale < 0 || static_cast(scale) > precision) { + return std::nullopt; + } + return TParamTypeSpec{EParamType::Decimal, + "Decimal(" + std::to_string(precision) + ", " + + std::to_string(scale) + ")", + precision, scale}; + } + return TParamTypeSpec{spec->ParamType, std::string(spec->YqlType)}; +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/sql_type_map.h b/odbc/src/utils/sql_type_map.h new file mode 100644 index 00000000000..ca56729e993 --- /dev/null +++ b/odbc/src/utils/sql_type_map.h @@ -0,0 +1,96 @@ +#pragma once + +#include "bindings.h" + +#include "odbc_compat.h" + +#include +#include +#include +#include +#include +#include +#include + +#define YDB_ODBC_C_INTEGER_TYPES(X) \ + X(SQL_C_BIT, SQLCHAR) \ + X(SQL_C_SBIGINT, SQLBIGINT) \ + X(SQL_C_UBIGINT, SQLUBIGINT) \ + X(SQL_C_LONG, SQLINTEGER) \ + X(SQL_C_SLONG, SQLINTEGER) \ + X(SQL_C_ULONG, SQLUINTEGER) \ + X(SQL_C_SHORT, SQLSMALLINT) \ + X(SQL_C_SSHORT, SQLSMALLINT) \ + X(SQL_C_USHORT, SQLUSMALLINT) \ + X(SQL_C_TINYINT, SQLSCHAR) \ + X(SQL_C_STINYINT, SQLSCHAR) \ + X(SQL_C_UTINYINT, SQLCHAR) + +#define YDB_ODBC_SCALAR_TYPES(X) \ + X(Int8, int8_t, SQL_TINYINT, false) \ + X(Uint8, uint8_t, SQL_TINYINT, true) \ + X(Int16, int16_t, SQL_SMALLINT, false) \ + X(Uint16, uint16_t, SQL_SMALLINT, true) \ + X(Int32, int32_t, SQL_INTEGER, false) \ + X(Uint32, uint32_t, SQL_INTEGER, true) \ + X(Int64, int64_t, SQL_BIGINT, false) \ + X(Uint64, uint64_t, SQL_BIGINT, true) \ + X(Float, float, SQL_REAL, false) \ + X(Double, double, SQL_DOUBLE, false) + +namespace NYdb::NOdbc { + +enum class EParamType { + Bool, +#define ODBC_PARAM_TYPE(name, cppType, sqlType, isUnsigned) name, + YDB_ODBC_SCALAR_TYPES(ODBC_PARAM_TYPE) +#undef ODBC_PARAM_TYPE + Decimal, + Utf8, + String, + Date, + Datetime, + Timestamp, + Date32, + Datetime64, + Timestamp64, +}; + +template +auto VisitCInteger(SQLSMALLINT type, Fn&& fn) + -> std::optional>> { +#define ODBC_VISIT_C_INTEGER(odbcType, cppType) \ + case odbcType: \ + return fn(std::type_identity{}); + switch (type) { + YDB_ODBC_C_INTEGER_TYPES(ODBC_VISIT_C_INTEGER) + default: + return std::nullopt; + } +#undef ODBC_VISIT_C_INTEGER +} + +struct TSqlTypeSpec { + SQLSMALLINT Type; + std::string_view Name; + EParamType ParamType; + std::string_view YqlType; + SQLULEN ColumnSize; + bool Advertise; +}; + +struct TParamTypeSpec { + EParamType Type; + std::string YqlType; + SQLULEN Precision{}; + SQLSMALLINT Scale{}; +}; + +std::span GetSqlTypeSpecs(); +const TSqlTypeSpec* FindSqlTypeSpec(SQLSMALLINT sqlType); +SQLLEN GetDisplaySize(SQLSMALLINT sqlType, SQLLEN size, bool isUnsigned = false); +SQLULEN GetCTypeSize(SQLSMALLINT cType, SQLLEN variableLength); +std::string MapSqlTypeToken(std::string_view sqlType); +std::optional ResolveParamType(const TBoundParam& param); + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/status_util.cpp b/odbc/src/utils/status_util.cpp new file mode 100644 index 00000000000..99620babd88 --- /dev/null +++ b/odbc/src/utils/status_util.cpp @@ -0,0 +1,11 @@ +#include "status_util.h" + +#include + +namespace NYdb::NOdbc { + +NYdb::TStatus StatusFrom(const NYdb::TStatus& ydbStatus) { + return NYdb::TStatus(ydbStatus.GetStatus(), NYdb::NIssue::TIssues(ydbStatus.GetIssues())); +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/status_util.h b/odbc/src/utils/status_util.h new file mode 100644 index 00000000000..43595c69ac1 --- /dev/null +++ b/odbc/src/utils/status_util.h @@ -0,0 +1,9 @@ +#pragma once + +#include + +namespace NYdb::NOdbc { + +NYdb::TStatus StatusFrom(const NYdb::TStatus& ydbStatus); + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/types.cpp b/odbc/src/utils/types.cpp new file mode 100644 index 00000000000..63423084b5d --- /dev/null +++ b/odbc/src/utils/types.cpp @@ -0,0 +1,94 @@ +#include "types.h" +#include "sql_type_map.h" + +#include +#include + +namespace NYdb::NOdbc { +namespace { + +struct TPrimitiveSpec { + EPrimitiveType Type; + SQLSMALLINT SqlType; + bool Integer = false; + bool Unsigned = false; +}; + +constexpr std::array PrimitiveSpecs{ + TPrimitiveSpec{EPrimitiveType::Bool, SQL_BIT}, +#define ODBC_PRIMITIVE_SPEC(name, cppType, sqlType, isUnsigned) \ + TPrimitiveSpec{EPrimitiveType::name, sqlType, std::is_integral_v, isUnsigned}, + YDB_ODBC_SCALAR_TYPES(ODBC_PRIMITIVE_SPEC) +#undef ODBC_PRIMITIVE_SPEC + TPrimitiveSpec{EPrimitiveType::Interval, SQL_BIGINT}, + TPrimitiveSpec{EPrimitiveType::Interval64, SQL_BIGINT}, + TPrimitiveSpec{EPrimitiveType::Date, SQL_TYPE_DATE}, + TPrimitiveSpec{EPrimitiveType::Date32, SQL_TYPE_DATE}, + TPrimitiveSpec{EPrimitiveType::TzDate, SQL_TYPE_DATE}, + TPrimitiveSpec{EPrimitiveType::Datetime, SQL_TYPE_TIME}, + TPrimitiveSpec{EPrimitiveType::Timestamp, SQL_TYPE_TIMESTAMP}, + TPrimitiveSpec{EPrimitiveType::Datetime64, SQL_TYPE_TIMESTAMP}, + TPrimitiveSpec{EPrimitiveType::Timestamp64, SQL_TYPE_TIMESTAMP}, + TPrimitiveSpec{EPrimitiveType::TzDatetime, SQL_TYPE_TIMESTAMP}, + TPrimitiveSpec{EPrimitiveType::TzTimestamp, SQL_TYPE_TIMESTAMP}, + TPrimitiveSpec{EPrimitiveType::String, SQL_VARBINARY}, + TPrimitiveSpec{EPrimitiveType::Utf8, SQL_VARCHAR}, + TPrimitiveSpec{EPrimitiveType::Yson, SQL_VARCHAR}, + TPrimitiveSpec{EPrimitiveType::Json, SQL_VARCHAR}, + TPrimitiveSpec{EPrimitiveType::JsonDocument, SQL_VARCHAR}, + TPrimitiveSpec{EPrimitiveType::DyNumber, SQL_VARCHAR}, + TPrimitiveSpec{EPrimitiveType::Uuid, SQL_GUID}, +}; + +SQLULEN GetColumnSize(SQLSMALLINT sqlType) { + const TSqlTypeSpec* spec = FindSqlTypeSpec(sqlType); + return spec ? spec->ColumnSize : sqlType == SQL_GUID ? 36 : 4096; +} + +} // namespace + +TYdbTypeInfo DescribeYdbType(const TType& type) { + TYdbTypeInfo info; + info.TypeName = type.ToString(); + TTypeParser parser(type); + info.Nullable = parser.GetKind() == TTypeParser::ETypeKind::Optional + || parser.GetKind() == TTypeParser::ETypeKind::Null + ? SQL_NULLABLE + : SQL_NO_NULLS; + size_t optionals = 0; + while (parser.GetKind() == TTypeParser::ETypeKind::Optional) { + parser.OpenOptional(); + ++optionals; + } + for (size_t optional = 0; optional < optionals && info.TypeName.ends_with('?'); ++optional) { + info.TypeName.pop_back(); + } + if (parser.GetKind() == TTypeParser::ETypeKind::Null) { + info.SqlType = SQL_VARCHAR; + info.ColumnSize = 1; + } else if (parser.GetKind() == TTypeParser::ETypeKind::Decimal) { + const TDecimalType decimal = parser.GetDecimal(); + info.SqlType = SQL_DECIMAL; + info.ColumnSize = decimal.Precision; + info.DecimalDigits = decimal.Scale; + info.Radix = 10; + } else if (parser.GetKind() == TTypeParser::ETypeKind::Primitive) { + const EPrimitiveType type = parser.GetPrimitive(); + const auto it = std::ranges::find(PrimitiveSpecs, type, &TPrimitiveSpec::Type); + if (it != PrimitiveSpecs.end()) { + info.SqlType = it->SqlType; + info.ColumnSize = type == EPrimitiveType::Uint64 ? 20 : GetColumnSize(info.SqlType); + if (it->Integer) { + info.Unsigned = it->Unsigned; + info.DecimalDigits = 0; + info.Radix = 10; + } + } + } + while (optionals--) { + parser.CloseOptional(); + } + return info; +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/types.h b/odbc/src/utils/types.h new file mode 100644 index 00000000000..fd1b34680f0 --- /dev/null +++ b/odbc/src/utils/types.h @@ -0,0 +1,23 @@ +#pragma once + +#include + +#include "odbc_compat.h" +#include +#include + +namespace NYdb::NOdbc { + +struct TYdbTypeInfo { + std::string TypeName; + SQLSMALLINT SqlType = SQL_UNKNOWN_TYPE; + SQLULEN ColumnSize = 4096; + SQLSMALLINT Nullable = SQL_NO_NULLS; + std::optional DecimalDigits; + std::optional Radix; + bool Unsigned = false; +}; + +TYdbTypeInfo DescribeYdbType(const TType& type); + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/util.cpp b/odbc/src/utils/util.cpp new file mode 100644 index 00000000000..e957d7baf82 --- /dev/null +++ b/odbc/src/utils/util.cpp @@ -0,0 +1,168 @@ +#include "util.h" + +#include +#include + +namespace NYdb::NOdbc { + +namespace { + +void TrimInPlace(std::string& value) { + while (!value.empty() && std::isspace(static_cast(value.front()))) { + value.erase(value.begin()); + } + while (!value.empty() && std::isspace(static_cast(value.back()))) { + value.pop_back(); + } +} + +} // namespace + +std::string GetString(SQLCHAR* str, SQLINTEGER length) { + if (!str) { + return {}; + } + if (length == SQL_NTS) { + return std::string(reinterpret_cast(str)); + } + if (length <= 0) { + return {}; + } + size_t size = static_cast(length); + if (str[size - 1] == 0) { + --size; + } + return std::string(reinterpret_cast(str), size); +} + +std::string GetString(SQLWCHAR* str, SQLINTEGER length) { + if (!str) { + return {}; + } + + size_t size = 0; + if (length == SQL_NTS) { + while (str[size] != 0) { + ++size; + } + } else if (length > 0) { + size = static_cast(length); + if (str[size - 1] == 0) { + --size; + } + } else { + return {}; + } + + std::string result; + result.reserve(size); + for (size_t i = 0; i < size; ++i) { + uint32_t codePoint = str[i]; + if (codePoint >= 0xd800 && codePoint <= 0xdbff) { + if (i + 1 < size && str[i + 1] >= 0xdc00 && str[i + 1] <= 0xdfff) { + codePoint = 0x10000 + ((codePoint - 0xd800) << 10) + (str[++i] - 0xdc00); + } else { + codePoint = 0xfffd; + } + } else if (codePoint >= 0xdc00 && codePoint <= 0xdfff) { + codePoint = 0xfffd; + } + + if (codePoint <= 0x7f) { + result.push_back(static_cast(codePoint)); + } else if (codePoint <= 0x7ff) { + result.push_back(static_cast(0xc0 | (codePoint >> 6))); + result.push_back(static_cast(0x80 | (codePoint & 0x3f))); + } else if (codePoint <= 0xffff) { + result.push_back(static_cast(0xe0 | (codePoint >> 12))); + result.push_back(static_cast(0x80 | ((codePoint >> 6) & 0x3f))); + result.push_back(static_cast(0x80 | (codePoint & 0x3f))); + } else { + result.push_back(static_cast(0xf0 | (codePoint >> 18))); + result.push_back(static_cast(0x80 | ((codePoint >> 12) & 0x3f))); + result.push_back(static_cast(0x80 | ((codePoint >> 6) & 0x3f))); + result.push_back(static_cast(0x80 | (codePoint & 0x3f))); + } + } + return result; +} + +bool StartsWithPrefix(const char* s, size_t sLen, const char* prefix, size_t prefixLen) { + if (sLen < prefixLen) { + return false; + } + for (size_t i = 0; i < prefixLen; ++i) { + if (std::tolower(static_cast(s[i])) != + std::tolower(static_cast(prefix[i]))) { + return false; + } + } + return true; +} + +TConnectionStringEntries ParseConnectionStringEntries(std::string_view connectionString) { + TConnectionStringEntries entries; + size_t pos = 0; + while (pos < connectionString.size()) { + const size_t eq = connectionString.find('=', pos); + if (eq == std::string::npos) { + break; + } + std::string key(connectionString.substr(pos, eq - pos)); + TrimInPlace(key); + if (key.empty()) { + break; + } + + size_t valueStart = eq + 1; + size_t valueEnd = connectionString.size(); + if (valueStart < connectionString.size() && connectionString[valueStart] == '{') { + ++valueStart; + std::string value; + size_t i = valueStart; + while (i < connectionString.size()) { + if (connectionString[i] != '}') { + value.push_back(connectionString[i++]); + continue; + } + if (i + 1 < connectionString.size() && connectionString[i + 1] == '}') { + value.push_back('}'); + i += 2; + continue; + } + pos = i + 1; + if (pos < connectionString.size() && connectionString[pos] == ';') { + ++pos; + } + break; + } + if (i == connectionString.size()) { + pos = connectionString.size(); + } + entries.emplace_back(std::move(key), std::move(value)); + continue; + } + + const size_t sc = connectionString.find(';', valueStart); + if (sc != std::string::npos) { + valueEnd = sc; + pos = sc + 1; + } else { + pos = connectionString.size(); + } + std::string val(connectionString.substr(valueStart, valueEnd - valueStart)); + TrimInPlace(val); + entries.emplace_back(std::move(key), std::move(val)); + } + return entries; +} + +std::map ParseConnectionString(std::string_view connectionString) { + std::map params; + for (auto&& [key, value] : ParseConnectionStringEntries(connectionString)) { + params[std::move(key)] = std::move(value); + } + return params; +} + +} // namespace NYdb::NOdbc diff --git a/odbc/src/utils/util.h b/odbc/src/utils/util.h new file mode 100644 index 00000000000..deacd84fb87 --- /dev/null +++ b/odbc/src/utils/util.h @@ -0,0 +1,27 @@ +#pragma once + +#include + +#include "odbc_compat.h" + +#include +#include +#include +#include +#include + +namespace NYdb::NOdbc { + +std::string GetString(SQLCHAR* str, SQLINTEGER length); + +std::string GetString(SQLWCHAR* str, SQLINTEGER length); + +bool StartsWithPrefix(const char* s, size_t sLen, const char* prefix, size_t prefixLen); + +using TConnectionStringEntries = std::vector>; + +TConnectionStringEntries ParseConnectionStringEntries(std::string_view connectionString); + +std::map ParseConnectionString(std::string_view connectionString); + +} // namespace NYdb::NOdbc diff --git a/odbc/tests/CMakeLists.txt b/odbc/tests/CMakeLists.txt new file mode 100644 index 00000000000..b46f5781221 --- /dev/null +++ b/odbc/tests/CMakeLists.txt @@ -0,0 +1,38 @@ +set(YDB_ODBC_TEST_CONFIG_DIR "${CMAKE_BINARY_DIR}/odbc") +file(MAKE_DIRECTORY "${YDB_ODBC_TEST_CONFIG_DIR}") +if (CMAKE_CONFIGURATION_TYPES) + set(YDB_ODBC_TEST_INI "${YDB_ODBC_TEST_CONFIG_DIR}/$/odbc.ini") +else() + set(YDB_ODBC_TEST_INI "${YDB_ODBC_TEST_CONFIG_DIR}/odbc.ini") +endif() + +set(YDB_ODBC_DSN_SERVER "localhost:2136" CACHE STRING + "YDB endpoint in odbc.ini generated for ODBC integration tests") +set(YDB_ODBC_DSN_DATABASE "/local" CACHE STRING + "YDB database path in odbc.ini generated for ODBC integration tests") + +file(GENERATE OUTPUT "${YDB_ODBC_TEST_INI}" CONTENT +"[ODBC Data Sources] +YDB=YDB ODBC Driver + +[YDB] +Driver=$ +Description=YDB Database Connection +Server=${YDB_ODBC_DSN_SERVER} +Database=${YDB_ODBC_DSN_DATABASE} +AuthMode=Anonymous +") + +add_subdirectory(integration) +add_subdirectory(unit) + +# Internal headers need SDK compiler settings, but the driver already embeds +# the SDK: linking it again would register SDK globals twice. +foreach(target IN ITEMS odbc-concurrency_it odbc-descriptor_ut) + target_include_directories(${target} PRIVATE + $) + target_compile_options(${target} PRIVATE + $) + target_compile_definitions(${target} PRIVATE + $) +endforeach() diff --git a/odbc/tests/frameworks/README.md b/odbc/tests/frameworks/README.md new file mode 100644 index 00000000000..203d33c1d8d --- /dev/null +++ b/odbc/tests/frameworks/README.md @@ -0,0 +1,99 @@ +# ODBC consumer verification + +The matrix installs the same packaged driver in isolated YDB jobs. It runs after merge +into `odbc-driver-feature`, or on a pull request labelled `ODBC full matrix`. +The native SDK/compiler/YDB-version matrix remains separate. + +| Consumer | Upstream suite | +| --- | --- | +| package-contract | Debian installation, upgrade, removal and replacement | +| isql | unixODBC scalar-query smoke test (DSN) | +| Qt | QtSql database, query, model and threading tests | +| PHP | ext/odbc PHPT tests | +| PHP PDO | PDO_ODBC and generic PDO PHPT tests | +| Ruby | ruby-odbc ANSI and UTF-8 tests | +| Lua | LuaSQL ODBC tests | +| R | odbc generic tests and DBItest's standard ODBC contract | + +All bindings run in DSN and connection-string modes. R includes connection stress tests; +Arrow requires a separate binding API. Julia and Tcl are outside this matrix. + +## Sources and fixtures + +YDB follows `ydbplatform/local-ydb:trunk` for logical affected-row statistics. +Runtime bases are digest-pinned. +Consumers with archived upstream suites +have checksum-locked source archives and `upstream.lock`. `package-contract` and +`isql` use installed system packages. PHP sources match the installed Ubuntu runtime +release. Ruby, Lua and R bindings build from their locked source. +R additionally locks DBItest in `test-sources.lock` and includes generic regressions +from backend-named test files; their database-specific suites remain excluded. + +Sources are downloaded only into the test container, checked before extraction, and +kept out of SDK packages. Fixture patches apply to writable copies. They may change +schema, dialect, connection setup or test reporting; assertions must retain their +behavior. Consumer implementations are unmodified. +R's DBItest fixture patch supplies YDB types through `field.types` +and adds separate keys for duplicate, NULL and non-key payloads. Partial type overrides +still exercise inference for omitted payload columns. SQL generated by bindings still +exercises their original code. Qt's batch schema uses Double for its original Double +parameters; its model-column case keeps YDB's required key on a column the case retains. +The original binding calls and model assertions are unchanged. Applicable Qt join, +BLOB, affected-row, long-string and non-finite-number cases run past upstream +backend gates; feature exclusions do not replace their original assertions. +Qt source uses its GPL-3.0 Qt exception option +only in CI and is not distributed in SDK artifacts. + +Reports retain source revisions, archive and fixture checksums, runtime package +versions, driver commit, package checksum, YDB image and connection mode. + +## Results and exceptions + +Adapters discover an inventory before execution and report native `results.json` with +`inventory` and `tests`. IDs include the consumer and connection mode. Missing cases, +invalid output, adapter crashes, setup errors, unexplained skips and unexpected passes fail +validation. Framework data rows and diagnostics remain in native output and attachments. +Qt also checks data-row counts against its pinned source and fixture profile. + +Every applicable test must pass. Classifications cover fundamentally unsupported +functionality, inapplicable backend/platform cases, and independently reproduced +upstream consumer defects. Driver defects remain failures. Never classify a broken +fixture or missing dependency. `upstream_failure` requires an upstream `reference`, +a checked-in `reproducer`, and an exact case and diagnostic match; see [reproductions](repros/README.md). +Raw failures remain failures in Allure and are counted separately from passes. +Isolated consumer crashes retain debugger output and require the same diagnostic match. + +```yaml +classifications: + - outcome: unsupported + reason: Explain the fundamental limitation. + match: 'A stable diagnostic identifying the unsupported operation' + tests: + consumer: [consumer.*.suite.case] +``` + +`unsupported` requires a failed test; `skipped` requires an upstream skip. Every +reported problem must match the diagnostic. `broken` and setup failures are never +expected. Patterns must match results, must not overlap, and must not exempt entire +suites. Only reproduced intermittent upstream defects may set `allow_pass: true`; +other newly passing exceptions fail review. Raw status, message and trace are preserved; Allure adds the classification +separately. A changed diagnostic or a newly passing exception requires review. + +Aggregation requires every registered run and matching driver/package/YDB provenance. +It preserves attachment filenames and reports passes, upstream defects, expected limitations/skips and +unexpected outcomes separately. Genuine compatibility gaps keep the matrix red. + +## Running + +Validate the registry and harness: + +```sh +python3 odbc/tests/frameworks/harness.py registry +python3 -m unittest odbc.tests.test_integration_harness +``` + +Use `harness.py launch --consumer NAME --mode dsn --runtime-image IMAGE --package FILE +--results DIRECTORY` with `DRIVER_COMMIT`, `YDB_TEST_IMAGE`, `YDB_ENDPOINT` and +`YDB_DATABASE` set. The image must match the registry. Use `connection_string` for +the second mode and `all` for package-contract. The launcher needs Docker access. +The full CI matrix and report aggregation come from the registry. diff --git a/odbc/tests/frameworks/bindings/Dockerfile b/odbc/tests/frameworks/bindings/Dockerfile new file mode 100644 index 00000000000..d0e5248cb9b --- /dev/null +++ b/odbc/tests/frameworks/bindings/Dockerfile @@ -0,0 +1,14 @@ +ARG RUNTIME_IMAGE +FROM ${RUNTIME_IMAGE} +ENV DEBIAN_FRONTEND=noninteractive +RUN apt-get update && apt-get install -y --no-install-recommends \ + build-essential ca-certificates gdb patch python3 python3-yaml unixodbc unixodbc-dev odbcinst \ + php-cli php-odbc \ + ruby ruby-dev \ + lua5.4 liblua5.4-dev \ + r-base-core r-cran-rcpp r-cran-bit64 r-cran-blob r-cran-hms r-cran-r6 r-cran-vctrs r-cran-rlang r-cran-withr r-cran-cli r-cran-testthat r-cran-dbitest r-cran-pkgload \ + && dpkg-query -W > /runtime-packages.txt \ + && rm -rf /var/lib/apt/lists/* + +RUN apt-get update && apt-get install -y --no-install-recommends php-mbstring php-xml \ + && dpkg-query -W > /runtime-packages.txt && rm -rf /var/lib/apt/lists/* diff --git a/odbc/tests/frameworks/bindings/adapter.py b/odbc/tests/frameworks/bindings/adapter.py new file mode 100644 index 00000000000..693cd978afe --- /dev/null +++ b/odbc/tests/frameworks/bindings/adapter.py @@ -0,0 +1,128 @@ +"""Shared plumbing for upstream suites; bindings and assertions stay upstream.""" +import json +import os +import shutil +import subprocess +import time +import traceback +import xml.etree.ElementTree as ET +from pathlib import Path +from urllib.parse import quote + +class Suite: + def __init__(self): + self.adapter = Path(os.environ['ODBC_ADAPTER_DIR']) + self.native = Path(os.environ['ODBC_NATIVE_RESULTS_DIR']) + self.consumer = self.adapter.name + self.mode = os.environ['ODBC_TEST_MODE'] + self.connection = os.environ['YDB_ODBC_DSN' if self.mode == 'dsn' else 'YDB_ODBC_CONNECTION_STRING'] + self.source = Path('/work/source') + self.tests, self.inventory = [], [] + self.started = int(time.time() * 1000) + + def prepare(self): + upstream = Path(os.environ['ODBC_UPSTREAM_DIR']) + if self.consumer == 'ruby': + archive = Path('/work/ruby-source.tar.gz') + archive.write_bytes((upstream / 'data.tar.gz').read_bytes()) + import sys + sys.path.insert(0, os.environ['ODBC_HARNESS_DIR']) + from harness import safe_extract + safe_extract(archive, self.source) + else: + children = list(upstream.iterdir()) + original = children[0] if len(children) == 1 and children[0].is_dir() else upstream + shutil.copytree(original, self.source) + for directory, _, files in os.walk(self.source): + Path(directory).chmod(0o755) + for name in files: + path = Path(directory) / name + if not path.is_symlink(): path.chmod(path.stat().st_mode | 0o200) + patch = self.adapter / 'ydb.patch' + if patch.exists(): self.command(['patch', '--batch', '--fuzz=0', '-p1', '-i', patch], 'fixture-patch') + packages = Path('/runtime-packages.txt') + if packages.exists(): shutil.copyfile(packages, self.native / packages.name) + return self.source + + def command(self, args, name='build', *, check=True, env=None, cwd=None, timeout=600): + log = self.native / (quote(name, safe='._-') + '.log') + try: + result = subprocess.run([str(a) for a in args], cwd=cwd or self.source, + env=os.environ | (env or {}), + stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=timeout) + except subprocess.TimeoutExpired as error: + log.write_bytes(error.stdout or b'') + raise + log.write_bytes(result.stdout or b'') + result.stdout = (result.stdout or b'').decode('utf-8', errors='backslashreplace') + if check and result.returncode: + raise RuntimeError(f'{name} exited {result.returncode}: {(result.stdout or "")[-3000:]}') + if not check and (result.returncode < 0 or result.returncode > 1): + self.add('infrastructure', 'broken', f'{name} exited {result.returncode}', + phase='infrastructure', attachments=[log]) + return result + + def dependencies(self): + import hashlib, urllib.request, yaml + import sys + sys.path.insert(0, os.environ['ODBC_HARNESS_DIR']) + from harness import safe_extract + sources = yaml.safe_load((self.adapter / 'test-sources.lock').read_text()) + paths = {} + for name, source in sources.items(): + archive = Path('/work') / (name + '.tar.gz') + urllib.request.urlretrieve(source['url'], archive) + if hashlib.sha256(archive.read_bytes()).hexdigest() != source['sha256']: + raise RuntimeError('Test dependency checksum mismatch: ' + name) + destination = Path('/work') / name + safe_extract(archive, destination) + paths[name] = next(destination.iterdir()) + (self.native / 'test-sources.json').write_text(json.dumps(sources, indent=2)) + return paths + + def test_id(self, name): + return f'{self.consumer}.{self.mode}.' + quote(str(name), safe='._-') + + def plan(self, names): + self.inventory = [self.test_id(name) for name in names] + self.save() + + def add(self, name, status, message='', *, phase='test', attachments=(), problems=None, rows=None): + self.tests.append(dict(id=self.test_id(name), name=str(name), status=status, + message=message, phase=phase, start=self.started, + stop=int(time.time() * 1000), + attachments=[dict(name=p.name, path=p.name, type='text/plain') for p in attachments], + **({'problems': problems} if problems else {}), **({'rows': rows} if rows else {}))) + self.save() + + def save(self): + (self.native / 'results.json').write_text(json.dumps( + dict(schema_version=1, inventory=self.inventory, tests=self.tests), indent=2) + '\n') + + def junit(self, path, names, *, name_of=lambda case: case.get('name'), log=None, + attachments_of=lambda name: []): + cases = list(ET.parse(path).getroot().iter('testcase')) + actual = {} + for case in cases: + actual.setdefault(name_of(case), []).append(case) + for name in names: + selected = actual.get(name, []) + problems = [dict(kind=item.tag, message=item.get('message', '') or ''.join(item.itertext()), + trace=''.join(item.itertext()), location=case.get('file', '') + ':' + case.get('line', '')) + for case in selected for item in case if item.tag in {'failure', 'error', 'skipped'}] + tags = {item.tag for case in selected for item in case} + status = 'broken' if not selected or 'error' in tags else 'failed' if 'failure' in tags else 'skipped' if 'skipped' in tags else 'passed' + self.add(name, status, problems[0]['message'] if problems else '' if selected else 'Missing upstream test result', + attachments=[path] + ([log] if log else []) + attachments_of(name), problems=problems) + extra = set(actual) - set(names) + if extra: self.add('infrastructure', 'broken', f'Unplanned upstream cases: {sorted(extra)}', phase='infrastructure') + +def run(main): + suite = Suite() + try: + suite.prepare() + main(suite) + except Exception: + suite.add('infrastructure', 'broken', traceback.format_exc(), phase='infrastructure') + return 2 + return int(any(t['status'] != 'passed' for t in suite.tests)) diff --git a/odbc/tests/frameworks/bindings/php.py b/odbc/tests/frameworks/bindings/php.py new file mode 100644 index 00000000000..c3f5255d6d4 --- /dev/null +++ b/odbc/tests/frameworks/bindings/php.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +import re, shutil +from urllib.parse import quote +from pathlib import Path + +def main(s): + directory = 'ext/odbc/tests' if s.consumer == 'php-odbc' else 'ext/pdo_odbc/tests' + paths = sorted((s.source / directory).glob('*.phpt')) + if s.consumer == 'php-pdo': paths += sorted((s.source / 'ext/pdo/tests').glob('*.phpt')) + paths = [p for p in paths if '--TEST--' in p.read_text(errors='replace') and '--REDIRECTTEST--' not in p.read_text(errors='replace')] + # Syntax-check changed FILE sections before running the upstream harness. + lint = Path('/work/php-lint'); lint.mkdir(exist_ok=True) + for index,path in enumerate(paths): + section = re.search(rb'(?ms)^--FILE--\s*$(.*?)(?=^--[A-Z_]+--\s*$|\Z)',path.read_bytes()) + if section: + target = lint / (str(index)+'.php'); target.write_bytes(section[1]) + s.command(['php','-l',target], 'syntax-'+str(index)) + names = [str(p.relative_to(s.source)) for p in paths] + s.plan(names) + env = {'ODBC_TEST_DSN': s.connection, 'ODBC_TEST_USER': '', 'ODBC_TEST_PASS': '', + 'PDOTEST_DSN': 'odbc:' + ('DSN=' if s.mode == 'dsn' else '') + s.connection, + 'PDOTEST_USER': '', 'PDOTEST_PASS': '', 'NO_INTERACTION': '1', + 'REDIR_TEST_DIR':str(s.source/'ext/pdo/tests')+'/', 'TEST_PHP_EXECUTABLE': '/usr/bin/php', 'TEST_PHP_JUNIT': str(s.native / 'php.xml')} + connect = ('$c=odbc_connect(getenv("ODBC_TEST_DSN"), "", ""); if (!$c) exit(2);' + if s.consumer == 'php-odbc' else 'new PDO(getenv("PDOTEST_DSN"), "", "");') + s.command(['php', '-r', connect], 'connect', env=env) + s.command(['php', 'run-tests.php', '-q', '--offline', '--set-timeout', '60', *paths], + 'upstream', env=env, check=False, timeout=1200) + attachments = {} + for path,name in zip(paths,names): + attachments[name] = [] + for suffix in ['.out','.diff','.exp']: + output = path.with_suffix(suffix) + if output.exists(): + target = s.native / (quote(name, safe='._-') + suffix) + shutil.copyfile(output, target); attachments[name].append(target) + s.junit(s.native / 'php.xml', names, name_of=lambda case: case.get('name', '').split(' ')[0], + log=s.native / 'upstream.log', attachments_of=lambda name: attachments[name]) diff --git a/odbc/tests/frameworks/harness.py b/odbc/tests/frameworks/harness.py new file mode 100755 index 00000000000..00f6af851da --- /dev/null +++ b/odbc/tests/frameworks/harness.py @@ -0,0 +1,653 @@ +#!/usr/bin/env python3 +import argparse +from collections import Counter +import fnmatch +import hashlib +import json +import os +import pwd +import re +import shutil +import subprocess +import sys +import tarfile +import time +import urllib.request +import uuid +from pathlib import Path +import yaml +ROOT = Path(__file__).resolve().parent +REGISTRY = ROOT / "registry.yaml" +RESULTS = Path("/results") +WORK = Path("/work") +IMAGE_RE = re.compile(r"^.+@sha256:[0-9a-f]{64}$") +SOURCE_RE = re.compile(r"^[0-9a-f]{64}$") +EXPECTED_OUTCOMES = ("unsupported", "skipped", "upstream_failure") +class HarnessError(ValueError): + pass +def require(condition, message): + if not condition: + raise HarnessError(message) +def expand_pattern(pattern): + match = re.search(r"\{([^{}]+)\}", pattern) + if not match: + return [pattern] + return [expanded for value in match.group(1).split(",") + for expanded in expand_pattern(pattern[:match.start()] + value + pattern[match.end():])] +def glob_ids(names, pattern): + return {name for name in names if any(fnmatch.fnmatch(name, item) for item in expand_pattern(pattern))} +def read_yaml(path): + try: + return yaml.safe_load(path.read_text(encoding="utf-8")) + except (OSError, yaml.YAMLError) as error: + raise HarnessError(f"cannot read {path}: {error}") from error +def load_classifications(data, consumers): + consumer_ids = {item.get("id") for item in consumers if isinstance(item, dict)} + grouped = {consumer: {outcome: {} for outcome in EXPECTED_OUTCOMES} for consumer in consumer_ids} + classifications = data.get("classifications", []) + require(isinstance(classifications, list), "classifications must be a list") + for index, group in enumerate(classifications): + require(isinstance(group, dict), f"classification {index}: must be a mapping") + outcome, reason, tests = group.get("outcome"), group.get("reason"), group.get("tests") + require(outcome in EXPECTED_OUTCOMES, + f"classification {index}: invalid outcome") + require(isinstance(reason, str) and reason.strip(), + f"classification {index}: reason must be a non-empty string") + match = group.get("match") + require(isinstance(match, str) and match.strip(), + f"classification {index}: a diagnostic match is required") + re.compile(match) + allow_pass = group.get("allow_pass", False) + require(isinstance(allow_pass, bool) and (not allow_pass or outcome == "upstream_failure"), + f"classification {index}: only upstream failures may allow intermittent passes") + if outcome == "upstream_failure": + reference, reproducer = group.get("reference", ""), group.get("reproducer", "") + require(isinstance(reference, str) and reference.startswith("https://"), + f"classification {index}: upstream reference is required") + require(isinstance(reproducer, str) and reproducer.startswith("repros/") + and ".." not in Path(reproducer).parts and (ROOT / reproducer).is_file(), + f"classification {index}: checked-in reproducer is required") + reason += f" Reference: {reference}. Reproducer: {reproducer}." + require(isinstance(tests, dict) and tests, + f"classification {index}: tests must be a non-empty consumer mapping") + for consumer, patterns in tests.items(): + require(consumer in consumer_ids, f"classification {index}: unknown consumer: {consumer}") + require(isinstance(patterns, list) and patterns + and all(isinstance(pattern, str) and pattern for pattern in patterns), + f"classification {index}: {consumer} patterns must be non-empty strings") + for pattern in patterns: + require(pattern not in grouped[consumer][outcome], + f"duplicate classification: {consumer}: {pattern}") + grouped[consumer][outcome][pattern] = {"reason": reason, "match": match, "allow_pass": allow_pass} + return grouped +def load_registry(path=REGISTRY): + data = read_yaml(path); require(isinstance(data, dict) and data.get("schema_version") == 2, + "unsupported registry schema") + ydb = data.get("ydb", {}); consumers = data.get("consumers") + require(ydb.get("image") == "ydbplatform/local-ydb:trunk", "YDB image must provide logical affected-row statistics") + require(ydb.get("endpoint") and str(ydb.get("database", "")).startswith("/"), + "YDB endpoint and absolute database are required") + require(isinstance(consumers, list) and consumers, "registry has no consumers") + classifications = load_classifications(data, consumers) + seen = set() + for item in consumers: + consumer = item.get("id") if isinstance(item, dict) else None; adapter = path.parent / str(consumer) + require(re.match(r"^[a-z][a-z0-9_-]*$", str(consumer or "")), + f"invalid consumer id: {consumer}") + require(consumer not in seen, f"duplicate consumer id: {consumer}"); seen.add(consumer) + require(item.get("kind") in {"package", "smoke", "framework"}, f"{consumer}: invalid kind") + require(item.get("tier") in {"smoke", "core", "expansion"}, f"{consumer}: invalid tier") + for field in ("display_name", "language"): require(item.get(field), f"{consumer}: {field} is required") + require(isinstance(item.get("runtime_version"), list) + and all(isinstance(value, str) for value in item["runtime_version"]), + f"{consumer}: runtime_version must be a command list") + require(IMAGE_RE.match(str(item.get("runtime_image", ""))), + f"{consumer}: runtime image must be digest-pinned") + require((path.parent / item.get("dockerfile", f"{consumer}/Dockerfile")).is_file(), + f"{consumer}: missing Dockerfile") + runner, tests = adapter / "run-tests", item.get("tests", []) + require(item["kind"] == "package" or tests or runner.is_file(), + f"{consumer}: tests or run-tests are required") + require(not runner.exists() or os.access(runner, os.X_OK), f"{consumer}: run-tests is not executable") + for test in tests: + require(isinstance(test, dict) and test.get("id") and test.get("name") + and isinstance(test.get("command"), list) and test["command"], + f"{consumer}: invalid declarative test") + if test.get("output_regex"): re.compile(test["output_regex"]) + expected = item.get("expected", {}) + require(isinstance(expected, dict), f"{consumer}: expected results must be a mapping") + require(not (set(EXPECTED_OUTCOMES) & set(expected)), + f"{consumer}: classifications must be declared in the top-level classification list") + expected.update(classifications[consumer]) + discovered = expected.get("discovered", False) + required = expected.get("required", []) + unsupported = expected.get("unsupported", {}) + skipped = expected.get("skipped", {}) + upstream_failure = expected.get("upstream_failure", {}) + require(isinstance(discovered, bool), f"{consumer}: discovered must be boolean") + require(isinstance(required, list) and (required or discovered), + f"{consumer}: required tests are empty") + require(all(isinstance(pattern, str) and pattern for pattern in required) + and len(required) == len(set(required)), + f"{consumer}: required tests contain invalid or duplicate patterns") + require(isinstance(unsupported, dict), f"{consumer}: unsupported tests must be a mapping") + require(isinstance(skipped, dict), f"{consumer}: skipped tests must be a mapping") + require(all(isinstance(pattern, str) and pattern and isinstance(rule, dict) + and rule.get("reason") and rule.get("match") + for patterns in (unsupported, skipped, upstream_failure) for pattern, rule in patterns.items()), + f"{consumer}: expected-result patterns and reasons must be non-empty strings") + require(sum(len(rules) for rules in (unsupported, skipped, upstream_failure)) + == len(set(unsupported) | set(skipped) | set(upstream_failure)), + f"{consumer}: duplicate or unexplained expectations") + broad = [pattern for patterns in (unsupported, skipped, upstream_failure) for pattern in patterns + if pattern.endswith(".*")] + require(not discovered or not broad, + f"{consumer}: suite-wide expected-result patterns are forbidden: {', '.join(broad)}") + require(not tests or {test["id"] for test in tests} == set(required), + f"{consumer}: declarative tests differ from required tests") + modes = item.get("modes", []) + require(item["kind"] == "package" or (modes and set(modes) <= {"dsn", "connection_string"}), + f"{consumer}: invalid connection modes") + source = item.get("source") + if item["kind"] == "framework": + require(isinstance(source, dict) and source.get("kind") == "archive", + f"{consumer}: upstream source must be an archive") + require(source.get("url") and source.get("revision") + and SOURCE_RE.match(str(source.get("sha256", ""))), + f"{consumer}: invalid pinned source") + require(read_yaml(adapter / "upstream.lock") == source, f"{consumer}: upstream.lock differs from registry") + else: + require(source == "system", f"{consumer}: smoke/package source must be system") + return data +def consumer_runs(data): + for consumer in data["consumers"]: + modes = consumer.get("modes") or ["all"] + for mode in modes: + run_id = consumer["id"] if mode == "all" else f"{consumer['id']}-{mode}" + yield {"consumer": consumer["id"], "mode": mode, "run_id": run_id, + "display_name": consumer["display_name"], + "runtime_image": consumer["runtime_image"]} +def command(args, *, env=None, capture=False, user=None, check=True, input_text=None, timeout=None): + options = {"env": env, "text": True, "check": check} + if input_text is not None: options["input"] = input_text + if capture: options.update(stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + if user: + account = pwd.getpwnam(user) + def demote(): + os.setgroups([]); os.setgid(account.pw_gid); os.setuid(account.pw_uid) + options["preexec_fn"] = demote + return subprocess.run([str(value) for value in args], timeout=timeout, **options) +def append_result(output, test_id, name, status, start, stop, message="", log=None): + document = json.loads(output.read_text()) if output.exists() else {"schema_version": 1, "tests": []} + result = {"id": test_id, "name": name, "status": status, "start": start, "stop": stop} + if message: result["message"] = message + if log: result["attachments"] = [{"name": log.name, "path": log.name, "type": "text/plain"}] + output.parent.mkdir(parents=True, exist_ok=True); document["tests"].append(result) + output.write_text(json.dumps(document, indent=2, sort_keys=True) + "\n", encoding="utf-8") +def infrastructure_test_id(consumer_id, mode): + return f"{consumer_id}.{mode}.infrastructure" if mode != "all" else f"{consumer_id}.infrastructure" +def logged(log, args, **options): + result = command(args, capture=True, check=False, **options) + log.append(f"$ {' '.join(map(str, args))}\n{result.stdout or ''}") + require(result.returncode == 0, f"{args[0]} exited with status {result.returncode}") + return result.stdout or "" +def record_case(native, test_id, name, action): + start, lines, status, message = int(time.time() * 1000), [], "passed", "" + try: + action(lines) + except Exception as error: + status, message = "failed", str(error); lines.append(f"\n{type(error).__name__}: {error}\n") + stop, log = int(time.time() * 1000), native / f"{test_id.replace('.', '-')}.log" + log.write_text("".join(lines), encoding="utf-8") + append_result(native / "results.json", test_id, name, status, start, stop, message, log) + return status != "passed" +def safe_extract(archive, destination): + destination.mkdir(parents=True); root = destination.resolve() + def check(name): + try: + (destination / name).resolve().relative_to(root) + except ValueError as error: + raise HarnessError(f"unsafe upstream path: {name}") from error + require(tarfile.is_tarfile(archive), "upstream source is not a tar archive") + with tarfile.open(archive) as stream: + for member in stream.getmembers(): + check(member.name); require(not member.islnk(), f"upstream hard link: {member.name}") + if member.issym(): check(str(Path(member.name).parent / member.linkname)) + stream.extractall(destination) + for path in sorted(destination.rglob("*"), reverse=True): + if not path.is_symlink(): + path.chmod(0o555 if path.is_dir() or path.stat().st_mode & 0o111 else 0o444) + destination.chmod(0o555) +def prepare_source(consumer): + source = consumer["source"] + if source == "system": return "system", "system", Path("/nonexistent-upstream") + archive = WORK / "upstream.archive"; urllib.request.urlretrieve(source["url"], archive) + actual = hashlib.sha256(archive.read_bytes()).hexdigest() + require(actual == source["sha256"], f"upstream checksum mismatch: {actual}") + upstream = WORK / "upstream"; safe_extract(archive, upstream) + return source["revision"], source["sha256"], upstream +def inspect_package(package): + field = lambda name: command(["dpkg-deb", "-f", package, name], capture=True).stdout.strip() + require(field("Package") == "ydb-odbc", "artifact is not the ydb-odbc package") + return field("Version"), hashlib.sha256(package.read_bytes()).hexdigest() +def install_package(package): + command(["apt-get", "update"]) + command(["apt-get", "install", "-y", "--no-install-recommends", package]) + files = command(["dpkg-query", "-L", "ydb-odbc"], capture=True).stdout.splitlines() + drivers = [Path(value).resolve() for value in files if value.endswith("/libydb-odbc.so")] + require(len(drivers) == 1 and drivers[0].is_file(), f"expected one installed driver: {drivers}") + driver = drivers[0]; owner = command(["dpkg-query", "-S", driver], capture=True).stdout.strip() + require(owner.startswith("ydb-odbc:"), f"driver has wrong package owner: {owner}") + registration = command(["odbcinst", "-q", "-d", "-n", "YDB"], capture=True).stdout + require(f"Driver={driver}" in registration and f"Setup={driver}" in registration, + "YDB driver registration is invalid") + return str(driver) +def write_dsn(consumer_id, endpoint, database): + dsn = f"YDB_{consumer_id}" + Path("/etc/odbc.ini").write_text(f"[ODBC Data Sources]\n{dsn}=YDB ODBC Driver\n\n[{dsn}]\nDriver=YDB\n" + f"Server={endpoint}\nDatabase={database}\nAuthMode=Anonymous\nAnsiSQL=1\n") + return dsn +def package_suite(package, native): + multiarch = command(["dpkg-architecture", "-qDEB_HOST_MULTIARCH"], capture=True).stdout.splitlines()[-1] + driver, template = Path(f"/usr/lib/{multiarch}/libydb-odbc.so"), Path("/usr/share/ydb-odbc/odbcinst.ini") + old, unpacked, state = Path("/tmp/ydb-odbc-old.deb"), Path("/tmp/ydb-odbc-old"), {} + def field(log, name): return logged(log, ["dpkg-deb", "-f", package, name]).strip() + def registration(log): + value = logged(log, ["odbcinst", "-q", "-d", "-n", "YDB"]) + for expected in (f"Driver={driver}", f"Setup={driver}", "UsageCount=1"): require(expected in value.splitlines(), f"missing registration: {expected}") + def unchanged(): + require(all(hashlib.sha256(path.read_bytes()).hexdigest() == digest + for path, digest in state["configs"].items()), "ODBC configuration changed") + def clean(log): + logged(log, ["apt-get", "update"]); require(field(log, "Package") == "ydb-odbc", "wrong package name") + require(field(log, "Architecture") == command(["dpkg", "--print-architecture"], capture=True).stdout.strip(), + "wrong package architecture") + depends = field(log, "Depends") + for dependency in ("odbcinst", "libodbcinst2", "libc6"): require(re.search(fr"(^|, ){dependency}([ (]|,|$)", depends), f"missing dependency: {dependency}") + unrelated = Path("/tmp/unrelated.ini") + unrelated.write_text(f"[UnrelatedPackageTest]\nDriver=/usr/lib/{multiarch}/libodbc.so.2\nSetup=/usr/lib/{multiarch}/libodbcinst.so.2\n") + logged(log, ["odbcinst", "-i", "-d", "-f", unrelated]) + configs = {Path("/etc/odbc.ini"): "[UnrelatedSystemDsn]\nDriver=UnrelatedPackageTest\n", + Path("/root/.odbc.ini"): "[UnrelatedUserDsn]\nDriver=UnrelatedPackageTest\n"} + for path, content in configs.items(): path.write_text(content) + state["configs"] = {path: hashlib.sha256(path.read_bytes()).hexdigest() for path in configs} + shutil.rmtree(unpacked, ignore_errors=True); logged(log, ["dpkg-deb", "--raw-extract", package, unpacked]) + control, version = unpacked / "DEBIAN/control", field(log, "Version") + control.write_text(re.sub(r"^Version: .*$", f"Version: {version}~integration1", + control.read_text(), flags=re.MULTILINE)) + logged(log, ["dpkg-deb", "--build", unpacked, old]); logged(log, ["apt-get", "install", "-y", old]) + require(driver.is_file() and template.is_file(), "installed files are missing") + require(f"Driver={driver}" in template.read_text().splitlines(), "invalid registration template") + require(logged(log, ["dpkg-query", "-S", driver]).startswith("ydb-odbc:"), "wrong file owner"); registration(log) + def upgrade(log): + logged(log, ["apt-get", "install", "-y", package]) + require(logged(log, ["dpkg-query", "-W", "-f=${Version}", "ydb-odbc"]).strip() + == field(log, "Version"), "upgrade version differs") + registration(log); unchanged() + def remove(log): + logged(log, ["apt-get", "remove", "-y", "ydb-odbc"]) + require(not driver.exists() and not template.exists(), "package files remain") + result = command(["odbcinst", "-q", "-d", "-n", "YDB"], capture=True, check=False) + log.append(result.stdout or ""); require(result.returncode != 0, "YDB registration remains") + logged(log, ["odbcinst", "-q", "-d", "-n", "UnrelatedPackageTest"]); unchanged() + def replacement(log): + logged(log, ["apt-get", "install", "-y", package]); registration(log) + logged(log, ["odbcinst", "-u", "-d", "-n", "YDB"]) + replacement_file = Path("/tmp/replacement.ini"); replacement_file.write_text(f"[YDB]\nDriver=/usr/lib/{multiarch}/libodbc.so.2\nSetup=/usr/lib/{multiarch}/libodbcinst.so.2\n") + logged(log, ["odbcinst", "-i", "-d", "-f", replacement_file]) + expected = logged(log, ["odbcinst", "-q", "-d", "-n", "YDB"]); logged(log, ["apt-get", "remove", "-y", "ydb-odbc"]) + require(logged(log, ["odbcinst", "-q", "-d", "-n", "YDB"]) == expected, + "replacement registration changed"); unchanged() + cases = [("package.clean_install", "Install and register ydb-odbc", clean), + ("package.upgrade", "Upgrade without duplicate registration", upgrade), + ("package.remove", "Remove without changing unrelated configuration", remove), + ("package.replacement", "Preserve a replacement YDB registration", replacement)] + return int(any([record_case(native, *case) for case in cases])) +def declarative_suite(consumer, env, native): + values = {"dsn": env["YDB_ODBC_DSN"], "connection_string": env["YDB_ODBC_CONNECTION_STRING"], + "endpoint": env["YDB_ENDPOINT"], "database": env["YDB_DATABASE"], + "upstream": env["ODBC_UPSTREAM_DIR"]} + failures = [] + for test in consumer["tests"]: + args = [value.format(**values) for value in test["command"]] + def action(log, test=test, args=args): + output = logged(log, args, env=env, user="nobody", input_text=test.get("stdin")) + require(not test.get("output_regex") or re.search(test["output_regex"], output, re.MULTILINE), + "output did not match expected pattern") + failures.append(record_case(native, test["id"], test["name"], action)) + return int(any(failures)) +def launch_consumer(consumer, mode, runtime, package, results): + package, adapter = package.resolve(), ROOT / consumer + item = next(item for item in load_registry()["consumers"] if item["id"] == consumer) + dockerfile = ROOT / item.get("dockerfile", f"{consumer}/Dockerfile") + require(runtime == item["runtime_image"], "runtime image differs from registry") + require(package.is_file() and dockerfile.is_file(), "package or adapter is missing") + results.mkdir(parents=True, exist_ok=True); results = results.resolve(); results.chmod(0o777) + image_name = f"ydb-odbc-{consumer}:{os.getenv('GITHUB_RUN_ID', 'local')}-{os.getenv('GITHUB_RUN_ATTEMPT', '1')}" + command(["docker", "build", "--build-arg", f"RUNTIME_IMAGE={runtime}", + "-f", dockerfile, "-t", image_name, ROOT], timeout=1800) + args = ["docker", "run", "--rm", "--network", "host", "--hostname", "odbc-test", "--user", "0:0", + "-v", f"{ROOT}:/harness:ro", "-v", f"{package.parent}:/packages:ro", + "-v", f"{results}:/results", "-e", f"ODBC_PACKAGE_BASENAME={package.name}", + "-e", f"ODBC_RUNTIME_IMAGE={runtime}", "-e", f"ODBC_TEST_MODE={mode}"] + for name in ("DRIVER_COMMIT", "YDB_TEST_IMAGE", "YDB_ENDPOINT", "YDB_DATABASE"): + require(os.getenv(name), f"{name} is required") + args += ["-e", f"{name}={os.environ[name]}"] + return command(args + [image_name, "python3", "/harness/harness.py", "run", "--consumer", consumer, + "--mode", mode], + check=False).returncode +def convert_allure(native, output, metadata): + tests = json.loads(native.read_text())["tests"]; output.mkdir(exist_ok=True) + for old in output.glob("*-result.json"): old.unlink() + attachment_files = {} + for test in tests: + result_id = str(uuid.uuid5(uuid.NAMESPACE_URL, f"ydb-odbc:{metadata['consumer']}:{test['id']}")) + attachments = [] + for index, attachment in enumerate(test.get("attachments", [])): + source = native.parent / attachment["path"]; require(source.is_file(), f"missing attachment for {test['id']}: {source}") + target = attachment_files.get(source) + if target is None: + attachment_id = uuid.uuid5(uuid.NAMESPACE_URL, f"ydb-odbc:{metadata['run_id']}:{attachment['path']}") + target = f"{attachment_id}-attachment{source.suffix or '.txt'}" + shutil.copyfile(source, output / target); attachment_files[source] = target + attachments.append({"name": attachment.get("name", source.name), + "source": target, "type": attachment.get("type", "text/plain")}) + result = { + "uuid": result_id, "historyId": f"{metadata['consumer']}::{test['id']}", + "testCaseId": test["id"], "name": test.get("name", test["id"]), + "fullName": f"{metadata['consumer']}.{test['id']}", "status": test["status"], + "stage": "finished", "start": test["start"], "stop": test["stop"], + "labels": [{"name": key, "value": str(metadata[value])} for key, value in + (("suite", "consumer"), ("language", "language"), ("tier", "tier"), ("driverCommit", "driver_commit"), + ("runtimeVersion", "runtime_version"), ("ydbImage", "ydb_image"), + ("connectionMode", "connection_mode"))] + ([{"name": "originalStatus", "value": test["status"]}] if test.get("expected") else []), + "parameters": [{"name": key, "value": str(metadata[value])} for key, value in + (("endpoint", "endpoint"), ("database", "database"), + ("packageSha256", "package_sha256"), + ("upstreamRevision", "upstream_revision"), + ("upstreamSha256", "upstream_sha256"))], + "attachments": attachments, + } + if test.get("expected"): + result["labels"].append({"name": "expectedOutcome", "value": test["expected"]}) + if test.get("message") or test.get("trace"): result["statusDetails"] = {key: test[key] for key in ("message", "trace") if test.get(key)} | ({"known": True} if test.get("expected") else {}) + if test.get("expected"): + result.setdefault("statusDetails", {})["message"] = ( + f"Expected {test['expected']}: {test['expected_reason']}\nReported {test['status'].upper()}: " + + test.get("message", "")) + (output / f"{result_id}-result.json").write_text(json.dumps(result, indent=2, sort_keys=True) + "\n") + properties = {key: metadata[key] for key in + ("consumer", "connection_mode", "run_id", "runtime_version", "driver_commit", "package_sha256", + "ydb_image", "endpoint", "database", "upstream_revision", "upstream_sha256")} + (output / "environment.properties").write_text("".join(f"{key}={value}\n" for key, value in sorted(properties.items()))) +def matching_ids(actual, pattern): + return {test_id for test_id, test in actual.items() + if glob_ids({test_id, test.get("parent_id", test_id)}, pattern)} + +def expected_result(test, expectations): + matches = [(outcome, rule) for outcome in EXPECTED_OUTCOMES + for pattern, rule in expectations.get(outcome, {}).items() + if glob_ids({test["id"], test.get("parent_id", test["id"])}, pattern)] + if len(matches) != 1: + return None + outcome, rule = matches[0] + # Setup errors, crashes and missing results can never be expected. + status = "skipped" if outcome == "skipped" else "failed" + if test.get("status") != status or test.get("phase", "test") != "test": + return None + problems = test.get("problems") or [{"message": test.get("message", ""), + "trace": test.get("trace", "")}] + if not all(problem.get("kind", status) in ({"failure", "failed"} if status == "failed" else {"skipped"}) + and re.search(rule["match"], "\n".join(str(problem.get(key, "")) + for key in ("message", "trace", "location"))) for problem in problems): + return None + return outcome, rule["reason"] + +def validate_classified_results(actual, expectations): + errors = [] + patterns = {"required": expectations.get("required", []), + "unsupported": expectations.get("unsupported", {}), + "skipped": expectations.get("skipped", {}), + "upstream_failure": expectations.get("upstream_failure", {})} + matches = {outcome: {pattern: matching_ids(actual, pattern) for pattern in values} + for outcome, values in patterns.items()} + for outcome, classified in matches.items(): + for pattern, test_ids in classified.items(): + if not test_ids and (expectations.get("discovered") or outcome != "required"): + errors.append(f"{outcome} expectation pattern matched no tests: {pattern}") + for test_id, test in actual.items(): + exceptions = [(outcome, pattern) for outcome in EXPECTED_OUTCOMES + for pattern, ids in matches[outcome].items() if test_id in ids] + if len(exceptions) > 1: + errors.append(f"{test_id}: ambiguous expected result: {exceptions}") + elif exceptions: + outcome = exceptions[0][0] + rule = expectations[outcome][exceptions[0][1]] + if test.get("status") == "passed" and rule.get("allow_pass") and test.get("phase", "test") == "test": + continue + if not expected_result(test, expectations): + errors.append(f"{test_id}: unexpected status or diagnostic for {outcome}: " + f"{test.get('status')}: {test.get('message', '')}") + elif not any(test_id in ids for ids in matches["required"].values()): + errors.append(f"{test_id}: missing result expectation") + elif test.get("status") != "passed": + errors.append(f"{test_id}: unexpected status {test.get('status')}: {test.get('message', '')}") + return errors + +def annotate_expected_results(consumer, native): + document = json.loads(native.read_text()) + for test in document.get("tests", []): + test.pop("expected", None); test.pop("expected_reason", None) + match = expected_result(test, consumer["expected"]) + if match: + test["expected"], test["expected_reason"] = match + # The original message, trace and status are never replaced. + native.write_text(json.dumps(document, indent=2, sort_keys=True) + "\n", encoding="utf-8") + +def validate_results(consumer, native, allure, test_rc=0): + errors, tests, document = [], [], {} + try: + document = json.loads(native.read_text()) + tests = document["tests"] + require(isinstance(tests, list) and tests, "test suite is empty") + except (OSError, KeyError, json.JSONDecodeError, HarnessError) as error: + errors = [f"invalid results: {error}"] + actual = {} + for test in tests: + test_id = test.get("id") if isinstance(test, dict) else None + if not test_id or test_id in actual: errors.append(f"missing or duplicate test id: {test_id}") + else: actual[test_id] = test + expectations = consumer["expected"]; required = set(expectations["required"]) + if expectations.get("discovered") and not any(key.endswith(".infrastructure") for key in actual): + inventory = document.get("inventory", []) + if not inventory or len(inventory) != len(set(inventory)): + errors.append("missing or duplicate discovered inventory") + reported = {test.get("parent_id", test_id) for test_id, test in actual.items()} if document.get("inventory_kind") == "parents" else set(actual) + if set(inventory) != reported: + errors.append(f"inventory/result mismatch: missing={sorted(set(inventory) - reported)}, " + f"unexpected={sorted(reported - set(inventory))}") + if document.get("inventory_kind") == "parents": + rows = document.get("inventory_rows", {}) + if set(rows) != set(inventory): errors.append("missing data-row inventory") + counts = Counter(test.get("parent_id", test_id) for test_id, test in actual.items()) + for parent, count in rows.items(): + if counts[parent] != count: + errors.append(f"{parent}: expected {count} data rows, reported {counts[parent]}") + infrastructure = [test for test_id, test in actual.items() if test_id.endswith(".infrastructure")] + if expectations.get("discovered") and infrastructure: + for test in infrastructure: + errors.append(f"{test['id']}: {test.get('message', 'infrastructure failure')}") + else: + errors += validate_classified_results(actual, expectations) + if not expectations.get("discovered"): + for test_id in sorted(required - set(actual)): errors.append(f"missing test: {test_id}") + for test_id in sorted(set(actual) - required): errors.append(f"unexpected test: {test_id}") + if test_rc < 0 or test_rc > 1: errors.append(f"test command exited abnormally: {test_rc}") + if test_rc and tests and all(test.get("status") == "passed" for test in tests + if isinstance(test, dict)): + errors.append(f"test command exited {test_rc} although every reported test passed") + if len(list(allure.glob("*-result.json"))) != len(tests): errors.append("Allure/native result count differs") + validation = {"consumer": consumer["id"], "connection_mode": os.environ.get("ODBC_TEST_MODE", "all"), + "ok": not errors, "test_count": len(tests), "errors": errors, + "counts": {name: sum((expected_result(test, expectations) or + ("unexpected_skip" if test.get("status") == "skipped" else test.get("status"),))[0] == name + for test in actual.values()) + for name in ("passed", *EXPECTED_OUTCOMES, "unexpected_skip", "failed", "broken")}} + + (RESULTS / "validation.json").write_text(json.dumps(validation, indent=2, sort_keys=True) + "\n") + for error in errors: print(f"result error: {error}", file=sys.stderr) + return errors +def run_consumer(consumer_id, mode): + os.environ["ODBC_TEST_MODE"] = mode + data = load_registry(); consumer = next((x for x in data["consumers"] if x["id"] == consumer_id), None) + require(consumer, f"unknown consumer: {consumer_id}") + allowed_modes = consumer.get("modes") or ["all"] + require(mode in allowed_modes, f"{consumer_id}: invalid connection mode: {mode}") + adapter, package = ROOT / consumer_id, Path("/packages") / os.environ["ODBC_PACKAGE_BASENAME"] + native, allure, home = RESULTS / "native", RESULTS / "allure", WORK / "home" + for path in (native, allure): + if path.exists(): shutil.rmtree(path) + for path in (RESULTS / "metadata.json", RESULTS / "validation.json"): + path.unlink(missing_ok=True) + for path in (RESULTS, native, allure, WORK, home): + path.mkdir(parents=True, exist_ok=True); path.chmod(0o777) + version, package_hash = inspect_package(package); endpoint, database = os.environ["YDB_ENDPOINT"], os.environ["YDB_DATABASE"] + metadata = { + "consumer": consumer_id, "display_name": consumer["display_name"], + "connection_mode": mode, "run_id": consumer_id if mode == "all" else f"{consumer_id}-{mode}", + "kind": consumer["kind"], "language": consumer["language"], "tier": consumer["tier"], + "runtime_image": os.environ["ODBC_RUNTIME_IMAGE"], "runtime_version": "unknown", + "driver_commit": os.environ["DRIVER_COMMIT"], "package_sha256": package_hash, + "package_version": version, "ydb_image": os.environ["YDB_TEST_IMAGE"], + "endpoint": endpoint, "database": database, + "runtime_packages_sha256": hashlib.sha256(Path("/runtime-packages.txt").read_bytes()).hexdigest() if Path("/runtime-packages.txt").exists() else "unknown", + "source_kind": "system" if consumer["source"] == "system" else "archive", + "upstream_revision": "unknown", "upstream_sha256": "unknown", + "test_sources_sha256": hashlib.sha256((adapter / "test-sources.lock").read_bytes()).hexdigest() if (adapter / "test-sources.lock").exists() else "none", + "fixture_sha256": hashlib.sha256(b"".join(path.read_bytes() for path in sorted(adapter.glob("*.patch")))).hexdigest(), + } + test_rc, error = 0, None + try: + if consumer["kind"] != "package": + metadata["driver_path"] = install_package(package) + revision, source_hash, upstream = prepare_source(consumer) + metadata.update(upstream_revision=revision, upstream_sha256=source_hash) + dsn = write_dsn(consumer_id, endpoint, database) if consumer["kind"] != "package" else "" + env = os.environ.copy(); env.pop("LD_LIBRARY_PATH", None) + env.update({ + "HOME": str(home), "ODBCINI": "/etc/odbc.ini", "YDB_ODBC_DSN": dsn, + "YDB_ODBC_CONNECTION_STRING": + f"Driver={{YDB}};Server={endpoint};Database={database};AuthMode=Anonymous;AnsiSQL=1", + "ODBC_NATIVE_RESULTS_DIR": str(native), "ODBC_UPSTREAM_DIR": str(upstream), + "ODBC_ADAPTER_DIR": str(adapter), "ODBC_HARNESS_DIR": str(ROOT), + "YDB_ENDPOINT": endpoint, "YDB_DATABASE": database, + "ODBC_TEST_MODE": mode, + }) + run_user = None if consumer["kind"] == "package" else "nobody" + runtime_output = command(consumer["runtime_version"], env=env, capture=True, user=run_user).stdout.strip() + metadata["runtime_version"] = runtime_output.splitlines()[0] + (RESULTS / "metadata.json").write_text(json.dumps(metadata, indent=2, sort_keys=True) + "\n") + if consumer.get("runner") == "package-contract": + test_rc = package_suite(package, native) + elif consumer.get("tests"): + test_rc = declarative_suite(consumer, env, native) + else: + test_rc = command([adapter / "run-tests"], env=env, user=run_user, check=False, timeout=1800).returncode + except Exception as exception: # preserve infrastructure failures as test output + error = str(exception) + (RESULTS / "metadata.json").write_text(json.dumps(metadata, indent=2, sort_keys=True) + "\n") + results_file = native / "results.json" + if error or not results_file.exists(): + now = int(time.time() * 1000) + append_result(results_file, infrastructure_test_id(consumer_id, mode), f"{consumer_id} test infrastructure", + "broken", now, now, error or f"test command exited {test_rc} without results") + try: + annotate_expected_results(consumer, results_file) + convert_allure(results_file, allure, metadata) + validation_errors = validate_results(consumer, results_file, allure, test_rc) + except Exception as exception: + print(f"result finalization failed: {exception}", file=sys.stderr); return 1 + return int(bool(error or validation_errors)) +def aggregate(source, output): + expected = {item["run_id"] for item in consumer_runs(load_registry())} + native_out, allure_out = output / "native", output / "allure-results" + native_out.mkdir(parents=True, exist_ok=True); allure_out.mkdir(exist_ok=True) + found, rows, errors, provenance = set(), [], [], None + for metadata_path in source.rglob("metadata.json"): + root = metadata_path.parent + try: + metadata = json.loads(metadata_path.read_text()) + validation = json.loads((root / "validation.json").read_text()) + run_id = metadata["run_id"] + require(run_id in expected, f"unexpected result artifact: {run_id}") + require(run_id not in found, f"duplicate artifact: {run_id}"); found.add(run_id) + results = json.loads((root / "native/results.json").read_text())["tests"] + require(len(results) == validation["test_count"], f"{run_id}: native/validation count differs") + require(len(list((root / "allure").glob("*-result.json"))) == len(results), + f"{run_id}: Allure/native count differs") + identity = tuple(metadata[key] for key in ("driver_commit", "package_sha256", "ydb_image")) + require(all(identity), f"{run_id}: incomplete provenance") + if provenance is None: provenance = identity + require(identity == provenance, f"{run_id}: mismatched artifact provenance") + require(not os.getenv("DRIVER_COMMIT") or identity[0] == os.environ["DRIVER_COMMIT"], + f"{run_id}: wrong driver commit") + require(not os.getenv("ODBC_PACKAGE_SHA256") or identity[1] == os.environ["ODBC_PACKAGE_SHA256"], + f"{run_id}: wrong package checksum") + shutil.copytree(root / "native", native_out / run_id, dirs_exist_ok=True) + for path in (metadata_path, root / "validation.json"): shutil.copy2(path, native_out / run_id / path.name) + for artifact in (root / "allure").iterdir(): + if artifact.name == "environment.properties": continue + target = allure_out / artifact.name + require(not target.exists(), f"duplicate Allure artifact: {artifact.name}") + shutil.copy2(artifact, target) + for path in (root / "allure").glob("*-result.json"): + for attachment in json.loads(path.read_text()).get("attachments", []): + require((allure_out / attachment["source"]).is_file(), f"missing Allure attachment: {attachment['source']}") + counts = validation.get("counts", {}) + rows.append((run_id, validation["test_count"], counts, "passed" if validation.get("ok") else "FAILED")) + if not validation.get("ok"): + errors.append(f"{run_id}: unexpected test outcomes; see native/{run_id}/validation.json") + except (OSError, KeyError, json.JSONDecodeError, HarnessError) as error: + errors.append(f"invalid artifact at {root}: {error}") + if expected - found: errors.append(f"missing result artifacts: {', '.join(sorted(expected - found))}") + lines = ["## ODBC integration results", "", "| Consumer | Tests | Passed | Unsupported | Upstream failures | Expected skips | Unexpected | Status |", + "| --- | ---: | ---: | ---: | ---: | ---: | ---: | --- |"] + lines += [f"| {name} | {count} | {counts.get('passed', 0)} | {counts.get('unsupported', 0)} | " + f"{counts.get('upstream_failure', 0)} | {counts.get('skipped', 0)} | {sum(counts.get(key, 0) for key in ('failed','broken','unexpected_skip'))} | {status} |" for name, count, counts, status in sorted(rows)] + if errors: lines += ["", "### Validation failures", ""] + [f"- {error}" for error in errors] + summary = "\n".join(lines) + "\n"; (output / "summary.md").write_text(summary); print(summary) + return int(bool(errors)) +def main(): + parser = argparse.ArgumentParser(description="YDB ODBC integration harness") + commands = parser.add_subparsers(dest="command", required=True) + registry = commands.add_parser("registry"); registry.add_argument("--registry", type=Path, default=REGISTRY) + registry.add_argument("--matrix", action="store_true"); registry.add_argument("--config", action="store_true") + run = commands.add_parser("run"); run.add_argument("--consumer", required=True) + run.add_argument("--mode", default="all") + launch = commands.add_parser("launch"); launch.add_argument("--consumer", required=True) + launch.add_argument("--mode", default="all") + launch.add_argument("--runtime-image", required=True); launch.add_argument("--package", type=Path, required=True) + launch.add_argument("--results", type=Path, required=True) + aggregation = commands.add_parser("aggregate"); aggregation.add_argument("--input", type=Path, required=True) + aggregation.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + try: + if args.command == "registry": + data = load_registry(args.registry.resolve()) + if args.matrix: + print(json.dumps({"include": [item for item in consumer_runs(data) + if item["mode"] != "all"]}, separators=(",", ":"))) + elif args.config: + package = next(item for item in data["consumers"] if item["kind"] == "package") + print(json.dumps({"ydb": data["ydb"], "package_runtime_image": package["runtime_image"]}, + separators=(",", ":"))) + else: print(f"Validated {len(data['consumers'])} ODBC consumers") + return 0 + if args.command == "run": return run_consumer(args.consumer, args.mode) + if args.command == "launch": return launch_consumer(args.consumer, args.mode, args.runtime_image, args.package, args.results) + return aggregate(args.input, args.output) + except HarnessError as error: + print(f"harness error: {error}", file=sys.stderr) + return 1 +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/odbc/tests/frameworks/isql/Dockerfile b/odbc/tests/frameworks/isql/Dockerfile new file mode 100644 index 00000000000..e437f36b446 --- /dev/null +++ b/odbc/tests/frameworks/isql/Dockerfile @@ -0,0 +1,6 @@ +ARG RUNTIME_IMAGE=ubuntu:24.04@sha256:019e8eb29a85e74d64925745884f2ec79aa27e3feab36353d24656f4d6b89467 +FROM ${RUNTIME_IMAGE} +ENV DEBIAN_FRONTEND=noninteractive +RUN apt-get update \ + && apt-get install -y --no-install-recommends ca-certificates python3 python3-yaml unixodbc \ + && rm -rf /var/lib/apt/lists/* diff --git a/odbc/tests/frameworks/lua/run-tests b/odbc/tests/frameworks/lua/run-tests new file mode 100755 index 00000000000..91ff43b8064 --- /dev/null +++ b/odbc/tests/frameworks/lua/run-tests @@ -0,0 +1,28 @@ +#!/usr/bin/env python3 +import os,sys,re,shutil +from pathlib import Path +sys.path.insert(0,'/harness/bindings') +from adapter import run + +def main(s): + s.command(['make','odbc','LUA_SYS_VER=5.4','CC=gcc -g'], 'build') + module=Path('/work/modules/luasql');module.mkdir(parents=True) + shutil.copyfile(s.source/'src/odbc.so',module/'odbc.so') + env={'LUA_CPATH':'/work/modules/?.so;;'} + cmd=['lua5.4','tests/test.lua','odbc',s.connection] + inventory=s.command(cmd,'inventory',env=env|{'ODBC_DISCOVER_ONLY':'1'}).stdout + names=[line.split('\t',1)[1] for line in inventory.splitlines() if line.startswith('@YDB_INVENTORY\t')] + s.plan(names) + for index,name in enumerate(names): + result=s.command(['gdb','--batch','-ex','run','-ex','bt','--args',*cmd], + f'upstream-{index}',env=env|{'ODBC_TEST_CASE':name},check=False) + if re.search(r'\breceived signal SIG[A-Z0-9]+\b', result.stdout): + s.add(name,'failed',result.stdout,attachments=[s.native/f'upstream-{index}.log']) + continue + for line in result.stdout.splitlines(): + if line.startswith('@YDB_CASE\t'): + _,case,status,diagnostic=line.split('\t',3) + s.add(case,status,bytes.fromhex(diagnostic).decode('utf-8',errors='replace'), + attachments=[s.native/f'upstream-{index}.log']) + +raise SystemExit(run(main)) diff --git a/odbc/tests/frameworks/lua/upstream.lock b/odbc/tests/frameworks/lua/upstream.lock new file mode 100644 index 00000000000..03dcbe99e9d --- /dev/null +++ b/odbc/tests/frameworks/lua/upstream.lock @@ -0,0 +1,6 @@ +kind: archive +url: https://codeload.github.com/lunarmodules/luasql/tar.gz/491fea76b9d9ee613fcd7de6b8a1c902e3668d11 +revision: 491fea76b9d9ee613fcd7de6b8a1c902e3668d11 +sha256: f777c75dec5effeb51c8206fc87c88d6a9c6eca59da148777b2815e825f14b27 +license: MIT +ci_only: true diff --git a/odbc/tests/frameworks/lua/ydb.patch b/odbc/tests/frameworks/lua/ydb.patch new file mode 100644 index 00000000000..d441061fd3c --- /dev/null +++ b/odbc/tests/frameworks/lua/ydb.patch @@ -0,0 +1,85 @@ +--- a/tests/odbc.lua ++++ b/tests/odbc.lua +@@ -12,9 +12,9 @@ + -- Test of data types managed by ODBC driver. + --------------------------------------------------------------------- + table.insert (EXTENSIONS, function () +- assert2 (CREATE_TABLE_RETURN_VALUE, CONN:execute"create table test_dt (f1 integer, f2 varchar(30), f3 bit )") ++ assert2 (CREATE_TABLE_RETURN_VALUE, CONN:execute"CREATE TABLE test_dt (f1 integer, f2 Utf8, f3 Bool, PRIMARY KEY (f1))") + -- Inserts a number, a string value and a "bit" value. +- assert2 (1, CONN:execute("insert into test_dt values (?, ?, ?)", 10, "ABCDE", true)) ++ assert2 (1, CONN:execute("insert into test_dt (f1, f2, f3) VALUES (CAST(? AS Int32), ?, ?)", 10, "ABCDE", true)) + + -- Checks the results with the inserted values. + local stmt = assert(CONN:prepare"select * from test_dt where f1 = ?") +--- a/tests/test.lua ++++ b/tests/test.lua +@@ -5,7 +5,7 @@ + TOTAL_FIELDS = 40 + TOTAL_ROWS = 40 --unused + +-DEFINITION_STRING_TYPE_NAME = "text" ++DEFINITION_STRING_TYPE_NAME = "Utf8" + QUERYING_STRING_TYPE_NAME = "text" + + CREATE_TABLE_RETURN_VALUE = 0 +@@ -166,7 +166,7 @@ + for i = 1, n do + table.insert (t, "f"..i.." "..DEFINITION_STRING_TYPE_NAME) + end +- return "create table t ("..table.concat (t, ',')..")" ++ return "create table t ("..table.concat (t, ',')..", PRIMARY KEY (f1))" + end + + +@@ -622,7 +622,7 @@ + + -- check cursor integrity after trying to close its connection + local conn = CONN_OK (ENV:connect (datasource, username, password)) +- assert2 (1, conn:execute"insert into t (f1) values (1)", "could not insert a new record") ++ assert2 (1, conn:execute"insert into t (f1) values ('1')", "could not insert a new record") + local cur = CUR_OK (conn:execute (cmd)) + local ok, err, msg = pcall (conn.close, conn) + assert2 (true, ok, "couldnΒ΄t try to close the connection") +@@ -670,7 +670,7 @@ + -- file (or in a string). + --------------------------------------------------------------------- + function to_be_closed_support () +- assert (loadfile"to_be_closed_support.lua")() ++ assert (loadfile"tests/to_be_closed_support.lua")() + end + + --------------------------------------------------------------------- +@@ -834,10 +834,32 @@ + end + io.write (" driver test. "..luasql._COPYRIGHT.."\n") + ++for _, t in ipairs(tests) do print("@YDB_INVENTORY\t"..t[1]) end ++if os.getenv("ODBC_DISCOVER_ONLY") == "1" then return end ++local selected = os.getenv("ODBC_TEST_CASE") ++if selected then ++ for _, t in ipairs(tests) do ++ if t[1] == selected then ++ local ok, err = xpcall(function() ++ if t[2] ~= basic_test then basic_test() end ++ if t[2] ~= basic_test and t[2] ~= create_table then create_table() end ++ end, debug.traceback) ++ if not ok then ++ local diagnostic = err:gsub(".", function(c) return string.format("%02x", string.byte(c)) end) ++ print("@YDB_CASE\t"..t[1].."\tbroken\t"..diagnostic) ++ return ++ end ++ tests = {t} ++ break ++ end ++ end ++end + for i = 1, table.getn (tests) do + local t = tests[i] + io.write (t[1].." ...") + local ok, err = xpcall (t[2], debug.traceback) ++ local diagnostic = (err or ""):gsub(".", function(c) return string.format("%02x", string.byte(c)) end) ++ print("\n@YDB_CASE\t"..t[1].."\t"..(ok and "passed" or "failed").."\t"..diagnostic) + if not ok then + io.write ("\n"..err) + io.write"\n... trying to drop test table ..." diff --git a/odbc/tests/frameworks/package-contract/Dockerfile b/odbc/tests/frameworks/package-contract/Dockerfile new file mode 100644 index 00000000000..0dc1869bac1 --- /dev/null +++ b/odbc/tests/frameworks/package-contract/Dockerfile @@ -0,0 +1,6 @@ +ARG RUNTIME_IMAGE=ubuntu:24.04@sha256:019e8eb29a85e74d64925745884f2ec79aa27e3feab36353d24656f4d6b89467 +FROM ${RUNTIME_IMAGE} +ENV DEBIAN_FRONTEND=noninteractive +RUN apt-get update \ + && apt-get install -y --no-install-recommends dpkg-dev odbcinst python3 python3-yaml unixodbc \ + && rm -rf /var/lib/apt/lists/* diff --git a/odbc/tests/frameworks/php-odbc/run-tests b/odbc/tests/frameworks/php-odbc/run-tests new file mode 100755 index 00000000000..90fc24a9f13 --- /dev/null +++ b/odbc/tests/frameworks/php-odbc/run-tests @@ -0,0 +1,6 @@ +#!/usr/bin/env python3 +import sys +sys.path.insert(0, '/harness/bindings') +from adapter import run +from php import main +raise SystemExit(run(main)) diff --git a/odbc/tests/frameworks/php-odbc/upstream.lock b/odbc/tests/frameworks/php-odbc/upstream.lock new file mode 100644 index 00000000000..754ead0b05b --- /dev/null +++ b/odbc/tests/frameworks/php-odbc/upstream.lock @@ -0,0 +1,6 @@ +kind: archive +url: https://codeload.github.com/php/php-src/tar.gz/refs/tags/php-8.3.6 +revision: php-8.3.6 +sha256: af9ca6ea711391eaf74793beeebeb66e8bf7756297d1bc97a293166282a0ba77 +license: PHP-3.01 +ci_only: true diff --git a/odbc/tests/frameworks/php-odbc/ydb.patch b/odbc/tests/frameworks/php-odbc/ydb.patch new file mode 100644 index 00000000000..4f4d7de64f4 --- /dev/null +++ b/odbc/tests/frameworks/php-odbc/ydb.patch @@ -0,0 +1,784 @@ +--- a/ext/odbc/tests/bug44618.phpt ++++ b/ext/odbc/tests/bug44618.phpt +@@ -15,8 +15,8 @@ + include __DIR__ . "/config.inc"; + $conn = odbc_connect($dsn, $user, $pass, SQL_CUR_USE_ODBC); + +-odbc_exec($conn, "CREATE TABLE bug44618(ID INT, real1 REAL, text1 TEXT)"); +-odbc_exec($conn, "INSERT INTO bug44618 VALUES (1, 10.0199995, 'testing 1,2,3')"); ++odbc_exec($conn, "CREATE TABLE bug44618 (ID INT, real1 Float, text1 Utf8, PRIMARY KEY (ID))"); ++odbc_exec($conn, "INSERT INTO bug44618 (ID, real1, text1) VALUES (1, 10.0199995, 'testing 1,2,3')"); + + $result = odbc_exec($conn, "SELECT * FROM bug44618"); + var_dump(odbc_fetch_array($result)); +--- a/ext/odbc/tests/bug47803.phpt ++++ b/ext/odbc/tests/bug47803.phpt +@@ -10,15 +10,15 @@ + include __DIR__ . "/config.inc"; + + $create_table = "CREATE TABLE bug47803( +- [PAR_ID] [int] NOT NULL, +- [PAR_INT] [int] NULL, +- [PAR_CHR] [varchar](500) NULL ++ `PAR_ID` Int32 NOT NULL, ++ `PAR_INT` Int32 NULL, ++ `PAR_CHR` Utf8 NULL, PRIMARY KEY (`PAR_ID`) + )"; + + $inserts = "INSERT INTO bug47803 +- ([PAR_ID] +- ,[PAR_INT] +- ,[PAR_CHR]) ++ (`PAR_ID` ++ ,`PAR_INT` ++ ,`PAR_CHR`) + VALUES + (1,14,''), + (2,30,''), +@@ -53,8 +53,8 @@ + array('id'=>6, 'name'=>'test 6'), + ); + $sql = "UPDATE bug47803 +- SET [PAR_CHR] = ? +- WHERE [PAR_ID] = ?"; ++ SET `PAR_CHR` = ? ++ WHERE `PAR_ID` = ?"; + $result = odbc_prepare($link, $sql); + if (!$result) { + print ('[sql] prep: '.$sql); +@@ -68,7 +68,7 @@ + } + odbc_free_result($result); + +-$sql = "SELECT * FROM bug47803 WHERE [PAR_ID] = ?"; ++$sql = "SELECT PAR_ID, PAR_INT, PAR_CHR FROM bug47803 WHERE `PAR_ID` = ?"; + $result = odbc_prepare($link, $sql); + if (!$result) { + print ('[sql] prep: '.$sql); +--- a/ext/odbc/tests/bug60616.phpt ++++ b/ext/odbc/tests/bug60616.phpt +@@ -6,6 +6,7 @@ + --SKIPIF-- + getMessage() . \PHP_EOL; + } +--- a/ext/odbc/tests/odbc_exec_002.phpt ++++ b/ext/odbc/tests/odbc_exec_002.phpt +@@ -11,8 +11,8 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE exec2 (TEST INT)'); +-odbc_exec($conn, 'INSERT INTO exec2 VALUES (1), (2)'); ++odbc_exec($conn, 'CREATE TABLE exec2 (test INT, PRIMARY KEY (test))'); ++odbc_exec($conn, 'INSERT INTO exec2 (test) VALUES (1), (2)'); + + $res = odbc_exec($conn, 'SELECT * FROM exec2'); + +--- a/ext/odbc/tests/odbc_fetch_array_001.phpt ++++ b/ext/odbc/tests/odbc_fetch_array_001.phpt +@@ -11,8 +11,8 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE fetch_array (foo INT)'); +-odbc_exec($conn, 'INSERT INTO fetch_array VALUES (1), (2)'); ++odbc_exec($conn, 'CREATE TABLE fetch_array (foo INT, PRIMARY KEY (foo))'); ++odbc_exec($conn, 'INSERT INTO fetch_array (foo) VALUES (1), (2)'); + + $res = odbc_exec($conn, 'SELECT * FROM fetch_array'); + +--- a/ext/odbc/tests/odbc_fetch_into_001.phpt ++++ b/ext/odbc/tests/odbc_fetch_into_001.phpt +@@ -11,8 +11,8 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE fetch_into (foo INT)'); +-odbc_exec($conn, 'INSERT INTO fetch_into VALUES (1), (2)'); ++odbc_exec($conn, 'CREATE TABLE fetch_into (foo INT, PRIMARY KEY (foo))'); ++odbc_exec($conn, 'INSERT INTO fetch_into (foo) VALUES (1), (2)'); + + $res = odbc_exec($conn, 'SELECT * FROM fetch_into'); + +--- a/ext/odbc/tests/odbc_fetch_object_001.phpt ++++ b/ext/odbc/tests/odbc_fetch_object_001.phpt +@@ -11,8 +11,8 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE fetch_object (foo INT)'); +-odbc_exec($conn, 'INSERT INTO fetch_object VALUES (1), (2)'); ++odbc_exec($conn, 'CREATE TABLE fetch_object (foo INT, PRIMARY KEY (foo))'); ++odbc_exec($conn, 'INSERT INTO fetch_object (foo) VALUES (1), (2)'); + + $res = odbc_exec($conn, 'SELECT * FROM fetch_object'); + +--- a/ext/odbc/tests/odbc_fetch_row_001.phpt ++++ b/ext/odbc/tests/odbc_fetch_row_001.phpt +@@ -11,9 +11,9 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE fetch_row (test INT)'); ++odbc_exec($conn, 'CREATE TABLE fetch_row (test INT, PRIMARY KEY (test))'); + +-odbc_exec($conn, 'INSERT INTO fetch_row VALUES (1), (2)'); ++odbc_exec($conn, 'INSERT INTO fetch_row (test) VALUES (1), (2)'); + + $res = odbc_exec($conn, 'SELECT * FROM fetch_row'); + +--- a/ext/odbc/tests/odbc_field_len_001.phpt ++++ b/ext/odbc/tests/odbc_field_len_001.phpt +@@ -11,9 +11,9 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE field_len (foo INT, bar TEXT, baz VARBINARY(50))'); ++odbc_exec($conn, 'CREATE TABLE field_len (foo INT, bar Utf8, baz String, PRIMARY KEY (foo))'); + +-$res = odbc_exec($conn, 'SELECT * FROM field_len'); ++$res = odbc_exec($conn, 'SELECT foo, bar, baz FROM field_len'); + try { + odbc_field_len($res, 0); + } catch (ValueError $error) { +--- a/ext/odbc/tests/odbc_field_name_001.phpt ++++ b/ext/odbc/tests/odbc_field_name_001.phpt +@@ -11,9 +11,9 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE field_name (foo INT, bar INT, baz INT)'); ++odbc_exec($conn, 'CREATE TABLE field_name (foo INT, bar INT, baz INT, PRIMARY KEY (foo))'); + +-$res = odbc_exec($conn, 'SELECT * FROM field_name'); ++$res = odbc_exec($conn, 'SELECT foo, bar, baz FROM field_name'); + try { + odbc_field_name($res, 0); + } catch (ValueError $error) { +--- a/ext/odbc/tests/odbc_field_num_001.phpt ++++ b/ext/odbc/tests/odbc_field_num_001.phpt +@@ -11,9 +11,9 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE field_num (foo INT, bar REAL, baz VARBINARY(50))'); ++odbc_exec($conn, 'CREATE TABLE field_num (foo INT, bar Float, baz String, PRIMARY KEY (foo))'); + +-$res = odbc_exec($conn, 'SELECT * FROM field_num'); ++$res = odbc_exec($conn, 'SELECT foo, bar, baz FROM field_num'); + var_dump(odbc_field_num($res, "foo")); + var_dump(odbc_field_num($res, "bar")); + var_dump(odbc_field_num($res, "baz")); +--- a/ext/odbc/tests/odbc_field_precision_001.phpt ++++ b/ext/odbc/tests/odbc_field_precision_001.phpt +@@ -11,9 +11,9 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE field_precision (foo INT, bar REAL, baz VARBINARY(50))'); ++odbc_exec($conn, 'CREATE TABLE field_precision (foo INT, bar Float, baz String, PRIMARY KEY (foo))'); + +-$res = odbc_exec($conn, 'SELECT * FROM field_precision'); ++$res = odbc_exec($conn, 'SELECT foo, bar, baz FROM field_precision'); + try { + odbc_field_precision($res, 0); + } catch (ValueError $error) { +--- a/ext/odbc/tests/odbc_field_scale_001.phpt ++++ b/ext/odbc/tests/odbc_field_scale_001.phpt +@@ -11,9 +11,9 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE field_scale (foo INT, bar REAL, baz VARBINARY(50))'); ++odbc_exec($conn, 'CREATE TABLE field_scale (foo INT, bar Float, baz String, PRIMARY KEY (foo))'); + +-$res = odbc_exec($conn, 'SELECT * FROM field_scale'); ++$res = odbc_exec($conn, 'SELECT foo, bar, baz FROM field_scale'); + try { + odbc_field_scale($res, 0); + } catch (ValueError $error) { +--- a/ext/odbc/tests/odbc_field_type_001.phpt ++++ b/ext/odbc/tests/odbc_field_type_001.phpt +@@ -11,9 +11,9 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE field_type (foo INT, bar TEXT, baz VARBINARY(50))'); ++odbc_exec($conn, 'CREATE TABLE field_type (foo INT, bar Utf8, baz String, PRIMARY KEY (foo))'); + +-$res = odbc_exec($conn, 'SELECT * FROM field_type'); ++$res = odbc_exec($conn, 'SELECT foo, bar, baz FROM field_type'); + try { + odbc_field_type($res, 0); + } catch (ValueError $error) { +@@ -33,9 +33,9 @@ + ?> + --EXPECTF-- + odbc_field_type(): Argument #2 ($field) must be greater than 0 +-string(3) "int" +-string(4) "text" +-string(9) "varbinary" ++string(7) "INTEGER" ++string(7) "VARCHAR" ++string(9) "VARBINARY" + + Warning: odbc_field_type(): Field index larger than number of fields in %s on line %d + bool(false) +--- a/ext/odbc/tests/odbc_free_result_001.phpt ++++ b/ext/odbc/tests/odbc_free_result_001.phpt +@@ -11,9 +11,9 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE free_result (TEST INT NOT NULL)'); ++odbc_exec($conn, 'CREATE TABLE free_result (test INT NOT NULL, PRIMARY KEY (test))'); + +-odbc_exec($conn, 'INSERT INTO free_result VALUES (1), (2)'); ++odbc_exec($conn, 'INSERT INTO free_result (test) VALUES (1), (2)'); + + $res = odbc_exec($conn, 'SELECT * FROM free_result'); + +--- a/ext/odbc/tests/odbc_longreadlen_001.phpt ++++ b/ext/odbc/tests/odbc_longreadlen_001.phpt +@@ -10,8 +10,8 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, "CREATE TABLE longreadlen (id INT, whatever VARBINARY(50))"); +-odbc_exec($conn, "INSERT INTO longreadlen VALUES (1, CONVERT(VARBINARY(50), 'whatever'))"); ++odbc_exec($conn, "CREATE TABLE longreadlen (id INT, whatever String, PRIMARY KEY (id))"); ++odbc_exec($conn, "INSERT INTO longreadlen (id, whatever) VALUES (1, CAST('whatever' AS String))"); + + $res = odbc_exec($conn, "SELECT * FROM longreadlen"); + odbc_longreadlen($res, 4); +--- a/ext/odbc/tests/odbc_num_fields_001.phpt ++++ b/ext/odbc/tests/odbc_num_fields_001.phpt +@@ -11,8 +11,8 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE num_fields (foo INT, bar INT, baz INT)'); +-odbc_exec($conn, 'INSERT INTO num_fields VALUES (1, 2, 3)'); ++odbc_exec($conn, 'CREATE TABLE num_fields (foo INT, bar INT, baz INT, PRIMARY KEY (foo))'); ++odbc_exec($conn, 'INSERT INTO num_fields (foo, bar, baz) VALUES (1, 2, 3)'); + + $res = odbc_exec($conn, 'SELECT * FROM num_fields'); + var_dump(odbc_num_fields($res)); +--- a/ext/odbc/tests/odbc_num_rows_001.phpt ++++ b/ext/odbc/tests/odbc_num_rows_001.phpt +@@ -11,8 +11,8 @@ + + $conn = odbc_connect($dsn, $user, $pass); + +-odbc_exec($conn, 'CREATE TABLE num_rows (test INT)'); +-odbc_exec($conn, 'INSERT INTO num_rows VALUES (1), (2), (3)'); ++odbc_exec($conn, 'CREATE TABLE num_rows (test INT, PRIMARY KEY (test))'); ++odbc_exec($conn, 'INSERT INTO num_rows (test) VALUES (1), (2), (3)'); + + $res = odbc_exec($conn, 'SELECT * FROM num_rows'); + var_dump(odbc_num_rows($res)); +--- a/ext/odbc/tests/odbc_persistent_close.phpt ++++ b/ext/odbc/tests/odbc_persistent_close.phpt +@@ -15,6 +15,7 @@ + // Since CI runs ODBC tests with SQL Server, just use an SQL Server specific way of testing. + $conn = odbc_connect($dsn, $user, $pass); + $result = @odbc_exec($conn, "SELECT @@Version"); ++if (!$result) die("skip MS SQL specific test"); + if ($result) { + $array = odbc_fetch_array($result); + $info = (string) reset($array); +--- a/ext/odbc/tests/odbc_primarykeys_001.phpt ++++ b/ext/odbc/tests/odbc_primarykeys_001.phpt +@@ -8,6 +8,7 @@ + + $conn = odbc_connect($dsn, $user, $pass); + $result = @odbc_exec($conn, "SELECT @@Version"); ++if (!$result) die("skip MS SQL specific test"); + if ($result) { + $array = odbc_fetch_array($result); + $info = (string) reset($array); +@@ -25,7 +26,7 @@ + $conn = odbc_connect($dsn, $user, $pass); + odbc_exec($conn, 'CREATE DATABASE PrimarykeysTest'); + odbc_exec($conn, 'USE PrimarykeysTest'); +-odbc_exec($conn, 'CREATE TABLE primarykeys (test INT NOT NULL)'); ++odbc_exec($conn, 'CREATE TABLE primarykeys (test INT NOT NULL, PRIMARY KEY (test))'); + + $res = odbc_primarykeys($conn, "PrimarykeysTest", "dbo", "primarykeys"); + var_dump(odbc_fetch_array($res)); +--- a/ext/odbc/tests/odbc_rollback_001.phpt ++++ b/ext/odbc/tests/odbc_rollback_001.phpt +@@ -10,10 +10,10 @@ + include 'config.inc'; + + $conn = odbc_connect($dsn, $user, $pass); +-odbc_exec($conn, 'CREATE TABLE rollback_table (test INT)'); ++odbc_exec($conn, 'CREATE TABLE rollback_table (test INT, PRIMARY KEY (test))'); + + odbc_autocommit($conn, false); +-odbc_exec($conn, 'INSERT INTO rollback_table VALUES(1)'); ++odbc_exec($conn, 'INSERT INTO rollback_table (test) VALUES(1)'); + var_dump(odbc_rollback($conn)); + + $res = odbc_exec($conn, 'SELECT * FROM rollback_table'); +--- a/ext/odbc/tests/skipif.inc ++++ b/ext/odbc/tests/skipif.inc +@@ -2,7 +2,7 @@ + + include 'config.inc'; + +-$conn = @odbc_connect($dsn, $user, $pass); ++$conn = odbc_connect($dsn, $user, $pass); + if (!$conn) { + die('skip could not connect'); + } +--- a/ext/odbc/tests/bug46050.phpt ++++ b/ext/odbc/tests/bug46050.phpt +@@ -8,7 +8,7 @@ + ++ + --CONFLICTS-- + odbc + --FILE-- +--- a/ext/odbc/tests/bug80592.phpt ++++ b/ext/odbc/tests/bug80592.phpt +@@ -10,7 +10,7 @@ + + $conn = odbc_connect($dsn, $user, $pass); + odbc_exec($conn,"CREATE TABLE bug80592 (f1 float not null, f2 float not null, f3 float not null, ydb_fixture_id Int32, PRIMARY KEY (ydb_fixture_id))"); +-$stmt = odbc_prepare($conn, "INSERT INTO bug80592 (f1, f2, f3) values (?, ?, ?)"); ++$stmt = odbc_prepare($conn, "INSERT INTO bug80592 (ydb_fixture_id, f1, f2, f3) values (1, ?, ?, ?)"); + odbc_execute($stmt, [1.0, 2.0, 3.0]); + $res = odbc_exec($conn, "SELECT f1, f2, f3 from bug80592"); + var_dump(odbc_fetch_array($res)); +@@ -25,9 +25,9 @@ + --EXPECT-- + array(3) { + ["f1"]=> +- string(3) "1.0" ++ string(1) "1" + ["f2"]=> +- string(3) "2.0" ++ string(1) "2" + ["f3"]=> +- string(3) "3.0" ++ string(1) "3" + } +--- a/ext/odbc/tests/odbc_exec_001.phpt ++++ b/ext/odbc/tests/odbc_exec_001.phpt +@@ -24,6 +24,8 @@ + + ?> + --EXPECTF-- +-Warning: odbc_exec(): SQL error: %s in %s on line %d ++Warning: odbc_exec(): SQL error: %a in %s on line %d + +-Warning: odbc_exec(): SQL error: %s in %s on line %d ++Warning: odbc_exec(): SQL error: %a in %s on line %d ++ ++Warning: odbc_exec(): SQL error: %a in %s on line %d +--- a/ext/odbc/tests/odbc_exec_002.phpt ++++ b/ext/odbc/tests/odbc_exec_002.phpt +@@ -14,7 +14,7 @@ + odbc_exec($conn, 'CREATE TABLE exec2 (test INT, PRIMARY KEY (test))'); + odbc_exec($conn, 'INSERT INTO exec2 (test) VALUES (1), (2)'); + +-$res = odbc_exec($conn, 'SELECT * FROM exec2'); ++$res = odbc_exec($conn, 'SELECT test AS `TEST` FROM exec2 ORDER BY test'); + + var_dump(odbc_fetch_row($res)); + var_dump(odbc_result($res, 'test')); +--- a/ext/odbc/tests/odbc_field_len_001.phpt ++++ b/ext/odbc/tests/odbc_field_len_001.phpt +@@ -35,8 +35,8 @@ + --EXPECTF-- + odbc_field_len(): Argument #2 ($field) must be greater than 0 + int(10) +-int(2147483647) +-int(50) ++int(0) ++int(0) + + Warning: odbc_field_len(): Field index larger than number of fields in %s on line %d + bool(false) +--- a/ext/odbc/tests/odbc_field_precision_001.phpt ++++ b/ext/odbc/tests/odbc_field_precision_001.phpt +@@ -35,7 +35,7 @@ + odbc_field_precision(): Argument #2 ($field) must be greater than 0 + int(10) + int(7) +-int(50) ++int(0) + + Warning: odbc_field_precision(): Field index larger than number of fields in %s on line %d + bool(false) +--- a/ext/odbc/tests/odbc_gettypeinfo_001.phpt ++++ b/ext/odbc/tests/odbc_gettypeinfo_001.phpt +@@ -25,20 +25,20 @@ + + odbc_close($conn); + ?> +---EXPECTF-- +-array(20) { ++--EXPECT-- ++array(19) { + ["TYPE_NAME"]=> +- string(14) "datetimeoffset" ++ string(4) "Bool" + ["DATA_TYPE"]=> +- string(4) "-155" ++ string(2) "-7" + ["COLUMN_SIZE"]=> +- string(2) "34" ++ string(1) "1" + ["LITERAL_PREFIX"]=> +- string(1) "'" ++ NULL + ["LITERAL_SUFFIX"]=> +- string(1) "'" ++ NULL + ["CREATE_PARAMS"]=> +- string(5) "scale" ++ NULL + ["NULLABLE"]=> + string(1) "1" + ["CASE_SENSITIVE"]=> +@@ -50,41 +50,39 @@ + ["FIXED_PREC_SCALE"]=> + string(1) "0" + ["AUTO_UNIQUE_VALUE"]=> ++ string(1) "0" ++ ["LOCAL_TYPE_NAME"]=> ++ string(4) "Bool" ++ ["MINIMUM_SCALE"]=> + NULL +- ["LOCAL_TYPE_NAME"]=> +- string(14) "datetimeoffset" +- ["MINIMUM_SCALE"]=> +- string(1) "0" + ["MAXIMUM_SCALE"]=> +- string(1) "7" ++ NULL + ["SQL_DATA_TYPE"]=> +- string(4) "-155" ++ string(2) "-7" + ["SQL_DATETIME_SUB"]=> +- string(1) "0" ++ NULL + ["NUM_PREC_RADIX"]=> + NULL + ["INTERVAL_PRECISION"]=> + NULL +- ["USERTYPE"]=> +- string(1) "0" + } +-array(20) { ++array(19) { + ["TYPE_NAME"]=> +- string(4) "char" ++ string(4) "Utf8" + ["DATA_TYPE"]=> + string(1) "1" + ["COLUMN_SIZE"]=> +- string(4) "8000" ++ string(1) "0" + ["LITERAL_PREFIX"]=> + string(1) "'" + ["LITERAL_SUFFIX"]=> + string(1) "'" + ["CREATE_PARAMS"]=> +- string(6) "length" ++ NULL + ["NULLABLE"]=> + string(1) "1" + ["CASE_SENSITIVE"]=> +- string(1) "0" ++ string(1) "1" + ["SEARCHABLE"]=> + string(1) "3" + ["UNSIGNED_ATTRIBUTE"]=> +@@ -92,9 +90,9 @@ + ["FIXED_PREC_SCALE"]=> + string(1) "0" + ["AUTO_UNIQUE_VALUE"]=> +- NULL ++ string(1) "0" + ["LOCAL_TYPE_NAME"]=> +- string(4) "char" ++ string(4) "Utf8" + ["MINIMUM_SCALE"]=> + NULL + ["MAXIMUM_SCALE"]=> +@@ -107,16 +105,14 @@ + NULL + ["INTERVAL_PRECISION"]=> + NULL +- ["USERTYPE"]=> +- string(1) "1" + } +-array(20) { ++array(19) { + ["TYPE_NAME"]=> +- string(7) "numeric" ++ string(7) "Decimal" + ["DATA_TYPE"]=> + string(1) "2" + ["COLUMN_SIZE"]=> +- string(2) "38" ++ string(2) "35" + ["LITERAL_PREFIX"]=> + NULL + ["LITERAL_SUFFIX"]=> +@@ -128,7 +124,7 @@ + ["CASE_SENSITIVE"]=> + string(1) "0" + ["SEARCHABLE"]=> +- string(1) "2" ++ string(1) "3" + ["UNSIGNED_ATTRIBUTE"]=> + string(1) "0" + ["FIXED_PREC_SCALE"]=> +@@ -136,11 +132,11 @@ + ["AUTO_UNIQUE_VALUE"]=> + string(1) "0" + ["LOCAL_TYPE_NAME"]=> +- string(7) "numeric" ++ string(7) "Decimal" + ["MINIMUM_SCALE"]=> + string(1) "0" + ["MAXIMUM_SCALE"]=> +- string(2) "38" ++ string(2) "35" + ["SQL_DATA_TYPE"]=> + string(1) "2" + ["SQL_DATETIME_SUB"]=> +@@ -149,6 +145,4 @@ + string(2) "10" + ["INTERVAL_PRECISION"]=> + NULL +- ["USERTYPE"]=> +- string(2) "10" + } +--- a/ext/odbc/tests/odbc_num_rows_001.phpt ++++ b/ext/odbc/tests/odbc_num_rows_001.phpt +@@ -31,5 +31,5 @@ + odbc_exec($conn, 'DROP TABLE num_rows'); + ?> + --EXPECT-- +-int(3) +-int(0) ++int(-1) ++int(-1) diff --git a/odbc/tests/frameworks/php-pdo/run-tests b/odbc/tests/frameworks/php-pdo/run-tests new file mode 100755 index 00000000000..90fc24a9f13 --- /dev/null +++ b/odbc/tests/frameworks/php-pdo/run-tests @@ -0,0 +1,6 @@ +#!/usr/bin/env python3 +import sys +sys.path.insert(0, '/harness/bindings') +from adapter import run +from php import main +raise SystemExit(run(main)) diff --git a/odbc/tests/frameworks/php-pdo/upstream.lock b/odbc/tests/frameworks/php-pdo/upstream.lock new file mode 100644 index 00000000000..754ead0b05b --- /dev/null +++ b/odbc/tests/frameworks/php-pdo/upstream.lock @@ -0,0 +1,6 @@ +kind: archive +url: https://codeload.github.com/php/php-src/tar.gz/refs/tags/php-8.3.6 +revision: php-8.3.6 +sha256: af9ca6ea711391eaf74793beeebeb66e8bf7756297d1bc97a293166282a0ba77 +license: PHP-3.01 +ci_only: true diff --git a/odbc/tests/frameworks/php-pdo/ydb.patch b/odbc/tests/frameworks/php-pdo/ydb.patch new file mode 100644 index 00000000000..1e028b0b2d6 --- /dev/null +++ b/odbc/tests/frameworks/php-pdo/ydb.patch @@ -0,0 +1,1225 @@ +--- a/ext/pdo/tests/bug_34630.phpt ++++ b/ext/pdo/tests/bug_34630.phpt +@@ -19,9 +19,9 @@ + $is_oci = $driver == 'oci'; + + if ($is_oci) { +- $db->exec('CREATE TABLE test (id int NOT NULL PRIMARY KEY, val BLOB)'); ++ $db->exec('CREATE TABLE test (id int NOT NULL, val String, PRIMARY KEY (id))'); + } else { +- $db->exec('CREATE TABLE test (id int NOT NULL PRIMARY KEY, val VARCHAR(256))'); ++ $db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, PRIMARY KEY (id))'); + } + $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); + +--- a/ext/pdo/tests/bug_35671.phpt ++++ b/ext/pdo/tests/bug_35671.phpt +@@ -15,7 +15,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test (field1 VARCHAR(32), field2 VARCHAR(32), field3 VARCHAR(32))'); ++$db->exec('CREATE TABLE test (field1 Utf8, field2 Utf8, field3 Utf8, PRIMARY KEY (field1))'); + $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); + + $insert = $db->prepare("insert into test (field1, field2, field3) values (:value1, :value2, :value3)"); +--- a/ext/pdo/tests/bug_36428.phpt ++++ b/ext/pdo/tests/bug_36428.phpt +@@ -16,7 +16,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + + $db = PDOTest::factory(); +-$db->exec("CREATE TABLE test (a VARCHAR(10))"); ++$db->exec("CREATE TABLE test (a Utf8, PRIMARY KEY (a))"); + $db->exec("INSERT INTO test (a) VALUES ('xyz')"); + $res = $db->query("SELECT a FROM test"); + var_dump($res->fetchAll(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, 'SimpleXMLElement', array(''))); +--- a/ext/pdo/tests/bug_38253.phpt ++++ b/ext/pdo/tests/bug_38253.phpt +@@ -15,7 +15,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $pdo = PDOTest::factory(); + +-$pdo->exec ("create table test (id integer primary key, n varchar(255))"); ++$pdo->exec ("CREATE TABLE test (id integer, n Utf8, PRIMARY KEY (id))"); + $pdo->exec ("INSERT INTO test (id, n) VALUES (1, 'hi')"); + + $pdo->setAttribute (PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_CLASS); +--- a/ext/pdo/tests/bug_38394.phpt ++++ b/ext/pdo/tests/bug_38394.phpt +@@ -16,7 +16,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + + $db = PDOTest::factory(); +-$db->exec("CREATE TABLE test (a INT, b INT, c INT)"); ++$db->exec("CREATE TABLE test (a INT, b INT, c INT, PRIMARY KEY (a))"); + $s = $db->prepare("INSERT INTO test (a,b,c) VALUES (:a,:b,:c)"); + + $s->execute(array('a' => 1, 'b' => 2, 'c' => 3)); +--- a/ext/pdo/tests/bug_39398.phpt ++++ b/ext/pdo/tests/bug_39398.phpt +@@ -15,10 +15,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + + $db = PDOTest::factory(); +-$db->exec("CREATE TABLE test (test INT)"); ++$db->exec("CREATE TABLE test (test INT, PRIMARY KEY (test))"); + + $boolean = 1; +-$stmt = $db->prepare('INSERT INTO test VALUES (:boolean)'); ++$stmt = $db->prepare('INSERT INTO test (test) VALUES (:boolean)'); + $stmt->bindValue(':boolean', isset($boolean), PDO::PARAM_INT); + $stmt->execute(); + +--- a/ext/pdo/tests/bug_39656.phpt ++++ b/ext/pdo/tests/bug_39656.phpt +@@ -19,7 +19,7 @@ + @$db->exec("DROP TABLE test"); + $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); + +-$db->exec("CREATE TABLE test (id INTEGER NOT NULL PRIMARY KEY, usr VARCHAR( 256 ) NOT NULL)"); ++$db->exec("CREATE TABLE test (id INTEGER NOT NULL, usr Utf8 NOT NULL, PRIMARY KEY (id))"); + $db->exec("INSERT INTO test (id, usr) VALUES (1, 'user')"); + + $stmt = $db->prepare("SELECT * FROM test WHERE id = ?"); +--- a/ext/pdo/tests/bug_40285.phpt ++++ b/ext/pdo/tests/bug_40285.phpt +@@ -16,10 +16,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test (field1 VARCHAR(32), field2 VARCHAR(32), field3 VARCHAR(32), field4 INT)'); ++$db->exec('CREATE TABLE test (field1 Utf8, field2 Utf8, field3 Utf8, field4 INT, PRIMARY KEY (field1))'); + + $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, true); +-$s = $db->prepare("INSERT INTO test VALUES( ':id', 'name', 'section', 22)" ); ++$s = $db->prepare("INSERT INTO test (field1, field2, field3, field4) VALUES( ':id', 'name', 'section', 22)" ); + $s->execute(); + + echo "Done\n"; +--- a/ext/pdo/tests/bug_42917.phpt ++++ b/ext/pdo/tests/bug_42917.phpt +@@ -15,7 +15,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec("CREATE TABLE test (a varchar(100), b varchar(100), c varchar(100))"); ++$db->exec("CREATE TABLE test (a Utf8, b Utf8, c Utf8, PRIMARY KEY (a))"); + + for ($i = 0; $i < 5; $i++) { + $db->exec("INSERT INTO test (a,b,c) VALUES('test".$i."','".$i."','".$i."')"); +--- a/ext/pdo/tests/bug_43130.phpt ++++ b/ext/pdo/tests/bug_43130.phpt +@@ -23,7 +23,7 @@ + if ($db->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') + $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 1); + +-$db->exec("CREATE TABLE test (a varchar(100), b varchar(100), c varchar(100))"); ++$db->exec("CREATE TABLE test (a Utf8, b Utf8, c Utf8, PRIMARY KEY (a))"); + + for ($i = 0; $i < 5; $i++) { + $db->exec("INSERT INTO test (a,b,c) VALUES('test".$i."','".$i."','".$i."')"); +--- a/ext/pdo/tests/bug_44173.phpt ++++ b/ext/pdo/tests/bug_44173.phpt +@@ -15,8 +15,8 @@ + require getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec("CREATE TABLE test (x int)"); +-$db->exec("INSERT INTO test VALUES (1)"); ++$db->exec("CREATE TABLE test (x int, PRIMARY KEY (x))"); ++$db->exec("INSERT INTO test (x) VALUES (1)"); + + + // Bug entry [2] -- 1 is PDO::FETCH_LAZY +--- a/ext/pdo/tests/bug_44409.phpt ++++ b/ext/pdo/tests/bug_44409.phpt +@@ -15,7 +15,7 @@ + require getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec("CREATE TABLE test (dat varchar(100))"); ++$db->exec("CREATE TABLE test (dat Utf8, PRIMARY KEY (dat))"); + $db->exec("INSERT INTO test (dat) VALUES ('Data from DB')"); + + class bug44409 implements Serializable +--- a/ext/pdo/tests/bug_50458.phpt ++++ b/ext/pdo/tests/bug_50458.phpt +@@ -15,7 +15,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + + $db = PDOTest::factory(); +-$db->exec("CREATE TABLE test (a VARCHAR(10))"); ++$db->exec("CREATE TABLE test (a Utf8, PRIMARY KEY (a))"); + $db->exec("INSERT INTO test (a) VALUES ('xyz')"); + $res = $db->query("SELECT a FROM test"); + var_dump($res->fetchAll(PDO::FETCH_FUNC, function($a) { return strtoupper($a); })); +--- a/ext/pdo/tests/bug_52098.phpt ++++ b/ext/pdo/tests/bug_52098.phpt +@@ -16,8 +16,8 @@ + $db = PDOTest::factory(); + + @$db->exec("DROP TABLE test"); +-$db->exec("CREATE TABLE test (x int)"); +-$db->exec("INSERT INTO test VALUES (1)"); ++$db->exec("CREATE TABLE test (x int, PRIMARY KEY (x))"); ++$db->exec("INSERT INTO test (x) VALUES (1)"); + + class MyStatement extends PDOStatement + { +--- a/ext/pdo/tests/bug_64172.phpt ++++ b/ext/pdo/tests/bug_64172.phpt +@@ -17,13 +17,13 @@ + $db = PDOTest::factory(); + + @$db->exec("DROP TABLE test"); +-$db->exec("CREATE TABLE test (x int)"); +-$db->exec("INSERT INTO test VALUES (1)"); ++$db->exec("CREATE TABLE test (x int, PRIMARY KEY (x))"); ++$db->exec("INSERT INTO test (x) VALUES (1)"); + + echo "===FAIL===\n"; + $db->query('SELECT * FROM bad_table'); + echo "\n"; +-echo "===TEST===\n"; ++echo "===test===\n"; + var_dump(is_string($db->errorInfo()[0])) . "\n"; + var_dump(is_int($db->errorInfo()[1])) . "\n"; + var_dump(is_string($db->errorInfo()[2])) . "\n"; +@@ -36,12 +36,12 @@ + echo "===FAIL===\n"; + $db->exec("INSERT INTO bad_table VALUES(1)"); + echo "\n"; +-echo "===TEST===\n"; ++echo "===test===\n"; + var_dump(is_string($db->errorInfo()[0])) . "\n"; + var_dump(is_int($db->errorInfo()[1])) . "\n"; + var_dump(is_string($db->errorInfo()[2])) . "\n"; + echo "===GOOD===\n"; +-$db->exec("INSERT INTO test VALUES (2)"); ++$db->exec("INSERT INTO test (x) VALUES (2)"); + var_dump($db->errorInfo()); + + $db->exec("DROP TABLE test"); +--- a/ext/pdo/tests/bug_65946.phpt ++++ b/ext/pdo/tests/bug_65946.phpt +@@ -15,8 +15,8 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, true); +-$db->exec('CREATE TABLE test(id int)'); +-$db->exec('INSERT INTO test VALUES(1)'); ++$db->exec('CREATE TABLE test (id int, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO test (id) VALUES(1)'); + switch ($db->getAttribute(PDO::ATTR_DRIVER_NAME)) { + case 'dblib': + $sql = 'SELECT TOP :limit * FROM test'; +--- a/ext/pdo/tests/bug_71447.phpt ++++ b/ext/pdo/tests/bug_71447.phpt +@@ -18,8 +18,8 @@ + $db->setAttribute (\PDO::ATTR_ERRMODE, \PDO::ERRMODE_WARNING); + $db->setAttribute (\PDO::ATTR_DEFAULT_FETCH_MODE, \PDO::FETCH_NUM); + $db->setAttribute (\PDO::ATTR_EMULATE_PREPARES, false); +-$db->exec('CREATE TABLE test(id int)'); +-$db->exec('INSERT INTO test VALUES(1)'); ++$db->exec('CREATE TABLE test (id int, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO test (id) VALUES(1)'); + + // Comment without quotes or placeholders + $stmt = $db->prepare(" +--- a/ext/pdo/tests/bug_71885.phpt ++++ b/ext/pdo/tests/bug_71885.phpt +@@ -8,7 +8,6 @@ + if (false == $dir) die('skip no driver'); + if (!strncasecmp(getenv('PDOTEST_DSN'), 'pgsql', strlen('pgsql'))) die('skip not relevant for pgsql driver'); + if (!strncasecmp(getenv('PDOTEST_DSN'), 'oci', strlen('oci'))) die('skip not relevant for OCI driver'); +-if (!strncasecmp(getenv('PDOTEST_DSN'), 'odbc', strlen('odbc'))) die('skip inconsistent error message with odbc'); + require_once $dir . 'pdo_test.inc'; + PDOTest::skip(); + ?> +@@ -19,7 +18,7 @@ + $db = PDOTest::factory(); + $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); + +-$db->exec("CREATE TABLE test (a int)"); ++$db->exec("CREATE TABLE test (a int, PRIMARY KEY (a))"); + + $sql = "SELECT * FROM test WHERE a ?? 1"; + +--- a/ext/pdo/tests/bug_73234.phpt ++++ b/ext/pdo/tests/bug_73234.phpt +@@ -25,15 +25,15 @@ + + switch ($db->getAttribute(PDO::ATTR_DRIVER_NAME)) { + case 'dblib': +- $sql = 'CREATE TABLE test(id INT NULL)'; ++ $sql = 'CREATE TABLE test (id INT NULL, PRIMARY KEY (id))'; + break; + default: +- $sql = 'CREATE TABLE test(id INT)'; ++ $sql = 'CREATE TABLE test (id INT, PRIMARY KEY (id))'; + break; + } + $db->exec($sql); + +-$stmt = $db->prepare('INSERT INTO test VALUES(:value)'); ++$stmt = $db->prepare('INSERT INTO test (id) VALUES(:value)'); + + $stmt->bindValue(':value', 0, PDO::PARAM_NULL); + $stmt->execute(); +--- a/ext/pdo/tests/bug_79106.phpt ++++ b/ext/pdo/tests/bug_79106.phpt +@@ -12,7 +12,7 @@ + } catch (PDOException $e) { + die('skip ' . $e->getMessage()); + } +-if (@$db->query('SELECT 1 as "1"') === false) { ++if (@$db->query('SELECT 1 as `1`') === false) { + die('skip driver does not support quoted numeric identifiers'); + } + ?> +@@ -22,7 +22,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$stmt = $db->query('SELECT 0 as "2007", 0 as "2008", 0 as "2020"'); ++$stmt = $db->query('SELECT 0 as `2007`, 0 as `2008`, 0 as `2020`'); + var_dump($stmt->fetchAll()); + ?> + --EXPECT-- +--- a/ext/pdo/tests/bug_79106_collision.phpt ++++ b/ext/pdo/tests/bug_79106_collision.phpt +@@ -12,7 +12,7 @@ + } catch (PDOException $e) { + die('skip ' . $e->getMessage()); + } +-if (@$db->query('SELECT 1 as "1"') === false) { ++if (@$db->query('SELECT 1 as `1`') === false) { + die('skip driver does not support quoted numeric identifiers'); + } + ?> +@@ -22,7 +22,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$stmt = $db->query('SELECT 11111 as "1", 22222 as "2"'); ++$stmt = $db->query('SELECT 11111 as `1`, 22222 as `2`'); + var_dump($stmt->fetchAll()); + ?> + --EXPECT-- +--- a/ext/pdo/tests/gh8626.phpt ++++ b/ext/pdo/tests/gh8626.phpt +@@ -23,9 +23,9 @@ + $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT); + + $db->exec('DROP TABLE test'); +-$db->exec('CREATE TABLE test (x int NOT NULL)'); ++$db->exec('CREATE TABLE test (x int NOT NULL, PRIMARY KEY (x))'); + +-$stmt = $db->prepare('INSERT INTO test VALUES(?)'); ++$stmt = $db->prepare('INSERT INTO test (x) VALUES(?)'); + + // fail + var_dump($stmt->execute([null]), $stmt->errorCode()); +--- a/ext/pdo/tests/pdo_001.phpt ++++ b/ext/pdo/tests/pdo_001.phpt +@@ -15,10 +15,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10))'); +-$db->exec("INSERT INTO test VALUES(1, 'A')"); +-$db->exec("INSERT INTO test VALUES(2, 'B')"); +-$db->exec("INSERT INTO test VALUES(3, 'C')"); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, PRIMARY KEY (id))'); ++$db->exec("INSERT INTO test (id, val) VALUES(1, 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES(2, 'B')"); ++$db->exec("INSERT INTO test (id, val) VALUES(3, 'C')"); + + $stmt = $db->prepare('SELECT * from test'); + $stmt->execute(); +--- a/ext/pdo/tests/pdo_002.phpt ++++ b/ext/pdo/tests/pdo_002.phpt +@@ -15,10 +15,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10))'); +-$db->exec("INSERT INTO test VALUES(1, 'A')"); +-$db->exec("INSERT INTO test VALUES(2, 'B')"); +-$db->exec("INSERT INTO test VALUES(3, 'C')"); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, PRIMARY KEY (id))'); ++$db->exec("INSERT INTO test (id, val) VALUES(1, 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES(2, 'B')"); ++$db->exec("INSERT INTO test (id, val) VALUES(3, 'C')"); + + $stmt = $db->prepare('SELECT * from test'); + $stmt->execute(); +--- a/ext/pdo/tests/pdo_003.phpt ++++ b/ext/pdo/tests/pdo_003.phpt +@@ -15,10 +15,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10))'); +-$db->exec("INSERT INTO test VALUES(1, 'A')"); +-$db->exec("INSERT INTO test VALUES(2, 'B')"); +-$db->exec("INSERT INTO test VALUES(3, 'C')"); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, PRIMARY KEY (id))'); ++$db->exec("INSERT INTO test (id, val) VALUES(1, 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES(2, 'B')"); ++$db->exec("INSERT INTO test (id, val) VALUES(3, 'C')"); + + $stmt = $db->prepare('SELECT * from test'); + $stmt->execute(); +--- a/ext/pdo/tests/pdo_004.phpt ++++ b/ext/pdo/tests/pdo_004.phpt +@@ -15,10 +15,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10))'); +-$db->exec("INSERT INTO test VALUES(1, 'A')"); +-$db->exec("INSERT INTO test VALUES(2, 'B')"); +-$db->exec("INSERT INTO test VALUES(3, 'C')"); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, PRIMARY KEY (id))'); ++$db->exec("INSERT INTO test (id, val) VALUES(1, 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES(2, 'B')"); ++$db->exec("INSERT INTO test (id, val) VALUES(3, 'C')"); + + $stmt = $db->prepare('SELECT * from test'); + $stmt->execute(); +--- a/ext/pdo/tests/pdo_005.phpt ++++ b/ext/pdo/tests/pdo_005.phpt +@@ -15,10 +15,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10), val2 VARCHAR(10))'); +-$db->exec("INSERT INTO test VALUES(1, 'A', 'AA')"); +-$db->exec("INSERT INTO test VALUES(2, 'B', 'BB')"); +-$db->exec("INSERT INTO test VALUES(3, 'C', 'CC')"); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, val2 Utf8, PRIMARY KEY (id))'); ++$db->exec("INSERT INTO test (id, val, val2) VALUES(1, 'A', 'AA')"); ++$db->exec("INSERT INTO test (id, val, val2) VALUES(2, 'B', 'BB')"); ++$db->exec("INSERT INTO test (id, val, val2) VALUES(3, 'C', 'CC')"); + + $stmt = $db->prepare('SELECT id, val, val2 from test'); + +--- a/ext/pdo/tests/pdo_006.phpt ++++ b/ext/pdo/tests/pdo_006.phpt +@@ -15,10 +15,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10))'); +-$db->exec("INSERT INTO test VALUES(1, 'A')"); +-$db->exec("INSERT INTO test VALUES(2, 'A')"); +-$db->exec("INSERT INTO test VALUES(3, 'C')"); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, PRIMARY KEY (id))'); ++$db->exec("INSERT INTO test (id, val) VALUES(1, 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES(2, 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES(3, 'C')"); + + $stmt = $db->prepare('SELECT val, id from test'); + +--- a/ext/pdo/tests/pdo_007.phpt ++++ b/ext/pdo/tests/pdo_007.phpt +@@ -15,10 +15,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id CHAR(1) NOT NULL PRIMARY KEY, val VARCHAR(10))'); +-$db->exec("INSERT INTO test VALUES('A', 'A')"); +-$db->exec("INSERT INTO test VALUES('B', 'A')"); +-$db->exec("INSERT INTO test VALUES('C', 'C')"); ++$db->exec('CREATE TABLE test (id Utf8 NOT NULL, val Utf8, PRIMARY KEY (id))'); ++$db->exec("INSERT INTO test (id, val) VALUES('A', 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES('B', 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES('C', 'C')"); + + $stmt = $db->prepare('SELECT id, val from test'); + +--- a/ext/pdo/tests/pdo_008.phpt ++++ b/ext/pdo/tests/pdo_008.phpt +@@ -15,10 +15,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id CHAR(1) NOT NULL PRIMARY KEY, val VARCHAR(10))'); +-$db->exec("INSERT INTO test VALUES('A', 'A')"); +-$db->exec("INSERT INTO test VALUES('B', 'A')"); +-$db->exec("INSERT INTO test VALUES('C', 'C')"); ++$db->exec('CREATE TABLE test (id Utf8 NOT NULL, val Utf8, PRIMARY KEY (id))'); ++$db->exec("INSERT INTO test (id, val) VALUES('A', 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES('B', 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES('C', 'C')"); + + $stmt = $db->prepare('SELECT val, id from test'); + +--- a/ext/pdo/tests/pdo_009.phpt ++++ b/ext/pdo/tests/pdo_009.phpt +@@ -15,15 +15,15 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE classtypes(id int NOT NULL PRIMARY KEY, name VARCHAR(10) NOT NULL UNIQUE)'); +-$db->exec('INSERT INTO classtypes VALUES(0, \'stdClass\')'); +-$db->exec('INSERT INTO classtypes VALUES(1, \'Test1\')'); +-$db->exec('INSERT INTO classtypes VALUES(2, \'Test2\')'); +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, classtype int, val VARCHAR(10))'); +-$db->exec('INSERT INTO test VALUES(1, 0, \'A\')'); +-$db->exec('INSERT INTO test VALUES(2, 1, \'B\')'); +-$db->exec('INSERT INTO test VALUES(3, 2, \'C\')'); +-$db->exec('INSERT INTO test VALUES(4, 3, \'D\')'); ++$db->exec('CREATE TABLE classtypes (id int NOT NULL, name Utf8 NOT NULL, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO classtypes (id, name) VALUES(0, \'stdClass\')'); ++$db->exec('INSERT INTO classtypes (id, name) VALUES(1, \'Test1\')'); ++$db->exec('INSERT INTO classtypes (id, name) VALUES(2, \'Test2\')'); ++$db->exec('CREATE TABLE test (id int NOT NULL, classtype int, val Utf8, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO test (id, classtype, val) VALUES(1, 0, \'A\')'); ++$db->exec('INSERT INTO test (id, classtype, val) VALUES(2, 1, \'B\')'); ++$db->exec('INSERT INTO test (id, classtype, val) VALUES(3, 2, \'C\')'); ++$db->exec('INSERT INTO test (id, classtype, val) VALUES(4, 3, \'D\')'); + + $stmt = $db->prepare('SELECT classtypes.name, test.id AS id, test.val AS val FROM test LEFT JOIN classtypes ON test.classtype=classtypes.id'); + +--- a/ext/pdo/tests/pdo_010.phpt ++++ b/ext/pdo/tests/pdo_010.phpt +@@ -15,15 +15,15 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE classtypes(id int NOT NULL PRIMARY KEY, name VARCHAR(10) NOT NULL UNIQUE)'); +-$db->exec('INSERT INTO classtypes VALUES(0, \'stdClass\')'); +-$db->exec('INSERT INTO classtypes VALUES(1, \'Test1\')'); +-$db->exec('INSERT INTO classtypes VALUES(2, \'Test2\')'); +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, classtype int, val VARCHAR(10), grp VARCHAR(10))'); +-$db->exec('INSERT INTO test VALUES(1, 0, \'A\', \'Group1\')'); +-$db->exec('INSERT INTO test VALUES(2, 1, \'B\', \'Group1\')'); +-$db->exec('INSERT INTO test VALUES(3, 2, \'C\', \'Group2\')'); +-$db->exec('INSERT INTO test VALUES(4, 3, \'D\', \'Group2\')'); ++$db->exec('CREATE TABLE classtypes (id int NOT NULL, name Utf8 NOT NULL, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO classtypes (id, name) VALUES(0, \'stdClass\')'); ++$db->exec('INSERT INTO classtypes (id, name) VALUES(1, \'Test1\')'); ++$db->exec('INSERT INTO classtypes (id, name) VALUES(2, \'Test2\')'); ++$db->exec('CREATE TABLE test (id int NOT NULL, classtype int, val Utf8, grp Utf8, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO test (id, classtype, val, grp) VALUES(1, 0, \'A\', \'Group1\')'); ++$db->exec('INSERT INTO test (id, classtype, val, grp) VALUES(2, 1, \'B\', \'Group1\')'); ++$db->exec('INSERT INTO test (id, classtype, val, grp) VALUES(3, 2, \'C\', \'Group2\')'); ++$db->exec('INSERT INTO test (id, classtype, val, grp) VALUES(4, 3, \'D\', \'Group2\')'); + + $stmt = $db->prepare('SELECT classtypes.name, test.grp AS grp, test.id AS id, test.val AS val FROM test LEFT JOIN classtypes ON test.classtype=classtypes.id'); + +--- a/ext/pdo/tests/pdo_011.phpt ++++ b/ext/pdo/tests/pdo_011.phpt +@@ -15,11 +15,11 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10), grp VARCHAR(10))'); +-$db->exec('INSERT INTO test VALUES(1, \'A\', \'Group1\')'); +-$db->exec('INSERT INTO test VALUES(2, \'B\', \'Group1\')'); +-$db->exec('INSERT INTO test VALUES(3, \'C\', \'Group2\')'); +-$db->exec('INSERT INTO test VALUES(4, \'D\', \'Group2\')'); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, grp Utf8, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO test (id, val, grp) VALUES(1, \'A\', \'Group1\')'); ++$db->exec('INSERT INTO test (id, val, grp) VALUES(2, \'B\', \'Group1\')'); ++$db->exec('INSERT INTO test (id, val, grp) VALUES(3, \'C\', \'Group2\')'); ++$db->exec('INSERT INTO test (id, val, grp) VALUES(4, \'D\', \'Group2\')'); + + class DerivedStatement extends PDOStatement + { +--- a/ext/pdo/tests/pdo_012.phpt ++++ b/ext/pdo/tests/pdo_012.phpt +@@ -15,9 +15,9 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10), grp VARCHAR(10))'); +-$db->exec('INSERT INTO test VALUES(1, \'A\', \'Group1\')'); +-$db->exec('INSERT INTO test VALUES(2, \'B\', \'Group2\')'); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, grp Utf8, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO test (id, val, grp) VALUES(1, \'A\', \'Group1\')'); ++$db->exec('INSERT INTO test (id, val, grp) VALUES(2, \'B\', \'Group2\')'); + + $SELECT = 'SELECT val, grp FROM test'; + +--- a/ext/pdo/tests/pdo_013.phpt ++++ b/ext/pdo/tests/pdo_013.phpt +@@ -15,9 +15,9 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10), grp VARCHAR(10))'); +-$db->exec('INSERT INTO test VALUES(1, \'A\', \'Group1\')'); +-$db->exec('INSERT INTO test VALUES(2, \'B\', \'Group2\')'); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, grp Utf8, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO test (id, val, grp) VALUES(1, \'A\', \'Group1\')'); ++$db->exec('INSERT INTO test (id, val, grp) VALUES(2, \'B\', \'Group2\')'); + + $SELECT = 'SELECT val, grp FROM test'; + +--- a/ext/pdo/tests/pdo_014.phpt ++++ b/ext/pdo/tests/pdo_014.phpt +@@ -15,9 +15,9 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10), grp VARCHAR(10))'); +-$db->exec('INSERT INTO test VALUES(1, \'A\', \'Group1\')'); +-$db->exec('INSERT INTO test VALUES(2, \'B\', \'Group2\')'); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, grp Utf8, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO test (id, val, grp) VALUES(1, \'A\', \'Group1\')'); ++$db->exec('INSERT INTO test (id, val, grp) VALUES(2, \'B\', \'Group2\')'); + $SELECT = 'SELECT val, grp FROM test'; + + class Test +--- a/ext/pdo/tests/pdo_015.phpt ++++ b/ext/pdo/tests/pdo_015.phpt +@@ -15,9 +15,9 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10), val2 VARCHAR(20))'); +-$db->exec('INSERT INTO test VALUES(1, \'A\', \'A2\')'); +-$db->exec('INSERT INTO test VALUES(2, \'A\', \'B2\')'); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, val2 Utf8, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO test (id, val, val2) VALUES(1, \'A\', \'A2\')'); ++$db->exec('INSERT INTO test (id, val, val2) VALUES(2, \'A\', \'B2\')'); + + $select1 = $db->prepare('SELECT id, val, val2 FROM test'); + $select2 = $db->prepare('SELECT val, val2 FROM test'); +--- a/ext/pdo/tests/pdo_016.phpt ++++ b/ext/pdo/tests/pdo_016.phpt +@@ -20,10 +20,10 @@ + $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true); + } + +-$db->exec('CREATE TABLE test(idx int NOT NULL PRIMARY KEY, txt VARCHAR(20))'); +-$db->exec('INSERT INTO test VALUES(0, \'String0\')'); +-$db->exec('INSERT INTO test VALUES(1, \'String1\')'); +-$db->exec('INSERT INTO test VALUES(2, \'String2\')'); ++$db->exec('CREATE TABLE test (idx int NOT NULL, txt Utf8, PRIMARY KEY (idx))'); ++$db->exec('INSERT INTO test (idx, txt) VALUES(0, \'String0\')'); ++$db->exec('INSERT INTO test (idx, txt) VALUES(1, \'String1\')'); ++$db->exec('INSERT INTO test (idx, txt) VALUES(2, \'String2\')'); + + $stmt1 = $db->prepare('SELECT COUNT(idx) FROM test'); + $stmt2 = $db->prepare('SELECT idx, txt FROM test ORDER by idx'); +--- a/ext/pdo/tests/pdo_016a.phpt ++++ b/ext/pdo/tests/pdo_016a.phpt +@@ -20,10 +20,10 @@ + $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true); + } + +-$db->exec('CREATE TABLE test(idx int NOT NULL PRIMARY KEY, txt VARCHAR(20))'); +-$db->exec('INSERT INTO test VALUES(0, \'String0\')'); +-$db->exec('INSERT INTO test VALUES(1, \'String1\')'); +-$db->exec('INSERT INTO test VALUES(2, \'String2\')'); ++$db->exec('CREATE TABLE test (idx int NOT NULL, txt Utf8, PRIMARY KEY (idx))'); ++$db->exec('INSERT INTO test (idx, txt) VALUES(0, \'String0\')'); ++$db->exec('INSERT INTO test (idx, txt) VALUES(1, \'String1\')'); ++$db->exec('INSERT INTO test (idx, txt) VALUES(2, \'String2\')'); + + $stmt1 = $db->prepare('SELECT COUNT(idx) FROM test'); + $stmt2 = $db->prepare('SELECT idx, txt FROM test ORDER by idx'); +--- a/ext/pdo/tests/pdo_017.phpt ++++ b/ext/pdo/tests/pdo_017.phpt +@@ -36,10 +36,10 @@ + $suf = ''; + } + +-$db->exec('CREATE TABLE test(id INT NOT NULL PRIMARY KEY, val VARCHAR(10))'.$suf); +-$db->exec("INSERT INTO test VALUES(1, 'A')"); +-$db->exec("INSERT INTO test VALUES(2, 'B')"); +-$db->exec("INSERT INTO test VALUES(3, 'C')"); ++$db->exec('CREATE TABLE test (id INT NOT NULL, val Utf8, PRIMARY KEY (id))'.$suf); ++$db->exec("INSERT INTO test (id, val) VALUES(1, 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES(2, 'B')"); ++$db->exec("INSERT INTO test (id, val) VALUES(3, 'C')"); + $delete = $db->prepare('DELETE FROM test'); + + function countRows($action) { +--- a/ext/pdo/tests/pdo_018.phpt ++++ b/ext/pdo/tests/pdo_018.phpt +@@ -67,19 +67,19 @@ + { + } + +-$db->exec('CREATE TABLE classtypes(id int NOT NULL PRIMARY KEY, name VARCHAR(20) NOT NULL UNIQUE)'); +-$db->exec('INSERT INTO classtypes VALUES(0, \'stdClass\')'); +-$db->exec('INSERT INTO classtypes VALUES(1, \'TestBase\')'); +-$db->exec('INSERT INTO classtypes VALUES(2, \'TestDerived\')'); ++$db->exec('CREATE TABLE classtypes (id int NOT NULL, name Utf8 NOT NULL UNIQUE, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO classtypes (id, name) VALUES(0, \'stdClass\')'); ++$db->exec('INSERT INTO classtypes (id, name) VALUES(1, \'TestBase\')'); ++$db->exec('INSERT INTO classtypes (id, name) VALUES(2, \'TestDerived\')'); + + switch ($db->getAttribute(PDO::ATTR_DRIVER_NAME)) { + case 'dblib': + // environment settings can influence how the table is created if specifics are missing + // https://msdn.microsoft.com/en-us/library/ms174979.aspx#Nullability Rules Within a Table Definition +- $sql = 'CREATE TABLE test(id int NOT NULL PRIMARY KEY, classtype int NULL, val VARCHAR(255) NULL)'; ++ $sql = 'CREATE TABLE test (id int NOT NULL, classtype int NULL, val Utf8 NULL, PRIMARY KEY (id))'; + break; + default: +- $sql = 'CREATE TABLE test(id int NOT NULL PRIMARY KEY, classtype int, val VARCHAR(255))'; ++ $sql = 'CREATE TABLE test (id int NOT NULL, classtype int, val Utf8, PRIMARY KEY (id))'; + break; + } + $db->exec($sql); +@@ -116,7 +116,7 @@ + unset($stmt); + + echo "===INSERT===\n"; +-$stmt = $db->prepare('INSERT INTO test VALUES(:id, :classtype, :val)'); ++$stmt = $db->prepare('INSERT INTO test (id, classtype, val) VALUES(:id, :classtype, :val)'); + $stmt->bindParam(':id', $idx); + $stmt->bindParam(':classtype', $ctype); + $stmt->bindParam(':val', $val); +--- a/ext/pdo/tests/pdo_019.phpt ++++ b/ext/pdo/tests/pdo_019.phpt +@@ -15,11 +15,11 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(idx int NOT NULL PRIMARY KEY, txt VARCHAR(20))'); +-$db->exec('INSERT INTO test VALUES(0, \'String0\')'); +-$db->exec('INSERT INTO test VALUES(1, \'String1\')'); +-$db->exec('INSERT INTO test VALUES(2, \'String2\')'); +-$db->exec('INSERT INTO test VALUES(3, \'String3\')'); ++$db->exec('CREATE TABLE test (idx int NOT NULL, txt Utf8, PRIMARY KEY (idx))'); ++$db->exec('INSERT INTO test (idx, txt) VALUES(0, \'String0\')'); ++$db->exec('INSERT INTO test (idx, txt) VALUES(1, \'String1\')'); ++$db->exec('INSERT INTO test (idx, txt) VALUES(2, \'String2\')'); ++$db->exec('INSERT INTO test (idx, txt) VALUES(3, \'String3\')'); + + + var_dump($db->query('SELECT COUNT(*) FROM test')->fetchColumn()); +--- a/ext/pdo/tests/pdo_020.phpt ++++ b/ext/pdo/tests/pdo_020.phpt +@@ -15,10 +15,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id INT NOT NULL PRIMARY KEY, val VARCHAR(10), val2 VARCHAR(16))'); +-$db->exec("INSERT INTO test VALUES(1, 'A', 'A')"); +-$db->exec("INSERT INTO test VALUES(2, 'B', 'B')"); +-$db->exec("INSERT INTO test VALUES(3, 'C', 'C')"); ++$db->exec('CREATE TABLE test (id INT NOT NULL, val Utf8, val2 Utf8, PRIMARY KEY (id))'); ++$db->exec("INSERT INTO test (id, val, val2) VALUES(1, 'A', 'A')"); ++$db->exec("INSERT INTO test (id, val, val2) VALUES(2, 'B', 'B')"); ++$db->exec("INSERT INTO test (id, val, val2) VALUES(3, 'C', 'C')"); + + foreach (array('SELECT id, val FROM test', 'SELECT id, val, val2 FROM test', 'SELECT COUNT(*) FROM test') as $sql) { + +--- a/ext/pdo/tests/pdo_021.phpt ++++ b/ext/pdo/tests/pdo_021.phpt +@@ -19,7 +19,7 @@ + $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true); + } + +-$db->exec('CREATE TABLE test(id INT NOT NULL PRIMARY KEY, val VARCHAR(10), val2 VARCHAR(16))'); ++$db->exec('CREATE TABLE test (id INT NOT NULL, val Utf8, val2 Utf8, PRIMARY KEY (id))'); + + $select = $db->prepare('SELECT COUNT(id) FROM test'); + +@@ -34,7 +34,7 @@ + + + // Insert using question mark placeholders +-$stmt = $db->prepare("INSERT INTO test VALUES(?, ?, ?)"); ++$stmt = $db->prepare("INSERT INTO test (id, val, val2) VALUES(?, ?, ?)"); + foreach ($data as $row) { + $stmt->execute($row); + } +@@ -43,7 +43,7 @@ + echo 'There are ' . $num . " rows in the table.\n"; + + // Insert using named parameters +-$stmt2 = $db->prepare("INSERT INTO test VALUES(:first, :second, :third)"); ++$stmt2 = $db->prepare("INSERT INTO test (id, val, val2) VALUES(:first, :second, :third)"); + foreach ($data as $row) { + $stmt2->execute(array(':first'=>($row[0] + 5), ':second'=>$row[1], + ':third'=>$row[2])); +--- a/ext/pdo/tests/pdo_022.phpt ++++ b/ext/pdo/tests/pdo_022.phpt +@@ -26,7 +26,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id INT NOT NULL PRIMARY KEY, val VARCHAR(10), val2 VARCHAR(16))'); ++$db->exec('CREATE TABLE test (id INT NOT NULL, val Utf8, val2 Utf8, PRIMARY KEY (id))'); + + $data = array( + array('10', 'Abc', 'zxy'), +@@ -38,7 +38,7 @@ + ); + + // Insert using question mark placeholders +-$stmt = $db->prepare("INSERT INTO test VALUES(?, ?, ?)"); ++$stmt = $db->prepare("INSERT INTO test (id, val, val2) VALUES(?, ?, ?)"); + foreach ($data as $row) { + $stmt->execute($row); + } +--- a/ext/pdo/tests/pdo_023.phpt ++++ b/ext/pdo/tests/pdo_023.phpt +@@ -63,9 +63,9 @@ + $db->test(); + var_dump($db); + +-$db->query('CREATE TABLE test(id INT NOT NULL PRIMARY KEY, val VARCHAR(10))'); +-$db->query('INSERT INTO test VALUES(0, \'A\')'); +-$db->query('INSERT INTO test VALUES(1, \'B\')'); ++$db->query('CREATE TABLE test (id INT NOT NULL, val Utf8, PRIMARY KEY (id))'); ++$db->query('INSERT INTO test (id, val) VALUES(0, \'A\')'); ++$db->query('INSERT INTO test (id, val) VALUES(1, \'B\')'); + + + $stmt = $db->query('SELECT val, id FROM test'); +--- a/ext/pdo/tests/pdo_024.phpt ++++ b/ext/pdo/tests/pdo_024.phpt +@@ -19,10 +19,10 @@ + case 'dblib': + // environment settings can influence how the table is created if specifics are missing + // https://msdn.microsoft.com/en-us/library/ms174979.aspx#Nullability Rules Within a Table Definition +- $sql = 'create table test (id int, name varchar(10) null)'; ++ $sql = 'CREATE TABLE test (id int, name Utf8 null, PRIMARY KEY (id))'; + break; + default: +- $sql = 'create table test (id int, name varchar(10))'; ++ $sql = 'CREATE TABLE test (id int, name Utf8, PRIMARY KEY (id))'; + break; + } + $db->exec($sql); +--- a/ext/pdo/tests/pdo_025.phpt ++++ b/ext/pdo/tests/pdo_025.phpt +@@ -15,7 +15,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id INT NOT NULL PRIMARY KEY, val VARCHAR(10), val2 VARCHAR(16))'); ++$db->exec('CREATE TABLE test (id INT NOT NULL, val Utf8, val2 Utf8, PRIMARY KEY (id))'); + + $data = array( + array('10', 'Abc', 'zxy'), +@@ -28,7 +28,7 @@ + + + // Insert using question mark placeholders +-$stmt = $db->prepare("INSERT INTO test VALUES(?, ?, ?)"); ++$stmt = $db->prepare("INSERT INTO test (id, val, val2) VALUES(?, ?, ?)"); + foreach ($data as $row) { + $stmt->execute($row); + } +--- a/ext/pdo/tests/pdo_026.phpt ++++ b/ext/pdo/tests/pdo_026.phpt +@@ -56,9 +56,9 @@ + $db = PDOTest::factory('PDODatabase'); + var_dump(get_class($db)); + +-$db->exec('CREATE TABLE test(id INT NOT NULL PRIMARY KEY, val VARCHAR(10), val2 VARCHAR(16))'); ++$db->exec('CREATE TABLE test (id INT NOT NULL, val Utf8, val2 Utf8, PRIMARY KEY (id))'); + +-$stmt = $db->prepare("INSERT INTO test VALUES(?, ?, ?)"); ++$stmt = $db->prepare("INSERT INTO test (id, val, val2) VALUES(?, ?, ?)"); + var_dump(get_class($stmt)); + foreach ($data as $row) { + $stmt->execute($row); +--- a/ext/pdo/tests/pdo_027.phpt ++++ b/ext/pdo/tests/pdo_027.phpt +@@ -15,7 +15,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('create table test (id int, name varchar(10))'); ++$db->exec('CREATE TABLE test (id int, name Utf8, PRIMARY KEY (id))'); + $db->exec("INSERT INTO test (id,name) VALUES(1,'test1')"); + $db->exec("INSERT INTO test (id,name) VALUES(2,'test2')"); + +--- a/ext/pdo/tests/pdo_028.phpt ++++ b/ext/pdo/tests/pdo_028.phpt +@@ -15,8 +15,8 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val1 VARCHAR(10), val2 VARCHAR(10), val3 VARCHAR(10))'); +-$stmt = $db->prepare('INSERT INTO test values (1, ?, ?, ?)'); ++$db->exec('CREATE TABLE test (id int NOT NULL, val1 Utf8, val2 Utf8, val3 Utf8, PRIMARY KEY (id))'); ++$stmt = $db->prepare('INSERT INTO test (id, val1, val2, val3) VALUES (1, ?, ?, ?)'); + + $data = array("one", "two", "three"); + +--- a/ext/pdo/tests/pdo_029.phpt ++++ b/ext/pdo/tests/pdo_029.phpt +@@ -62,9 +62,9 @@ + $db = PDOTest::factory('PDODatabase'); + var_dump(get_class($db)); + +-$db->exec('CREATE TABLE test(id INT NOT NULL PRIMARY KEY, val VARCHAR(10), val2 VARCHAR(16))'); ++$db->exec('CREATE TABLE test (id INT NOT NULL, val Utf8, val2 Utf8, PRIMARY KEY (id))'); + +-$stmt = $db->prepare("INSERT INTO test VALUES(?, ?, ?)"); ++$stmt = $db->prepare("INSERT INTO test (id, val, val2) VALUES(?, ?, ?)"); + var_dump(get_class($stmt)); + foreach ($data as $row) { + $stmt->execute($row); +--- a/ext/pdo/tests/pdo_030.phpt ++++ b/ext/pdo/tests/pdo_030.phpt +@@ -60,9 +60,9 @@ + $db = PDOTest::factory('PDODatabase'); + var_dump(get_class($db)); + +-$db->exec('CREATE TABLE test(id INT NOT NULL PRIMARY KEY, val VARCHAR(10), val2 VARCHAR(16))'); ++$db->exec('CREATE TABLE test (id INT NOT NULL, val Utf8, val2 Utf8, PRIMARY KEY (id))'); + +-$stmt = $db->prepare("INSERT INTO test VALUES(?, ?, ?)"); ++$stmt = $db->prepare("INSERT INTO test (id, val, val2) VALUES(?, ?, ?)"); + var_dump(get_class($stmt)); + foreach ($data as $row) { + $stmt->execute($row); +--- a/ext/pdo/tests/pdo_031.phpt ++++ b/ext/pdo/tests/pdo_031.phpt +@@ -22,9 +22,9 @@ + + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id INT NOT NULL PRIMARY KEY, val VARCHAR(10), val2 VARCHAR(16))'); ++$db->exec('CREATE TABLE test (id INT NOT NULL, val Utf8, val2 Utf8, PRIMARY KEY (id))'); + +-$stmt = $db->prepare("INSERT INTO test VALUES(?, ?, ?)"); ++$stmt = $db->prepare("INSERT INTO test (id, val, val2) VALUES(?, ?, ?)"); + foreach ($data as $row) { + $stmt->execute($row); + } +--- a/ext/pdo/tests/pdo_032.phpt ++++ b/ext/pdo/tests/pdo_032.phpt +@@ -15,10 +15,10 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, val VARCHAR(10))'); +-$db->exec("INSERT INTO test VALUES(1, 'A')"); +-$db->exec("INSERT INTO test VALUES(2, 'B')"); +-$db->exec("INSERT INTO test VALUES(3, 'C')"); ++$db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, PRIMARY KEY (id))'); ++$db->exec("INSERT INTO test (id, val) VALUES(1, 'A')"); ++$db->exec("INSERT INTO test (id, val) VALUES(2, 'B')"); ++$db->exec("INSERT INTO test (id, val) VALUES(3, 'C')"); + + // Lower case columns + $db->setAttribute(PDO::ATTR_CASE, PDO::CASE_LOWER); +--- a/ext/pdo/tests/pdo_033.phpt ++++ b/ext/pdo/tests/pdo_033.phpt +@@ -24,7 +24,7 @@ + + @$db->exec("DROP TABLE test"); + +-$db->query("CREATE TABLE test (t char($len))"); ++$db->query("CREATE TABLE test (t char($len), PRIMARY KEY (t))"); + $db->query("INSERT INTO test (t) VALUES($quoted)"); + + $stmt = $db->prepare('SELECT * from test'); +--- a/ext/pdo/tests/pdo_034.phpt ++++ b/ext/pdo/tests/pdo_034.phpt +@@ -15,7 +15,7 @@ + require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc'; + $db = PDOTest::factory(); + +-$db->exec("CREATE TABLE test (a varchar(100), b varchar(100), c varchar(100))"); ++$db->exec("CREATE TABLE test (a Utf8, b Utf8, c Utf8, PRIMARY KEY (a))"); + + for ($i = 0; $i < 5; $i++) { + $db->exec("INSERT INTO test (a,b,c) VALUES('test".$i."','".$i."','".$i."')"); +--- a/ext/pdo/tests/pdo_035.phpt ++++ b/ext/pdo/tests/pdo_035.phpt +@@ -16,8 +16,8 @@ + $db = PDOTest::factory(); + + const TABLE_NAME = 'test_pdo_35_pdo_row'; +-$db->exec('CREATE TABLE ' . TABLE_NAME .' (id int, name varchar(10))'); +-$db->exec('INSERT INTO ' . TABLE_NAME .' VALUES (23, \'0\')'); ++$db->exec('CREATE TABLE ' . TABLE_NAME .' (id int, name Utf8, PRIMARY KEY (id))'); ++$db->exec('INSERT INTO ' . TABLE_NAME .' (id, name) VALUES (23, \'0\')'); + + $stmt = $db->prepare('SELECT id, name FROM ' . TABLE_NAME); + $stmt->execute(); +--- a/ext/pdo/tests/pecl_bug_5217.phpt ++++ b/ext/pdo/tests/pecl_bug_5217.phpt +@@ -18,7 +18,7 @@ + $ser = serialize($db); + debug_zval_dump($ser); + $db = unserialize($ser); +- $db->exec('CREATE TABLE test (id int NOT NULL PRIMARY KEY, val VARCHAR(10))'); ++ $db->exec('CREATE TABLE test (id int NOT NULL, val Utf8, PRIMARY KEY (id))'); + } catch (Exception $e) { + echo "Safely caught " . $e->getMessage() . "\n"; + } +--- a/ext/pdo_odbc/tests/autocommit.phpt ++++ b/ext/pdo_odbc/tests/autocommit.phpt +@@ -16,7 +16,7 @@ + $table = 'autocommit_pdo_odbc'; + + $db = PDOTest::test_factory(dirname(__FILE__) . '/common.phpt'); +-$db->exec("CREATE TABLE {$table} (id INT, name VARCHAR(255))"); ++$db->exec("CREATE TABLE {$table} (id INT, name Utf8, PRIMARY KEY (id))"); + unset($db); + + $db = new PDO(getenv('PDOTEST_DSN'), getenv('PDOTEST_USER'), getenv('PDOTEST_PASS'), [ +--- a/ext/pdo_odbc/tests/bug80783.phpt ++++ b/ext/pdo_odbc/tests/bug80783.phpt +@@ -11,10 +11,10 @@ + exec("CREATE TABLE bug80783 (name IMAGE)"); ++$db->exec("CREATE TABLE bug80783 (name String, PRIMARY KEY (name))"); + + $string = str_repeat("0123456789", 50); +-$db->exec("INSERT INTO bug80783 VALUES('$string')"); ++$db->exec("INSERT INTO bug80783 (name) VALUES('$string')"); + + $stmt = $db->prepare("SELECT name FROM bug80783"); + $stmt->bindColumn(1, $data, PDO::PARAM_LOB); +--- a/ext/pdo_odbc/tests/bug80783a.phpt ++++ b/ext/pdo_odbc/tests/bug80783a.phpt +@@ -8,18 +8,15 @@ + require 'ext/pdo/tests/pdo_test.inc'; + PDOTest::skip(); + +-if (PDO_ODBC_TYPE === "unixODBC") { +- die("skip Fails with unixODBC"); +-} + ?> + --FILE-- + exec("CREATE TABLE bug80783a (name NVARCHAR(MAX))"); ++$db->exec("CREATE TABLE bug80783a (name Utf8, PRIMARY KEY (name))"); + + $string = str_repeat("0123456789", 50); +-$db->exec("INSERT INTO bug80783a VALUES('$string')"); ++$db->exec("INSERT INTO bug80783a (name) VALUES('$string')"); + + $stmt = $db->prepare("SELECT name FROM bug80783a"); + $stmt->setAttribute(PDO::ODBC_ATTR_ASSUME_UTF8, true); +--- a/ext/pdo_odbc/tests/gh9372.phpt ++++ b/ext/pdo_odbc/tests/gh9372.phpt +@@ -17,8 +17,8 @@ + $db = PDOTest::test_factory(dirname(__FILE__) . '/common.phpt'); + $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); + +-$db->exec("CREATE TABLE gh9372 (col VARCHAR(10))"); +-$db->exec("INSERT INTO gh9372 VALUES ('something')"); ++$db->exec("CREATE TABLE gh9372 (col Utf8, PRIMARY KEY (col))"); ++$db->exec("INSERT INTO gh9372 (col) VALUES ('something')"); + + $stmt = $db->prepare("SELECT * FROM gh9372 WHERE col = ?"); + $stmt->bindValue(1, 'something else'); +--- a/ext/pdo_odbc/tests/long_columns.phpt ++++ b/ext/pdo_odbc/tests/long_columns.phpt +@@ -46,9 +46,9 @@ + $db = PDOTest::test_factory('ext/pdo_odbc/tests/common.phpt'); + $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT); + +-if (false === $db->exec('CREATE TABLE TEST (id INT NOT NULL PRIMARY KEY, data CLOB)')) { +- if (false === $db->exec('CREATE TABLE TEST (id INT NOT NULL PRIMARY KEY, data longtext)')) { +- if (false === $db->exec('CREATE TABLE TEST (id INT NOT NULL PRIMARY KEY, data varchar(4000))')) { ++if (false === $db->exec('CREATE TABLE test (id INT NOT NULL, data Utf8, PRIMARY KEY (id))')) { ++ if (false === $db->exec('CREATE TABLE test (id INT NOT NULL, data Utf8, PRIMARY KEY (id))')) { ++ if (false === $db->exec('CREATE TABLE test (id INT NOT NULL, data Utf8, PRIMARY KEY (id))')) { + die("BORK: don't know how to create a long column here:\n" . implode(", ", $db->errorInfo())); + } + } +@@ -74,11 +74,11 @@ + // this test does - nice to be able to test using MS SQL server + foreach ($sizes as $num) { + $text = alpha_repeat($num); +- $db->exec("INSERT INTO TEST VALUES($num, '$text')"); ++ $db->exec("INSERT INTO test (id, data) VALUES($num, '$text')"); + } + + // verify data +-foreach ($db->query('SELECT id, data from TEST ORDER BY LEN(data) ASC') as $row) { ++foreach ($db->query('SELECT id, data from test ORDER BY id ASC') as $row) { + $expect = alpha_repeat($row[0]); + if (strcmp($expect, $row[1])) { + echo "Failed on size $row[id]:\n"; +--- a/ext/pdo_odbc/tests/max_columns.phpt ++++ b/ext/pdo_odbc/tests/max_columns.phpt +@@ -13,9 +13,9 @@ + $db = PDOTest::test_factory('ext/pdo_odbc/tests/common.phpt'); + $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT); + +-if (false === $db->exec('CREATE TABLE TEST (id INT NOT NULL PRIMARY KEY, data varchar(max))')) { +- if (false === $db->exec('CREATE TABLE TEST (id INT NOT NULL PRIMARY KEY, data longtext)')) { +- if (false === $db->exec('CREATE TABLE TEST (id INT NOT NULL PRIMARY KEY, data CLOB)')) { ++if (false === $db->exec('CREATE TABLE test (id INT NOT NULL, data Utf8, PRIMARY KEY (id))')) { ++ if (false === $db->exec('CREATE TABLE test (id INT NOT NULL, data longtext, PRIMARY KEY (id))')) { ++ if (false === $db->exec('CREATE TABLE test (id INT NOT NULL, data CLOB, PRIMARY KEY (id))')) { + die("BORK: don't know how to create a long column here:\n" . implode(", ", $db->errorInfo())); + } + } +@@ -26,14 +26,14 @@ + $sizes = array(32, 64, 128, 253, 254, 255, 256, 257, 258, 512, 1024, 2048, 3998, 3999, 4000); + + $db->beginTransaction(); +-$insert = $db->prepare('INSERT INTO TEST VALUES (?, ?)'); ++$insert = $db->prepare('INSERT INTO test (id, data) VALUES (?, ?)'); + foreach ($sizes as $num) { + $insert->execute(array($num, str_repeat('i', $num))); + } + $insert = null; + $db->commit(); + +-foreach ($db->query('SELECT id, data from TEST') as $row) { ++foreach ($db->query('SELECT id, data from test') as $row) { + $expect = str_repeat('i', $row[0]); + if (strcmp($expect, $row[1])) { + echo "Failed on size $row[id]:\n"; +--- a/ext/pdo/tests/bug_44861.phpt ++++ b/ext/pdo/tests/bug_44861.phpt +@@ -6,7 +6,7 @@ + PDO::CURSOR_SCROLL); + + $res = $db->prepare($query, $aParams); +--- a/ext/pdo/tests/bug_64172.phpt ++++ b/ext/pdo/tests/bug_64172.phpt +@@ -23,7 +23,7 @@ + echo "===FAIL===\n"; + $db->query('SELECT * FROM bad_table'); + echo "\n"; +-echo "===test===\n"; ++echo "===TEST===\n"; + var_dump(is_string($db->errorInfo()[0])) . "\n"; + var_dump(is_int($db->errorInfo()[1])) . "\n"; + var_dump(is_string($db->errorInfo()[2])) . "\n"; +@@ -34,9 +34,9 @@ + var_dump($db->errorInfo()); + + echo "===FAIL===\n"; +-$db->exec("INSERT INTO bad_table VALUES(1)"); ++$db->exec("INSERT INTO bad_table (x) VALUES(1)"); + echo "\n"; +-echo "===test===\n"; ++echo "===TEST===\n"; + var_dump(is_string($db->errorInfo()[0])) . "\n"; + var_dump(is_int($db->errorInfo()[1])) . "\n"; + var_dump(is_string($db->errorInfo()[2])) . "\n"; +--- a/ext/pdo/tests/bug_65946.phpt ++++ b/ext/pdo/tests/bug_65946.phpt +@@ -22,7 +22,7 @@ + $sql = 'SELECT TOP :limit * FROM test'; + break; + case 'odbc': +- $sql = 'SELECT TOP (:limit) * FROM test'; ++ $sql = 'SELECT * FROM test LIMIT :limit'; + break; + case 'firebird': + $sql = 'SELECT FIRST :limit * FROM test'; +--- a/ext/pdo/tests/bug_73234.phpt ++++ b/ext/pdo/tests/bug_73234.phpt +@@ -28,20 +28,22 @@ + $sql = 'CREATE TABLE test (id INT NULL, PRIMARY KEY (id))'; + break; + default: +- $sql = 'CREATE TABLE test (id INT, PRIMARY KEY (id))'; ++ $sql = 'CREATE TABLE test (id INT, fixture_key Int32, PRIMARY KEY (fixture_key))'; + break; + } + $db->exec($sql); + +-$stmt = $db->prepare('INSERT INTO test (id) VALUES(:value)'); ++$stmt = $db->prepare('INSERT INTO test (fixture_key, id) VALUES(:key, :value)'); + ++$stmt->bindValue(':key', 1, PDO::PARAM_INT); + $stmt->bindValue(':value', 0, PDO::PARAM_NULL); + $stmt->execute(); + ++$stmt->bindValue(':key', 2, PDO::PARAM_INT); + $stmt->bindValue(':value', null, PDO::PARAM_NULL); + $stmt->execute(); + +-$stmt = $db->query('SELECT * FROM test'); ++$stmt = $db->query('SELECT id FROM test ORDER BY fixture_key'); + var_dump($stmt->fetchAll(PDO::FETCH_ASSOC)); + ?> + --EXPECT-- +--- a/ext/pdo/tests/gh8626.phpt ++++ b/ext/pdo/tests/gh8626.phpt +@@ -49,7 +49,7 @@ + [1]=> + int(%i) + [2]=> +- string(%d) "%s%w%S" ++ string(%d) "%a" + } + bool(true) + string(5) "00000" +--- a/ext/pdo/tests/pdo_018.phpt ++++ b/ext/pdo/tests/pdo_018.phpt +@@ -67,7 +67,7 @@ + { + } + +-$db->exec('CREATE TABLE classtypes (id int NOT NULL, name Utf8 NOT NULL UNIQUE, PRIMARY KEY (id))'); ++$db->exec('CREATE TABLE classtypes (id int NOT NULL, name Utf8 NOT NULL, INDEX by_name GLOBAL UNIQUE ON (name), PRIMARY KEY (id))'); + $db->exec('INSERT INTO classtypes (id, name) VALUES(0, \'stdClass\')'); + $db->exec('INSERT INTO classtypes (id, name) VALUES(1, \'TestBase\')'); + $db->exec('INSERT INTO classtypes (id, name) VALUES(2, \'TestDerived\')'); +@@ -160,7 +160,7 @@ + echo "===FAILURE===\n"; + try + { +- $db->query('SELECT classtypes.name AS name, test.val AS val FROM test LEFT JOIN classtypes ON test.classtype=classtypes.id')->fetchAll(PDO::FETCH_CLASS|PDO::FETCH_CLASSTYPE|PDO::FETCH_SERIALIZE, 'TestLeaf', array()); ++ $db->query('SELECT classtypes.name AS name, test.val AS val FROM test LEFT JOIN classtypes ON test.classtype=classtypes.id ORDER BY test.id')->fetchAll(PDO::FETCH_CLASS|PDO::FETCH_CLASSTYPE|PDO::FETCH_SERIALIZE, 'TestLeaf', array()); + } + catch (PDOException $e) + { +@@ -172,7 +172,7 @@ + var_dump($db->query('SELECT COUNT(*) FROM test LEFT JOIN classtypes ON test.classtype=classtypes.id WHERE (classtypes.id IS NULL OR classtypes.id > 0)')->fetchColumn()); + + echo "===DATABASE===\n"; +-$stmt = $db->prepare('SELECT classtypes.name AS name, test.val AS val FROM test LEFT JOIN classtypes ON test.classtype=classtypes.id WHERE (classtypes.id IS NULL OR classtypes.id > 0)'); ++$stmt = $db->prepare('SELECT classtypes.name AS name, test.val AS val FROM test LEFT JOIN classtypes ON test.classtype=classtypes.id WHERE (classtypes.id IS NULL OR classtypes.id > 0) ORDER BY test.id'); + + $stmt->execute(); + var_dump($stmt->fetchAll(PDO::FETCH_ASSOC)); +--- a/ext/pdo/tests/pdo_034.phpt ++++ b/ext/pdo/tests/pdo_034.phpt +@@ -24,7 +24,7 @@ + var_dump($db->query("SELECT a,b FROM test")->fetch(PDO::FETCH_KEY_PAIR)); + var_dump($db->query("SELECT a,b FROM test")->fetchAll(PDO::FETCH_KEY_PAIR)); + var_dump($db->query("SELECT * FROM test")->fetch(PDO::FETCH_KEY_PAIR)); +-var_dump($db->query("SELECT a,a FROM test")->fetchAll(PDO::FETCH_KEY_PAIR)); ++var_dump($db->query("SELECT a,a AS a_copy FROM test ORDER BY a")->fetchAll(PDO::FETCH_KEY_PAIR)); + + ?> + --EXPECTF-- +--- a/ext/pdo_odbc/tests/bug44643.phpt ++++ b/ext/pdo_odbc/tests/bug44643.phpt +@@ -11,7 +11,7 @@ + prepare($sql); + $id1 = 1; + $stmt->bindParam(':id1', $id1, PDO::PARAM_INT); diff --git a/odbc/tests/frameworks/qt/CMakeLists.txt b/odbc/tests/frameworks/qt/CMakeLists.txt new file mode 100644 index 00000000000..c11d79581c6 --- /dev/null +++ b/odbc/tests/frameworks/qt/CMakeLists.txt @@ -0,0 +1,19 @@ +cmake_minimum_required(VERSION 3.16) +project(ydb_qt_sql_upstream_tests LANGUAGES CXX) +set(CMAKE_AUTOMOC ON) +set(CMAKE_CXX_STANDARD 17) +find_package(Qt6 REQUIRED COMPONENTS Core Gui Sql Test Widgets) +set(SQL ${QT_SQL_SOURCE}) +set(KERNEL qsql qsqldatabase qsqldriver qsqlquery qsqlthread) +set(MODELS qsqlquerymodel qsqlrelationaldelegate qsqlrelationaltablemodel qsqltablemodel) +foreach(TEST IN LISTS KERNEL MODELS) + if("${TEST}" IN_LIST KERNEL) + set(GROUP kernel) + else() + set(GROUP models) + endif() + add_executable(tst_${TEST} ${SQL}/${GROUP}/${TEST}/tst_${TEST}.cpp) + target_link_libraries(tst_${TEST} PRIVATE Qt6::CorePrivate Qt6::Sql Qt6::SqlPrivate Qt6::Test) +endforeach() +target_link_libraries(tst_qsqlquerymodel PRIVATE Qt6::Gui Qt6::Widgets) +target_link_libraries(tst_qsqlrelationaldelegate PRIVATE Qt6::Widgets) diff --git a/odbc/tests/frameworks/qt/Dockerfile b/odbc/tests/frameworks/qt/Dockerfile new file mode 100644 index 00000000000..125b11932e9 --- /dev/null +++ b/odbc/tests/frameworks/qt/Dockerfile @@ -0,0 +1,16 @@ +ARG RUNTIME_IMAGE=ubuntu:24.04@sha256:019e8eb29a85e74d64925745884f2ec79aa27e3feab36353d24656f4d6b89467 +FROM ${RUNTIME_IMAGE} +ENV DEBIAN_FRONTEND=noninteractive +RUN apt-get update \ + && apt-get install -y --no-install-recommends \ + build-essential \ + ca-certificates \ + cmake \ + libqt6sql6-odbc \ + ninja-build \ + patch \ + python3 \ + python3-yaml \ + qt6-base-dev \ + qt6-base-private-dev \ + && rm -rf /var/lib/apt/lists/* diff --git a/odbc/tests/frameworks/qt/run-tests b/odbc/tests/frameworks/qt/run-tests new file mode 100755 index 00000000000..6afedd5798e --- /dev/null +++ b/odbc/tests/frameworks/qt/run-tests @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +"""Build Qt's upstream QtSql tests and preserve every reported data row.""" +import json, os, shutil, subprocess, time +import xml.etree.ElementTree as ET +from pathlib import Path +from urllib.parse import quote +ADAPTER = Path(os.environ["ODBC_ADAPTER_DIR"]) +UPSTREAM = Path(os.environ["ODBC_UPSTREAM_DIR"]) +NATIVE = Path(os.environ["ODBC_NATIVE_RESULTS_DIR"]) +PRISTINE = next(UPSTREAM.glob("*/tests/auto/sql")) +SOURCE, BUILD = Path("/work/qt-sql"), Path("/work/qt-build") +TARGETS = ("qsql", "qsqldatabase", "qsqldriver", "qsqlquery", "qsqlthread", + "qsqlquerymodel", "qsqlrelationaldelegate", "qsqlrelationaltablemodel", "qsqltablemodel") +RUN_LAST = {"qsqldatabase": {"transaction"}, "qsqlthread": {"readWriteThreading"}, + "qsqltablemodel": {"modelInAnotherThread"}} +INAPPLICABLE = {("qsqltablemodel", "modelInAnotherThread"): + "Exercises Qt's hardcoded SQLite in-memory model, outside the QODBC suite."} +# Data-row counts in the locked Qt source with this single QODBC fixture. +ROWS = {"qsqldatabase.errorReporting": 2, "qsqlquery.dateTime": 4, + **{"qsqltablemodel." + name: 3 for name in + ("insertColumns", "insertRow", "insertRowFailure", "removeInsertedRow", "isDirty")}} +MODE = os.environ["ODBC_TEST_MODE"] +DATABASES = {"dsn": os.environ["YDB_ODBC_DSN"], "connection_string": os.environ["YDB_ODBC_CONNECTION_STRING"]} +def run(args, **options): + return subprocess.run([str(arg) for arg in args], text=True, **options) +def problem_details(problem): + message = (problem.get("message") or "").strip() + trace = "".join(problem.itertext()).strip() + return message or trace or problem.tag, "" if trace == message else trace +def prepare_source(): + shutil.copytree(PRISTINE, SOURCE, copy_function=shutil.copyfile) + for root, _, _ in os.walk(SOURCE): Path(root).chmod(0o755) + patch = ADAPTER / "ydb.patch" + applied = run(["patch", "--batch", "--forward", "--fuzz=0", "-p1", "-i", patch], cwd=SOURCE, + stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + (NATIVE / "fixture-patch.log").write_text(applied.stdout or "") + if applied.returncode: + raise RuntimeError(f"fixture patch exited {applied.returncode}:\n{(applied.stdout or '').strip()}") +def main(): + if MODE not in DATABASES: raise RuntimeError(f"unsupported ODBC test mode: {MODE}") + prepare_source() + run(["cmake", "-G", "Ninja", "-S", ADAPTER, "-B", BUILD, f"-DQT_SQL_SOURCE={SOURCE}"], check=True) + run(["cmake", "--build", BUILD, "--parallel", "2"], check=True) + results, inventory, inventory_rows = [], [], {} + database = DATABASES[MODE] + config = Path(f"/work/qt-databases-{MODE}.json") + config.write_text(json.dumps({"entries": [{"driver": "QODBC", "name": database}]}) + "\n") + env = os.environ | {"QT_TEST_DATABASES_FILE": str(config), "QT_QPA_PLATFORM": "offscreen"} + def save(): + (NATIVE / "results.json").write_text(json.dumps({"schema_version": 1, "inventory_kind": "parents", + "inventory": inventory, "inventory_rows": inventory_rows, "tests": results}, indent=2) + "\n") + for target in TARGETS: + binary, xml = BUILD / f"tst_{target}", NATIVE / f"{MODE}-{target}.xml" + functions = [line.removesuffix("()") for line in run([binary, "-functions"], env=env, check=True, + stdout=subprocess.PIPE).stdout.splitlines() if line.endswith("()")] + if not functions: raise RuntimeError(f"Empty Qt suite: {target}") + inventory += [f"qt.{MODE}.{target}.{function}" for function in functions] + inventory_rows.update({f"qt.{MODE}.{target}.{function}": ROWS.get(f"{target}.{function}", 1) + for function in functions}) + save() + delayed = RUN_LAST.get(target, set()) + ordered = [f for f in functions if f not in delayed] + [f for f in functions if f in delayed] + ordered = [f for f in ordered if (target, f) not in INAPPLICABLE] + started = int(time.time() * 1000) + completed = run([binary, *ordered, "-o", f"{xml},junitxml"], env=env, + stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=300) + stopped = int(time.time() * 1000) + log = NATIVE / f"{MODE}-{target}.log"; log.write_text(completed.stdout or "") + cases = ET.parse(xml).getroot().findall("testcase") + lifecycle = [case for case in cases if case.get("name", "").startswith(("initTestCase", "cleanupTestCase"))] + fatal = [item for case in lifecycle for item in case if item.tag in {"error", "failure"}] + if completed.returncode < 0 or completed.returncode > 127 or fatal or (completed.returncode and not any( + item.tag in {"failure", "error"} for case in cases for item in case)): + results.append({"id":f"qt.{MODE}.{target}.infrastructure", "status":"broken", + "phase":"setup", "start":started, "stop":stopped, + "message":f"Qt lifecycle/process failure: exit {completed.returncode}; " + + "; ".join(problem_details(item)[0] for item in fatal)}) + for function in functions: + parent = f"qt.{MODE}.{target}.{function}" + selected = [case for case in cases if case.get("name") == function or case.get("name", "").startswith(function + "(")] + if (target, function) in INAPPLICABLE: + results.append({"id":parent, "parent_id":parent, "status":"skipped", "phase":"test", + "message":INAPPLICABLE[(target,function)], "start":started, "stop":stopped}) + elif not selected: + results.append({"id":parent, "parent_id":parent, "status":"broken", "start":started, + "stop":stopped, "message":"Upstream function is missing from Qt JUnit output"}) + for case in selected: + problems = [{"kind":item.tag, "message":problem_details(item)[0], "trace":problem_details(item)[1], + "location":case.get("name", "")} for item in case if item.tag in {"failure", "error", "skipped"}] + tags = {problem["kind"] for problem in problems} + status = "broken" if "error" in tags else "failed" if "failure" in tags else "skipped" if "skipped" in tags else "passed" + row = case.get("name", "")[len(function):].strip("()") + stable_row = row.replace(database, "YDB") + results.append({"id":parent + "@" + quote(stable_row, safe="_-"), "parent_id":parent, + "name":f"Qt {target}: {function} ({MODE}, {stable_row})", "data_tag":row, + "status":status, "message":"\n".join(p["message"] for p in problems), + "trace":"\n".join(p["trace"] for p in problems), "problems":problems, + "start":started,"stop":stopped, + "attachments":[{"name":p.name,"path":p.name,"type":"text/plain"} for p in (log,xml)]}) + save() + return int(any(test["status"] != "passed" for test in results)) +if __name__ == "__main__": raise SystemExit(main()) diff --git a/odbc/tests/frameworks/qt/upstream.lock b/odbc/tests/frameworks/qt/upstream.lock new file mode 100644 index 00000000000..588ce5461b5 --- /dev/null +++ b/odbc/tests/frameworks/qt/upstream.lock @@ -0,0 +1,6 @@ +kind: archive +url: https://codeload.github.com/qt/qtbase/tar.gz/e3e40c44d3f998a433a6a1080297c5f28e9a768f +revision: e3e40c44d3f998a433a6a1080297c5f28e9a768f +sha256: 31968efe5280ca254b66a60fe2d717e6bc3367e1bd7ff404b256c2a27eb003ba +license: GPL-3.0-only WITH Qt-GPL-exception-1.0 +ci_only: true diff --git a/odbc/tests/frameworks/qt/ydb.patch b/odbc/tests/frameworks/qt/ydb.patch new file mode 100644 index 00000000000..79fc7a47620 --- /dev/null +++ b/odbc/tests/frameworks/qt/ydb.patch @@ -0,0 +1,2775 @@ +# YDB schema, SQL dialect, connection and reporting fixtures. +# Applies to qtbase revision e3e40c44d3f998a433a6a1080297c5f28e9a768f. +# Preserve upstream binding calls and assertions. + +--- a/kernel/qsqldatabase/tst_databases.h ++++ b/kernel/qsqldatabase/tst_databases.h +@@ -85,7 +85,7 @@ + || name.startsWith( "QODBC" ) + || name.startsWith( "QSQLITE" ) + || name.startsWith( "QMYSQL" );*/ +- return name != QLatin1String("QSQLITE2"); ++ return !name.startsWith("QODBC") && name != QLatin1String("QSQLITE2"); + } + + inline static QString toHex( const QString& binary ) +@@ -326,6 +326,12 @@ + // drop a table only if it exists to prevent warnings + static void safeDropTables( QSqlDatabase db, const QStringList& tableNames ) + { ++ if (db.driverName().startsWith("QODBC")) { ++ QSqlQuery q(db); ++ for (const QString &tableName : tableNames) ++ q.exec("drop table if exists " + tableName); ++ return; ++ } + bool wasDropped; + QSqlQuery q( db ); + QStringList dbtables=db.tables(); +@@ -555,4 +561,3 @@ + }; + + #endif +- +--- a/kernel/qsqldatabase/tst_qsqldatabase.cpp ++++ b/kernel/qsqldatabase/tst_qsqldatabase.cpp +@@ -58,15 +58,15 @@ + //database specific tests + void recordMySQL_data() { generic_data("QMYSQL"); } + void recordMySQL(); +- void recordPSQL_data() { generic_data("QPSQL"); } ++ void recordPSQL_data() { generic_data(); } + void recordPSQL(); +- void recordOCI_data() { generic_data("QOCI"); } ++ void recordOCI_data() { generic_data(); } + void recordOCI(); +- void recordTDS_data() { generic_data("QTDS"); } ++ void recordTDS_data() { generic_data(); } + void recordTDS(); +- void recordDB2_data() { generic_data("QDB2"); } ++ void recordDB2_data() { generic_data(); } + void recordDB2(); +- void recordSQLite_data() { generic_data("QSQLITE"); } ++ void recordSQLite_data() { generic_data(); } + void recordSQLite(); + void recordAccess_data() { generic_data("QODBC"); } + void recordAccess(); +@@ -110,21 +110,21 @@ + void multipleThreads_data() { generic_data(); } + void multipleThreads(); + +- void db2_valueCacheUpdate_data() { generic_data("QDB2"); } ++ void db2_valueCacheUpdate_data() { generic_data(); } + void db2_valueCacheUpdate(); + + void psql_schemas_data() { generic_data("QPSQL"); } + void psql_schemas(); + void psql_escapedIdentifiers_data() { generic_data("QPSQL"); } + void psql_escapedIdentifiers(); +- void psql_escapeBytea_data() { generic_data("QPSQL"); } ++ void psql_escapeBytea_data() { generic_data(); } + void psql_escapeBytea(); + void psql_bug249059_data() { generic_data("QPSQL"); } + void psql_bug249059(); + + void mysqlOdbc_unsignedIntegers_data() { generic_data(); } + void mysqlOdbc_unsignedIntegers(); +- void mysql_multiselect_data() { generic_data("QMYSQL"); } ++ void mysql_multiselect_data() { generic_data(); } + void mysql_multiselect(); // For task 144331 + void mysql_savepointtest_data() { generic_data("QMYSQL"); } + void mysql_savepointtest(); +@@ -133,9 +133,9 @@ + void accessOdbc_strings_data() { generic_data(); } + void accessOdbc_strings(); + +- void ibase_numericFields_data() { generic_data("QIBASE"); } ++ void ibase_numericFields_data() { generic_data(); } + void ibase_numericFields(); // For task 125053 +- void ibase_fetchBlobs_data() { generic_data("QIBASE"); } ++ void ibase_fetchBlobs_data() { generic_data(); } + void ibase_fetchBlobs(); // For task 143471 + void ibase_useCustomCharset_data() { generic_data("QIBASE"); } + void ibase_useCustomCharset(); // For task 134608 +@@ -155,7 +155,7 @@ + void odbc_testqGetString_data() { generic_data("QODBC"); } + void odbc_testqGetString(); + +- void oci_serverDetach_data() { generic_data("QOCI"); } ++ void oci_serverDetach_data() { generic_data(); } + void oci_serverDetach(); // For task 154518 + void oci_xmltypeSupport_data() { generic_data("QOCI"); } + void oci_xmltypeSupport(); +@@ -198,14 +198,14 @@ + + //helper class for database specific tests + struct FieldDef { +- FieldDef(QString tn = QString(), +- int t = QMetaType::UnknownType, +- QVariant v = QVariant(), +- bool nl = true): +- typeName(tn), type(t), val(v), nullable(nl) {} ++ FieldDef(QString tn = QString(), int t = QMetaType::UnknownType, ++ QVariant v = QVariant(), bool nl = true, QString fn = QString()): ++ typeName(tn), type(t), val(v), nullable(nl), fieldNameOverride(fn) {} + + QString fieldName() const + { ++ if (!fieldNameOverride.isEmpty()) ++ return fieldNameOverride; + QString rt = typeName; + rt.replace(QRegularExpression("\\s"), QString("_")); + int i = rt.indexOf(QLatin1Char('(')); +@@ -219,6 +219,7 @@ + int type; + QVariant val; + bool nullable; ++ QString fieldNameOverride; + }; + + // creates a table out of the FieldDefs and returns the number of fields +@@ -233,11 +234,11 @@ + QString qs = "create table " + tableName; + QString autoName = tst_Databases::autoFieldName(db); + if (tst_Databases::isMSAccess(db)) +- qs.append(" (id int not null"); ++ qs.append(" (id int"); + else if (dbType == QSqlDriver::PostgreSQL) + qs.append(" (id serial not null"); + else +- qs.append(QString("(id integer not null %1 primary key").arg(autoName)); ++ qs.append(QString("(id integer %1").arg(autoName)); + + int i = 0; + for (i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) { +@@ -246,8 +247,8 @@ + qs += " null"; + } + +- if (tst_Databases::isMSAccess(db)) +- qs.append(",\n primary key (id)"); ++ if (tst_Databases::isMSAccess(db) || db.driverName().startsWith("QODBC")) ++ qs.append(",\n PRIMARY KEY (id)"); + + qs += ')'; + if (!q.exec(qs)) { +@@ -293,18 +294,20 @@ + // please never ever change this table; otherwise fix all tests ;) + if (tst_Databases::isMSAccess(db)) { + QVERIFY_SQL(q, exec("create table " + tableName + +- " (id int not null, t_varchar varchar(40) not null, t_char char(40), " ++ " (id int, t_varchar Utf8, t_char Utf8, " + "t_numeric number, primary key (id, t_varchar))")); + } else { + QVERIFY_SQL(q, exec("create table " + tableName + +- " (id integer not null, t_varchar varchar(40) not null, " +- "t_char char(40), t_numeric numeric(6, 3), primary key (id, t_varchar))")); ++ " (id integer, t_varchar Utf8, " ++ "t_char Utf8, t_numeric Double, primary key (id, t_varchar))")); + } + if (testWhiteSpaceNames(db.driverName())) { + QString qry = "create table " + qTableName("qtest test", __FILE__, db) + + '(' + + db.driver()->escapeIdentifier(QLatin1String("test test"), QSqlDriver::FieldName) +- + " int not null primary key)"; ++ + " int, primary key (" ++ + db.driver()->escapeIdentifier(QLatin1String("test test"), QSqlDriver::FieldName) ++ + "))"; + QVERIFY_SQL(q, exec(qry)); + } + } +@@ -602,7 +605,7 @@ + const bool isCaseSensitive = driverQuotedCaseSensitive(db); + QSqlQuery q(db); + +- QVERIFY_SQL(q, exec("create table " + qtestalter + " (F1 char(20), F2 char(20), F3 char(20))")); ++ QVERIFY_SQL(q, exec("create table " + qtestalter + " (F1 Utf8, F2 Utf8, F3 Utf8, primary key (F1))")); + QSqlRecord rec = db.record(isCaseSensitive ? qtestalter : noEscapeAlterTable); + QCOMPARE((int)rec.count(), 3); + +@@ -638,8 +641,8 @@ + CHECK_DATABASE(db); + + static const FieldDef fieldDefs[] = { +- FieldDef("char(20)", QMetaType(QMetaType::QString), QString("blah1"), false), +- FieldDef("varchar(20)", QMetaType(QMetaType::QString), QString("blah2"), false), ++ FieldDef("Utf8", QMetaType(QMetaType::QString), QString("blah1"), false), ++ FieldDef("Utf8", QMetaType(QMetaType::QString), QString("blah2"), false), + FieldDef() + }; + +@@ -695,26 +698,26 @@ + CHECK_DATABASE(db); + + static const FieldDef fieldDefs[] = { +- FieldDef("tinyint", QMetaType::Int, 255), +- FieldDef("smallint", QMetaType::Int, 32767), +- FieldDef("int", QMetaType::Int, 2147483647), +- FieldDef("numeric(10,9)", QMetaType::Double, 1.23456789), +- FieldDef("decimal(10,9)", QMetaType::Double, 1.23456789), +- FieldDef("float(4)", QMetaType::Double, 1.23456789), +- FieldDef("double precision", QMetaType::Double, 1.23456789), +- FieldDef("real", QMetaType::Double, 1.23456789), +- FieldDef("smallmoney", QMetaType::Double, 100.42), +- FieldDef("money", QMetaType::Double, 200.42), ++ FieldDef("Int32", QMetaType::Int, 255, true, "t_tinyint"), ++ FieldDef("Int32", QMetaType::Int, 32767, true, "t_smallint"), ++ FieldDef("Int32", QMetaType::Int, 2147483647, true, "t_int"), ++ FieldDef("Double", QMetaType::Double, 1.23456789, true, "t_numeric"), ++ FieldDef("Double", QMetaType::Double, 1.23456789, true, "t_decimal"), ++ FieldDef("Double", QMetaType::Double, 1.23456789, true, "t_float"), ++ FieldDef("Double", QMetaType::Double, 1.23456789, true, "t_double_precision"), ++ FieldDef("Double", QMetaType::Double, 1.23456789, true, "t_real"), ++ FieldDef("Double", QMetaType::Double, 100.42, true, "t_smallmoney"), ++ FieldDef("Double", QMetaType::Double, 200.42, true, "t_money"), + // accuracy is that of a minute +- FieldDef("smalldatetime", QMetaType::QDateTime, QDateTime(QDate::currentDate(), QTime(1, 2, 0, 0))), ++ FieldDef("Timestamp", QMetaType::QDateTime, QDateTime(QDate::currentDate(), QTime(1, 2, 0, 0)), true, "t_smalldatetime"), + // accuracy is that of a second +- FieldDef("datetime", QMetaType::QDateTime, QDateTime(QDate::currentDate(), QTime(1, 2, 3, 0))), +- FieldDef("char(20)", QMetaType::QString, "blah1"), +- FieldDef("varchar(20)", QMetaType::QString, "blah2"), +- FieldDef("nchar(20)", QMetaType::QString, "blah3"), +- FieldDef("nvarchar(20)", QMetaType::QString, "blah4"), +- FieldDef("text", QMetaType::QString, "blah5"), +- FieldDef("bit", QMetaType::Int, 1, false), ++ FieldDef("Timestamp", QMetaType::QDateTime, QDateTime(QDate::currentDate(), QTime(1, 2, 3, 0)), true, "t_datetime"), ++ FieldDef("Utf8", QMetaType::QString, "blah1", true, "t_char"), ++ FieldDef("Utf8", QMetaType::QString, "blah2", true, "t_varchar"), ++ FieldDef("Utf8", QMetaType::QString, "blah3", true, "t_nchar"), ++ FieldDef("Utf8", QMetaType::QString, "blah4", true, "t_nvarchar"), ++ FieldDef("Utf8", QMetaType::QString, "blah5", true, "t_text"), ++ FieldDef("Int32", QMetaType::Int, 1, false, "t_bit"), + + FieldDef() + }; +@@ -734,7 +737,7 @@ + CHECK_DATABASE(db); + + // runtime check for Oracle version since V8 doesn't support TIMESTAMPs +- if (tst_Databases::getOraVersion(db) >= 9) ++ if (db.driverName().startsWith("QODBC") || tst_Databases::getOraVersion(db) >= 9) + hasTimeStamp = true; + + FieldDef tsdef; +@@ -746,26 +749,26 @@ + static const QDateTime dt(QDate::currentDate(), QTime(1, 2, 3, 0)); + + if (hasTimeStamp) { +- tsdef = FieldDef("timestamp", QMetaType::QDateTime, dt); +- tstzdef = FieldDef("timestamp with time zone", QMetaType::QDateTime, dt); +- tsltzdef = FieldDef("timestamp with local time zone", QMetaType::QDateTime, dt); +- intytm = FieldDef("interval year to month", QMetaType::QString, QString("+01-01")); +- intdts = FieldDef("interval day to second", QMetaType::QString, QString("+01 00:00:01.000000")); ++ tsdef = FieldDef("Timestamp", QMetaType::QDateTime, dt, true, "t_timestamp"); ++ tstzdef = FieldDef("Timestamp", QMetaType::QDateTime, dt, true, "t_timestamp_with_time_"); ++ tsltzdef = FieldDef("Timestamp", QMetaType::QDateTime, dt, true, "t_timestamp_with_local"); ++ intytm = FieldDef("Utf8", QMetaType::QString, QString("+01-01"), true, "t_interval_year_to_mon"); ++ intdts = FieldDef("Utf8", QMetaType::QString, QString("+01 00:00:01.000000"), true, "t_interval_day_to_seco"); + } + + const FieldDef fieldDefs[] = { +- FieldDef("char(20)", QMetaType::QString, QString("blah1")), +- FieldDef("varchar(20)", QMetaType::QString, QString("blah2")), +- FieldDef("nchar(20)", QMetaType::QString, QString("blah3")), +- FieldDef("nvarchar2(20)", QMetaType::QString, QString("blah4")), +- FieldDef("number(10,5)", QMetaType::Double, 1.1234567), +- FieldDef("date", QMetaType::QDateTime, dt), +- FieldDef("long raw", QMetaType::QByteArray, QByteArray("blah5")), +- FieldDef("raw(2000)", QMetaType::QByteArray, QByteArray("blah6"), false), +- FieldDef("blob", QMetaType::QByteArray, QByteArray("blah7")), +- FieldDef("clob", QMetaType::QByteArray, QByteArray("blah8")), +- FieldDef("nclob", QMetaType::QByteArray, QByteArray("blah9")), +-// FieldDef("bfile", QMetaType::QByteArray, QByteArray("blah10")), ++ FieldDef("Utf8", QMetaType::QString, QString("blah1"), true, "t_char"), ++ FieldDef("Utf8", QMetaType::QString, QString("blah2"), true, "t_varchar"), ++ FieldDef("Utf8", QMetaType::QString, QString("blah3"), true, "t_nchar"), ++ FieldDef("Utf8", QMetaType::QString, QString("blah4"), true, "t_nvarchar2"), ++ FieldDef("Decimal(10,5)", QMetaType::Double, 1.1234567, true, "t_number"), ++ FieldDef("Timestamp", QMetaType::QDateTime, dt, true, "t_date"), ++ FieldDef("String", QMetaType::QByteArray, QByteArray("blah5"), true, "t_long_raw"), ++ FieldDef("String", QMetaType::QByteArray, QByteArray("blah6"), false, "t_raw"), ++ FieldDef("String", QMetaType::QByteArray, QByteArray("blah7"), true, "t_blob"), ++ FieldDef("String", QMetaType::QByteArray, QByteArray("blah8"), true, "t_clob"), ++ FieldDef("String", QMetaType::QByteArray, QByteArray("blah9"), true, "t_nclob"), ++// FieldDef("String", QMetaType::QByteArray, QByteArray("blah10"), true, "t_bfile"), + + intytm, + intdts, +@@ -801,39 +804,39 @@ + + FieldDef byteadef; + if (db.driver()->hasFeature(QSqlDriver::BLOB)) +- byteadef = FieldDef("bytea", QMetaType::QByteArray, QByteArray("bl\\ah")); ++ byteadef = FieldDef("String", QMetaType::QByteArray, QByteArray("bl\\ah"), true, "t_bytea"); + static FieldDef fieldDefs[] = { +- FieldDef("bigint", QMetaType::LongLong, Q_INT64_C(9223372036854775807)), +- FieldDef("bigserial", QMetaType::LongLong, 100, false), +- FieldDef("bit", QMetaType::QString, "1"), // a bit in postgres is a bit-string +- FieldDef("box", QMetaType::QString, "(5,6),(1,2)"), +- FieldDef("char(20)", QMetaType::QString, "blah5678901234567890"), +- FieldDef("varchar(20)", QMetaType::QString, "blah5678901234567890"), +- FieldDef("cidr", QMetaType::QString, "12.123.0.0/24"), +- FieldDef("circle", QMetaType::QString, "<(1,2),3>"), +- FieldDef("date", QMetaType::QDate, QDate::currentDate()), +- FieldDef("float8", QMetaType::Double, 1.12345678912), +- FieldDef("inet", QMetaType::QString, "12.123.12.23"), +- FieldDef("integer", QMetaType::Int, 2147483647), +- FieldDef("interval", QMetaType::QString, "1 day 12:59:10"), ++ FieldDef("Int64", QMetaType::LongLong, Q_INT64_C(9223372036854775807), true, "t_bigint"), ++ FieldDef("Int64", QMetaType::LongLong, 100, false, "t_bigserial"), ++ FieldDef("Utf8", QMetaType::QString, "1", true, "t_bit"), // a bit in postgres is a bit-string ++ FieldDef("Utf8", QMetaType::QString, "(5,6),(1,2)", true, "t_box"), ++ FieldDef("Utf8", QMetaType::QString, "blah5678901234567890", true, "t_char"), ++ FieldDef("Utf8", QMetaType::QString, "blah5678901234567890", true, "t_varchar"), ++ FieldDef("Utf8", QMetaType::QString, "12.123.0.0/24", true, "t_cidr"), ++ FieldDef("Utf8", QMetaType::QString, "<(1,2),3>", true, "t_circle"), ++ FieldDef("Date", QMetaType::QDate, QDate::currentDate(), true, "t_date"), ++ FieldDef("Double", QMetaType::Double, 1.12345678912, true, "t_float8"), ++ FieldDef("Utf8", QMetaType::QString, "12.123.12.23", true, "t_inet"), ++ FieldDef("Int32", QMetaType::Int, 2147483647, true, "t_integer"), ++ FieldDef("Utf8", QMetaType::QString, "1 day 12:59:10", true, "t_interval"), + // LOL... you can create a "line" datatype in PostgreSQL <= 7.2.x but + // as soon as you want to insert data you get a "not implemented yet" error + // FieldDef("line", QMetaType::Polygon, QPolygon(QRect(1, 2, 3, 4))), +- FieldDef("lseg", QMetaType::QString, "[(1,1),(2,2)]"), +- FieldDef("macaddr", QMetaType::QString, "08:00:2b:01:02:03"), +- FieldDef("money", QMetaType::QString, "$12.23"), +- FieldDef("numeric", QMetaType::Double, 1.2345678912), +- FieldDef("path", QMetaType::QString, "((1,2),(3,2),(3,5),(1,5))"), +- FieldDef("point", QMetaType::QString, "(1,2)"), +- FieldDef("polygon", QMetaType::QString, "((1,2),(3,2),(3,5),(1,5))"), +- FieldDef("real", QMetaType::Double, 1.1234), +- FieldDef("smallint", QMetaType::Int, 32767), +- FieldDef("serial", QMetaType::Int, 100, false), +- FieldDef("text", QMetaType::QString, "blah"), +- FieldDef("time(6)", QMetaType::QTime, QTime(1, 2, 3)), +- FieldDef("timetz", QMetaType::QTime, QTime(1, 2, 3)), +- FieldDef("timestamp(6)", QMetaType::QDateTime, QDateTime::currentDateTime()), +- FieldDef("timestamptz", QMetaType::QDateTime, QDateTime::currentDateTime()), ++ FieldDef("Utf8", QMetaType::QString, "[(1,1),(2,2)]", true, "t_lseg"), ++ FieldDef("Utf8", QMetaType::QString, "08:00:2b:01:02:03", true, "t_macaddr"), ++ FieldDef("Utf8", QMetaType::QString, "$12.23", true, "t_money"), ++ FieldDef("Double", QMetaType::Double, 1.2345678912, true, "t_numeric"), ++ FieldDef("Utf8", QMetaType::QString, "((1,2),(3,2),(3,5),(1,5))", true, "t_path"), ++ FieldDef("Utf8", QMetaType::QString, "(1,2)", true, "t_point"), ++ FieldDef("Utf8", QMetaType::QString, "((1,2),(3,2),(3,5),(1,5))", true, "t_polygon"), ++ FieldDef("Double", QMetaType::Double, 1.1234, true, "t_real"), ++ FieldDef("Int32", QMetaType::Int, 32767, true, "t_smallint"), ++ FieldDef("Int32", QMetaType::Int, 100, false, "t_serial"), ++ FieldDef("Utf8", QMetaType::QString, "blah", true, "t_text"), ++ FieldDef("Datetime", QMetaType::QTime, QTime(1, 2, 3), true, "t_time"), ++ FieldDef("Datetime", QMetaType::QTime, QTime(1, 2, 3), true, "t_timetz"), ++ FieldDef("Timestamp", QMetaType::QDateTime, QDateTime::currentDateTime(), true, "t_timestamp"), ++ FieldDef("Timestamp", QMetaType::QDateTime, QDateTime::currentDateTime(), true, "t_timestamptz"), + byteadef, + + FieldDef() +@@ -901,15 +904,15 @@ + FieldDef("bigint unsigned", QMetaType::ULongLong, Q_UINT64_C(18446744073709551615)), + FieldDef("float", QMetaType::Double, 1.12345), + FieldDef("double", QMetaType::Double, 1.123456789), +- FieldDef("decimal(10, 9)", QMetaType::Double, 1.123456789), +- FieldDef("numeric(5, 2)", QMetaType::Double, 123.67), ++ FieldDef("Decimal(10, 9)", QMetaType::Double, 1.123456789), ++ FieldDef("Decimal(5, 2)", QMetaType::Double, 123.67), + FieldDef("date", QMetaType::QDate, QDate::currentDate()), + FieldDef("datetime", QMetaType::QDateTime, dt), + FieldDef("timestamp", QMetaType::QDateTime, dt, false), + FieldDef("time", QMetaType::QString, dt.time()), + FieldDef("year", QMetaType::Int, 2003), +- FieldDef("char(20)", QMetaType::QString, "Blah"), +- FieldDef("varchar(20)", QMetaType::QString, "BlahBlah"), ++ FieldDef("Utf8", QMetaType::QString, "Blah"), ++ FieldDef("Utf8", QMetaType::QString, "BlahBlah"), + FieldDef("tinytext", QMetaType::QString, QString("blah5")), + FieldDef("text", QMetaType::QString, QString("blah6")), + FieldDef("mediumtext", QMetaType::QString, QString("blah7")), +@@ -937,26 +940,26 @@ + CHECK_DATABASE(db); + + static const FieldDef fieldDefs[] = { +- FieldDef("char(20)", QMetaType::QString, QString("Blah1")), +- FieldDef("varchar(20)", QMetaType::QString, QString("Blah2")), +- FieldDef("long varchar", QMetaType::QString, QString("Blah3")), ++ FieldDef("Utf8", QMetaType::QString, QString("Blah1"), true, "t_char"), ++ FieldDef("Utf8", QMetaType::QString, QString("Blah2"), true, "t_varchar"), ++ FieldDef("Utf8", QMetaType::QString, QString("Blah3"), true, "t_long_varchar"), + // using BOOLEAN results in "SQL0486N The BOOLEAN data type is currently only supported internally." + //X FieldDef("boolean" , QMetaType::Bool, QVariant(true, 1)), +- FieldDef("smallint", QMetaType::Int, 32767), +- FieldDef("integer", QMetaType::Int, 2147483647), +- FieldDef("bigint", QMetaType::LongLong, Q_INT64_C(9223372036854775807)), +- FieldDef("real", QMetaType::Double, 1.12345), +- FieldDef("double", QMetaType::Double, 1.23456789), +- FieldDef("float", QMetaType::Double, 1.23456789), +- FieldDef("decimal(10,9)", QMetaType::Double, 1.234567891), +- FieldDef("numeric(10,9)", QMetaType::Double, 1.234567891), +- FieldDef("date", QMetaType::QDate, QDate::currentDate()), +- FieldDef("time", QMetaType::QTime, QTime(1, 2, 3)), +- FieldDef("timestamp", QMetaType::QDateTime, QDateTime::currentDateTime()), +-// FieldDef("graphic(20)", QMetaType::QString, QString("Blah4")), +-// FieldDef("vargraphic(20)", QMetaType::QString, QString("Blah5")), +-// FieldDef("long vargraphic", QMetaType::QString, QString("Blah6")), +- //X FieldDef("datalink", QMetaType::QString, QString("DLVALUE('Blah10')")), ++ FieldDef("Int32", QMetaType::Int, 32767, true, "t_smallint"), ++ FieldDef("Int32", QMetaType::Int, 2147483647, true, "t_integer"), ++ FieldDef("Int64", QMetaType::LongLong, Q_INT64_C(9223372036854775807), true, "t_bigint"), ++ FieldDef("Double", QMetaType::Double, 1.12345, true, "t_real"), ++ FieldDef("Double", QMetaType::Double, 1.23456789, true, "t_double"), ++ FieldDef("Double", QMetaType::Double, 1.23456789, true, "t_float"), ++ FieldDef("Double", QMetaType::Double, 1.234567891, true, "t_decimal"), ++ FieldDef("Double", QMetaType::Double, 1.234567891, true, "t_numeric"), ++ FieldDef("Date", QMetaType::QDate, QDate::currentDate(), true, "t_date"), ++ FieldDef("Datetime", QMetaType::QTime, QTime(1, 2, 3), true, "t_time"), ++ FieldDef("Timestamp", QMetaType::QDateTime, QDateTime::currentDateTime(), true, "t_timestamp"), ++// FieldDef("Utf8", QMetaType::QString, QString("Blah4"), true, "t_graphic"), ++// FieldDef("Utf8", QMetaType::QString, QString("Blah5"), true, "t_vargraphic"), ++// FieldDef("Utf8", QMetaType::QString, QString("Blah6"), true, "t_long_vargraphic"), ++ //X FieldDef("Utf8", QMetaType::QString, QString("DLVALUE('Blah10')"), true, "t_datalink"), + FieldDef() + }; + +@@ -973,15 +976,15 @@ + CHECK_DATABASE(db); + + static const FieldDef fieldDefs[] = { +- FieldDef("char(20)", QMetaType::QString, QString("Blah1"), false), +- FieldDef("varchar(20)", QMetaType::QString, QString("Blah2")), ++ FieldDef("Utf8", QMetaType::QString, QString("Blah1"), false), ++ FieldDef("Utf8", QMetaType::QString, QString("Blah2")), + FieldDef("smallint", QMetaType::Int, 32767), + FieldDef("float", QMetaType::Double, 1.2345), + FieldDef("double precision", QMetaType::Double, 1.2345678), + FieldDef("timestamp", QMetaType::QDateTime, QDateTime::currentDateTime()), + FieldDef("time", QMetaType::QTime, QTime::currentTime()), + FieldDef("decimal(18)", QMetaType::LongLong, Q_INT64_C(9223372036854775807)), +- FieldDef("numeric(5,2)", QMetaType::Double, 123.45), ++ FieldDef("Double", QMetaType::Double, 123.45), + FieldDef("boolean", QMetaType::Bool, true), + + FieldDef() +@@ -1001,23 +1004,23 @@ + + static QDateTime dt(QDate::currentDate(), QTime(1, 2, 3, 0)); + static const FieldDef fieldDefs[] = { +- FieldDef("decimal(10, 9)", QMetaType::Double, 1.123456789), +- FieldDef("numeric(5, 2)", QMetaType::Double, 123.67), +- FieldDef("float", QMetaType::Double, 1.123456789), +- FieldDef("double precision", QMetaType::Double, 1.123456789), +- FieldDef("real", QMetaType::Float, 1.12345), ++ FieldDef("Double", QMetaType::Double, 1.123456789, true, "t_decimal_10_9"), ++ FieldDef("Double", QMetaType::Double, 123.67, true, "t_numeric_5_2"), ++ FieldDef("Double", QMetaType::Double, 1.123456789, true, "t_float"), ++ FieldDef("Double", QMetaType::Double, 1.123456789, true, "t_double_precision"), ++ FieldDef("Float", QMetaType::Float, 1.12345, true, "t_real"), + + // FieldDef("tinyint", QMetaType::Char, 127), // not supported by psqlODBC +- FieldDef("smallint", QMetaType::Short, 32767), +- FieldDef("integer", QMetaType::Int, 2147483647), +- FieldDef("bigint", QMetaType::LongLong, Q_INT64_C(9223372036854775807)), +- +- FieldDef("date", QMetaType::QDate, QDate::currentDate()), +- FieldDef("timestamp", QMetaType::QDateTime, dt, false), +- FieldDef("time", QMetaType::QTime, dt.time()), +- FieldDef("char(20)", QMetaType::QString, "Blah"), +- FieldDef("varchar(20)", QMetaType::QString, "BlahBlah"), +- FieldDef("text", QMetaType::QString, QString("blah6")), ++ FieldDef("Int16", QMetaType::Short, 32767, true, "t_smallint"), ++ FieldDef("Int32", QMetaType::Int, 2147483647, true, "t_integer"), ++ FieldDef("Int64", QMetaType::LongLong, Q_INT64_C(9223372036854775807), true, "t_bigint"), ++ ++ FieldDef("Date", QMetaType::QDate, QDate::currentDate(), true, "t_date"), ++ FieldDef("Timestamp", QMetaType::QDateTime, dt, false, "t_timestamp"), ++ FieldDef("Datetime", QMetaType::QTime, dt.time(), true, "t_time"), ++ FieldDef("Utf8", QMetaType::QString, "Blah", true, "t_char"), ++ FieldDef("Utf8", QMetaType::QString, "BlahBlah", true, "t_varchar"), ++ FieldDef("Utf8", QMetaType::QString, QString("blah6"), true, "t_text"), + + FieldDef() + }; +@@ -1036,14 +1039,14 @@ + + static const FieldDef fieldDefs[] = { + // The affinity of these fields are TEXT so SQLite should give us strings, not ints or doubles. +- FieldDef("char(20)", QMetaType::QString, QString("123")), +- FieldDef("varchar(20)", QMetaType::QString, QString("123.4")), +- FieldDef("clob", QMetaType::QString, QString("123.45")), +- FieldDef("text", QMetaType::QString, QString("123.456")), +- +- FieldDef("integer", QMetaType::Int, QVariant(13)), +- FieldDef("int", QMetaType::Int, QVariant(12)), +- FieldDef("real", QMetaType::Double, QVariant(1.234567890123456)), ++ FieldDef("Utf8", QMetaType::QString, QString("123"), true, "t_char"), ++ FieldDef("Utf8", QMetaType::QString, QString("123.4"), true, "t_varchar"), ++ FieldDef("Utf8", QMetaType::QString, QString("123.45"), true, "t_clob"), ++ FieldDef("Utf8", QMetaType::QString, QString("123.456"), true, "t_text"), ++ ++ FieldDef("Int32", QMetaType::Int, QVariant(13), true, "t_integer"), ++ FieldDef("Int32", QMetaType::Int, QVariant(12), true, "t_int"), ++ FieldDef("Double", QMetaType::Double, QVariant(1.234567890123456), true, "t_real"), + + FieldDef() + }; +@@ -1061,18 +1064,19 @@ + CHECK_DATABASE(db); + + QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db); +- if (dbType != QSqlDriver::MSSqlServer) ++ if (dbType != QSqlDriver::MSSqlServer && !db.driverName().startsWith("QODBC")) + QSKIP("SQL server specific test"); ++ + + // ### TODO: Add the rest of the fields + static const FieldDef fieldDefs[] = { +- FieldDef("varchar(20)", QMetaType::QString, QString("Blah1")), +- FieldDef("bigint", QMetaType::LongLong, 12345), +- FieldDef("int", QMetaType::Int, 123456), +- FieldDef("tinyint", QMetaType::UInt, 255), +- FieldDef("float", QMetaType::Double, 1.12345), +- FieldDef("numeric(5,2)", QMetaType::Double, 123.45), +- FieldDef("uniqueidentifier", QMetaType::QString, ++ FieldDef("Utf8", QMetaType::QString, QString("Blah1"), true, "t_varchar"), ++ FieldDef("Int64", QMetaType::LongLong, 12345, true, "t_bigint"), ++ FieldDef("Int32", QMetaType::Int, 123456, true, "t_int"), ++ FieldDef("Uint8", QMetaType::UInt, 255, true, "t_tinyint"), ++ FieldDef("Double", QMetaType::Double, 1.12345, true, "t_float"), ++ FieldDef("Double", QMetaType::Double, 123.45, true, "t_numeric"), ++ FieldDef("Uuid", QMetaType::QString, + QString("AA7DF450-F119-11CD-8465-00AA00425D90")), + + FieldDef() +@@ -1090,8 +1094,9 @@ + QSqlDatabase db = QSqlDatabase::database(dbName); + CHECK_DATABASE(db); + +- if (!tst_Databases::isMSAccess(db)) ++ if (!tst_Databases::isMSAccess(db) && !db.driverName().startsWith("QODBC")) + QSKIP("MS Access specific test"); ++ + + QString memo; + for (int i = 0; i < 32; i++) +@@ -1099,12 +1104,12 @@ + + // ### TODO: Add the rest of the fields + static const FieldDef fieldDefs[] = { +- FieldDef("varchar(20)", QMetaType::QString, QString("Blah1")), +- FieldDef("single", QMetaType::Double, 1.12345), +- FieldDef("double", QMetaType::Double, 1.123456), +- FieldDef("byte", QMetaType::UInt, 255), +- FieldDef("long", QMetaType::Int, 2147483647), +- FieldDef("memo", QMetaType::QString, memo), ++ FieldDef("Utf8", QMetaType::QString, QString("Blah1"), true, "t_varchar"), ++ FieldDef("Double", QMetaType::Double, 1.12345, true, "t_single"), ++ FieldDef("Double", QMetaType::Double, 1.123456, true, "t_double"), ++ FieldDef("Uint8", QMetaType::UInt, 255, true, "t_byte"), ++ FieldDef("Int32", QMetaType::Int, 2147483647, true, "t_long"), ++ FieldDef("Utf8", QMetaType::QString, memo, true, "t_memo"), + FieldDef() + }; + +@@ -1128,7 +1133,8 @@ + QVERIFY(db.transaction()); + + QSqlQuery q(db); +- QVERIFY_SQL(q, exec("insert into " + qtest + " values (40, 'VarChar40', 'Char40', 40.40)")); ++ QVERIFY_SQL(q, exec("insert into " + qtest ++ + " (id, t_varchar, t_char, t_numeric) values (40, 'VarChar40', 'Char40', 40.40)")); + QVERIFY_SQL(q, exec("select * from " + qtest + " where id = 40")); + QVERIFY(q.next()); + QCOMPARE(q.value(0).toInt(), 40); +@@ -1144,7 +1150,8 @@ + QVERIFY(db.commit()); + + QVERIFY(db.transaction()); +- QVERIFY_SQL(q, exec("insert into " + qtest + " values (41, 'VarChar41', 'Char41', 41.41)")); ++ QVERIFY_SQL(q, exec("insert into " + qtest ++ + " (id, t_varchar, t_char, t_numeric) values (41, 'VarChar41', 'Char41', 41.41)")); + QVERIFY_SQL(q, exec("select * from " + qtest + " where id = 41")); + QVERIFY(q.next()); + QCOMPARE(q.value(0).toInt(), 41); +@@ -1184,16 +1191,20 @@ + QVERIFY_SQL(q, exec("create table " + qtest_bigint + "(id int, t_s64bit bigint, t_u64bit bigint)")); + } else if (dbType == QSqlDriver::Oracle) { + QVERIFY_SQL(q, exec("create table " + qtest_bigint + " (id int, t_s64bit int, t_u64bit int)")); ++ } else if (db.driverName().startsWith("QODBC")) { ++ QVERIFY_SQL(q, exec("create table " + qtest_bigint ++ + " (id Int32, t_s64bit Int64, t_u64bit Uint64, primary key (id))")); + //} else if (dbType == QSqlDriver::Interbase) { + // QVERIFY_SQL(q, exec("create table " + qtest_bigint + " (id int, t_s64bit int64, t_u64bit int64)")); + } else { + QSKIP("no 64 bit integer support"); + } +- QVERIFY(q.prepare("insert into " + qtest_bigint + " values (?, ?, ?)")); ++ QVERIFY(q.prepare("insert into " + qtest_bigint + " (id, t_s64bit, t_u64bit) values (?, ?, ?)")); + qlonglong ll = Q_INT64_C(9223372036854775807); + qulonglong ull = Q_UINT64_C(18446744073709551615); + +- if (dbType == QSqlDriver::MySqlServer || dbType == QSqlDriver::Oracle) { ++ if (dbType == QSqlDriver::MySqlServer || dbType == QSqlDriver::Oracle ++ || db.driverName().startsWith("QODBC")) { + q.bindValue(0, 0); + q.bindValue(1, ll); + q.bindValue(2, ull); +@@ -1262,10 +1273,10 @@ + + // Explicit test for case sensitive table creation without quoting + QSqlQuery qry(db); +- const auto noQuotesTable = qTableName("NoQuotes", __FILE__, db, false); ++ const auto noQuotesTable = db.driverName().startsWith("QODBC") ? qTableName("NoQuotes", __FILE__, db, false).toLower() : qTableName("NoQuotes", __FILE__, db, false); + tst_Databases::safeDropTable(db, noQuotesTable); +- QVERIFY_SQL(qry, exec("CREATE TABLE " + noQuotesTable + " (id INTEGER)")); +- QVERIFY_SQL(qry, exec("INSERT INTO " + noQuotesTable + " VALUES(1)")); ++ QVERIFY_SQL(qry, exec("CREATE TABLE " + noQuotesTable + " (id INTEGER, primary key (id))")); ++ QVERIFY_SQL(qry, exec("INSERT INTO " + noQuotesTable + " (id) VALUES(1)")); + QVERIFY_SQL(qry, exec("SELECT * FROM " + noQuotesTable)); + QVERIFY_SQL(qry, next()); + QCOMPARE(qry.value(0).toInt(), 1); +@@ -1308,7 +1319,7 @@ + const auto table = schemaName + '.' + qTableName("qtesttable", __FILE__, db); + const auto noescapeTable = qTableName("qtestschema", __FILE__, db, false) + '.' + + qTableName("qtesttable", __FILE__, db, false); +- QVERIFY_SQL(q, exec("CREATE TABLE " + table + " (id int primary key, name varchar(20))")); ++ QVERIFY_SQL(q, exec("CREATE TABLE " + table + " (id int, name Utf8, primary key (id))")); + + QVERIFY(db.tables().contains(noescapeTable, Qt::CaseInsensitive)); + +@@ -1344,7 +1355,7 @@ + q.exec(QString("DROP SCHEMA %1 CASCADE").arg(schemaName)); + const auto createSchema = QString("CREATE SCHEMA %1").arg(schemaName); + QVERIFY_SQL(q, exec(createSchema)); +- const auto createTable = QString("CREATE TABLE %1.%2 (\"%3\" int PRIMARY KEY, \"%4\" varchar(20))") ++ const auto createTable = QString("CREATE TABLE %1.%2 (\"%3\" int, \"%4\" Utf8, PRIMARY KEY (\"%3\"))") + .arg(schemaName, tableName, field1Name, field2Name); + QVERIFY_SQL(q, exec(createTable)); + +@@ -1381,10 +1392,10 @@ + + QSqlQuery q(db); + const QString tableName(qTableName("batable", __FILE__, db)); +- QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (ba bytea)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (ba String, PRIMARY KEY (ba))").arg(tableName))); + + QSqlQuery iq(db); +- QVERIFY_SQL(iq, prepare(QString("INSERT INTO %1 VALUES (?)").arg(tableName))); ++ QVERIFY_SQL(iq, prepare(QString("INSERT INTO %1 (ba) VALUES (?)").arg(tableName))); + iq.bindValue(0, QVariant(ba)); + QVERIFY_SQL(iq, exec()); + +@@ -1451,8 +1462,8 @@ + if(tst_Databases::isMSAccess(db)) + QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id smallint, num number)").arg(tableName))); + else +- QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id smallint, num numeric(18,5))").arg(tableName))); +- QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?, ?)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id Int16, num Decimal(18, 5), primary key (id))").arg(tableName))); ++ QVERIFY_SQL(q, prepare((db.driverName().startsWith("QODBC") ? QString("INSERT INTO %1 (id, num) VALUES (CAST(? AS Int16), CAST(CAST(? AS Utf8) AS Decimal(18, 5)))") : QString("INSERT INTO %1 (id, num) VALUES (?, ?)")).arg(tableName))); + q.bindValue(0, 1); + q.bindValue(1, 123); + QVERIFY_SQL(q, exec()); +@@ -1532,15 +1543,16 @@ + QSqlDatabase db = QSqlDatabase::database(dbName); + CHECK_DATABASE(db); + +- if (tst_Databases::getDatabaseType(db) != QSqlDriver::PostgreSQL) ++ if (tst_Databases::getDatabaseType(db) != QSqlDriver::PostgreSQL ++ && !db.driverName().startsWith("QODBC")) + QSKIP("checking for infinity/nan currently only works for PostgreSQL"); + + QSqlQuery q(db); + const QString tableName(qTableName("infititytest", __FILE__, db)); + tst_Databases::safeDropTables(db, {tableName}); +- QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id smallint, val double precision)").arg(tableName))); +- +- QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?, ?)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id int, val Double, primary key (id))").arg(tableName))); ++ ++ QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 (id, val) VALUES (?, ?)").arg(tableName))); + + q.bindValue(0, 1); + q.bindValue(1, qQNaN()); +@@ -1597,15 +1609,15 @@ + QSqlDatabase db = QSqlDatabase::database(dbName); + CHECK_DATABASE(db); + +- if (!tst_Databases::isMSAccess(db)) ++ if (!tst_Databases::isMSAccess(db) && !db.driverName().startsWith("QODBC")) + QSKIP("MS Access specific test"); + + QSqlQuery q(db); + const QString tableName(qTableName("strings", __FILE__, db)); +- QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (aStr memo, bStr memo, cStr memo, dStr memo" +- ", eStr memo, fStr memo, gStr memo, hStr memo)").arg(tableName))); +- +- QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?, ?, ?, ?, ?, ?, ?, ?)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (aStr Utf8, bStr Utf8, cStr Utf8, dStr Utf8" ++ ", eStr Utf8, fStr Utf8, gStr Utf8, hStr Utf8, primary key (aStr))").arg(tableName))); ++ ++ QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 (aStr, bStr, cStr, dStr, eStr, fStr, gStr, hStr) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").arg(tableName))); + QString aStr, bStr, cStr, dStr, eStr, fStr, gStr, hStr; + + q.bindValue(0, aStr.fill('A', 32)); +@@ -1640,13 +1652,13 @@ + + QSqlQuery q(db); + const QString tableName(qTableName("numericfields", __FILE__, db)); +- QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id int not null, num1 NUMERIC(2,1), " +- "num2 NUMERIC(5,2), num3 NUMERIC(10,3), " +- "num4 NUMERIC(18,4))").arg(tableName))); +- +- QVERIFY_SQL(q, exec(QString("INSERT INTO %1 VALUES (1, 1.1, 123.45, 1234567.123, 10203040506070.8090)").arg(tableName))); +- +- QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?, ?, ?, ?, ?)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id int not null, num1 Decimal(2,1), " ++ "num2 Decimal(5,2), num3 Decimal(10,3), " ++ "num4 Decimal(18,4), PRIMARY KEY (id))").arg(tableName))); ++ ++ QVERIFY_SQL(q, exec(QString("INSERT INTO %1 (id, num1, num2, num3, num4) VALUES (1, Decimal('1.1's, 2, 1), Decimal('123.45's, 5, 2), Decimal('1234567.123's, 10, 3), Decimal('10203040506070.8090's, 18, 4))").arg(tableName))); ++ ++ QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 (id, num1, num2, num3, num4) VALUES (?, CAST(CAST(? AS String) AS Decimal(2,1)), CAST(CAST(? AS String) AS Decimal(5,2)), CAST(CAST(? AS String) AS Decimal(10,3)), CAST(CAST(? AS String) AS Decimal(18,4)))").arg(tableName))); + + double num1 = 1.1; + double num2 = 123.45; +@@ -1660,7 +1672,7 @@ + q.bindValue(4, QVariant(num4)); + QVERIFY_SQL(q, exec()); + +- QVERIFY_SQL(q, exec(QString("SELECT id, num1, num2, num3, num4 FROM %1").arg(tableName))); ++ QVERIFY_SQL(q, exec(QString("SELECT id, num1, num2, num3, num4 FROM %1 ORDER BY id").arg(tableName))); + + int id = 0; + while (q.next()) { +@@ -1713,21 +1725,21 @@ + + const QString tableName(qTableName("qtest_ibaseblobs", __FILE__, db)); + QSqlQuery q(db); +- QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (blob1 BLOB segment size 256)").arg(tableName))); +- +- QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id Int32, blob1 String, PRIMARY KEY (id))").arg(tableName))); ++ ++ QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 (id, blob1) VALUES (0, ?)").arg(tableName))); + q.bindValue(0, QByteArray().fill('x', 1024)); + QVERIFY_SQL(q, exec()); + +- QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?)").arg(tableName))); ++ QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 (id, blob1) VALUES (1, ?)").arg(tableName))); + q.bindValue(0, QByteArray().fill('x', 16383)); + QVERIFY_SQL(q, exec()); + +- QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?)").arg(tableName))); ++ QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 (id, blob1) VALUES (2, ?)").arg(tableName))); + q.bindValue(0, QByteArray().fill('x', 17408)); + QVERIFY_SQL(q, exec()); + +- QVERIFY_SQL(q, exec(QString("SELECT * FROM %1").arg(tableName))); ++ QVERIFY_SQL(q, exec(QString("SELECT blob1 FROM %1 ORDER BY id").arg(tableName))); + + QVERIFY_SQL(q, next()); + QCOMPARE(q.value(0).toByteArray().size(), 1024); +@@ -1746,7 +1758,7 @@ + QSqlQuery q(db); + const QString procName(qTableName("qtest_proc1", __FILE__, db)); + q.exec(QString("drop procedure %1").arg(procName)); +- QVERIFY_SQL(q, exec("CREATE PROCEDURE " + procName + " (str VARCHAR(10))\nAS BEGIN\nstr='test';\nEND;")); ++ QVERIFY_SQL(q, exec("CREATE PROCEDURE " + procName + " (str Utf8)\nAS BEGIN\nstr='test';\nEND;")); + QVERIFY_SQL(q, exec(QString("execute procedure %1('qtest')").arg(procName))); + q.exec(QString("drop procedure %1").arg(procName)); + } +@@ -1848,10 +1860,10 @@ + + QSqlQuery q(db); + const QString tableName = qTableName("qtestBindBool", __FILE__, db); +- QVERIFY_SQL(q, exec("CREATE TABLE " + tableName + "(id int, boolvalue bit)")); ++ QVERIFY_SQL(q, exec("CREATE TABLE " + tableName + "(id int, boolvalue Bool, primary key (id))")); + + // Bind and insert +- QVERIFY_SQL(q, prepare("INSERT INTO " + tableName + " VALUES(?, ?)")); ++ QVERIFY_SQL(q, prepare("INSERT INTO " + tableName + " (id, boolvalue) VALUES(?, ?)")); + q.bindValue(0, 1); + q.bindValue(1, true); + QVERIFY_SQL(q, exec()); +@@ -1883,13 +1895,13 @@ + else if(tst_Databases::isMSAccess(db)) + QVERIFY_SQL(q, exec("CREATE TABLE " + testqGetString + "(id int, vcvalue memo)")); + else +- QVERIFY_SQL(q, exec("CREATE TABLE " + testqGetString + "(id int, vcvalue varchar(65538))")); ++ QVERIFY_SQL(q, exec("CREATE TABLE " + testqGetString + "(id int, vcvalue Utf8, primary key (id))")); + + QString largeString; + largeString.fill('A', 65536); + + // Bind and insert +- QVERIFY_SQL(q, prepare("INSERT INTO " + testqGetString + " VALUES(?, ?)")); ++ QVERIFY_SQL(q, prepare("INSERT INTO " + testqGetString + " (id, vcvalue) VALUES(?, ?)")); + q.bindValue(0, 1); + q.bindValue(1, largeString); + QVERIFY_SQL(q, exec()); +@@ -1945,7 +1957,7 @@ + QSqlQuery q(db); + QEXPECT_FAIL("", "Currently fails, potentially due to invalid test - needs further " + "investigation - QTBUG-85828", Abort); +- QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(text VARCHAR(6) CHARACTER SET Latin1)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(text Utf8 CHARACTER SET Latin1)").arg(tableName))); + QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES(?)").arg(tableName))); + q.addBindValue(nonlatin1string); + QVERIFY_SQL(q, exec()); +@@ -1964,7 +1976,7 @@ + db.close(); + if (db.open()) { + QSqlQuery query(db); +- query.exec("SELECT 1 FROM DUAL"); ++ query.exec("SELECT 1"); + db.close(); + } else { + QFAIL(tst_Databases::printError(db.lastError(), db)); +@@ -2033,7 +2045,7 @@ + db2.close(); + QVERIFY_SQL(db2, open(creator,creator)); + QSqlQuery q2(db2); +- QVERIFY_SQL(q2, exec(QString("create table %1(id int primary key)").arg(table1))); ++ QVERIFY_SQL(q2, exec(QString("create table %1(id int, primary key (id))").arg(table1))); + QVERIFY_SQL(q, exec(QString("create user %1 identified by %2 default tablespace users temporary tablespace temp").arg(appuser).arg(appuser))); + QVERIFY_SQL(q, exec(QString("grant CREATE ANY SYNONYM to %1").arg(appuser))); + QVERIFY_SQL(q, exec(QString("grant CONNECT to %1").arg(appuser))); +@@ -2108,8 +2120,8 @@ + if ( tst_Databases::isMSAccess( db ) ) + QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(num number)").arg(tableName))); + else +- QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(num numeric(10))").arg(tableName))); +- q.prepare(QString("INSERT INTO %1 VALUES(?)").arg(tableName)); ++ QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(num Uint32, primary key (num))").arg(tableName))); ++ q.prepare(QString("INSERT INTO %1 (num) VALUES(?)").arg(tableName)); + q.addBindValue(val); + QVERIFY_SQL(q, exec()); + +@@ -2337,7 +2349,7 @@ + CHECK_DATABASE(db); + QSqlQuery q(db); + const QString systemTableName("sys." + qTableName("mypassword", __FILE__, db).toUpper()); +- QVERIFY_SQL(q, exec("CREATE TABLE "+systemTableName+"(name VARCHAR(20))")); ++ QVERIFY_SQL(q, exec("CREATE TABLE "+systemTableName+"(name Utf8)")); + QVERIFY(!db.tables().contains(systemTableName.toUpper())); + QVERIFY(db.tables(QSql::SystemTables).contains(systemTableName.toUpper())); + } +--- a/kernel/qsqldriver/tst_qsqldriver.cpp ++++ b/kernel/qsqldriver/tst_qsqldriver.cpp +@@ -67,16 +67,16 @@ + else if (dbType == QSqlDriver::PostgreSQL) + doubleField = "more_data double precision"; + else if (dbType == QSqlDriver::Interbase) +- doubleField = "more_data numeric(8,7)"; +- else +- doubleField = "more_data double(8,7)"; ++ doubleField = "more_data Double"; ++ else ++ doubleField = "more_data Double"; + const QString defValue(driverSupportsDefaultValues(dbType) ? QStringLiteral("DEFAULT 'defaultVal'") : QString()); + QVERIFY_SQL( q, exec("create table " + relTEST1 + +- " (id int not null primary key, name varchar(20) " + defValue + ", title_key int, another_title_key int, " + doubleField + QLatin1Char(')'))); +- QVERIFY_SQL( q, exec("insert into " + relTEST1 + " values(1, 'harry', 1, 2, 1.234567)")); +- QVERIFY_SQL( q, exec("insert into " + relTEST1 + " values(2, 'trond', 2, 1, 8.901234)")); +- QVERIFY_SQL( q, exec("insert into " + relTEST1 + " values(3, 'vohi', 1, 2, 5.678901)")); +- QVERIFY_SQL( q, exec("insert into " + relTEST1 + " values(4, 'boris', 2, 2, 2.345678)")); ++ " (id int, name Utf8 " + defValue + ", title_key int, another_title_key int, " + doubleField + ", primary key (id)" + QLatin1Char(')'))); ++ QVERIFY_SQL( q, exec("insert into " + relTEST1 + " (id, name, title_key, another_title_key, more_data) values(1, 'harry', 1, 2, 1.234567)")); ++ QVERIFY_SQL( q, exec("insert into " + relTEST1 + " (id, name, title_key, another_title_key, more_data) values(2, 'trond', 2, 1, 8.901234)")); ++ QVERIFY_SQL( q, exec("insert into " + relTEST1 + " (id, name, title_key, another_title_key, more_data) values(3, 'vohi', 1, 2, 5.678901)")); ++ QVERIFY_SQL( q, exec("insert into " + relTEST1 + " (id, name, title_key, another_title_key, more_data) values(4, 'boris', 2, 2, 2.345678)")); + } + + void tst_QSqlDriver::initTestCase() +@@ -152,6 +152,8 @@ + tablename = tablename.toLower(); + else if (dbType == QSqlDriver::PostgreSQL) + tablename = tablename.toUpper(); ++ else if (db.driverName().startsWith("QODBC")) ++ tablename = tablename.toLower(); + + //check that we can't get records using incorrect tablename casing that's been quoted + rec = db.driver()->record(db.driver()->escapeIdentifier(tablename,QSqlDriver::TableName)); +@@ -203,6 +205,8 @@ + tablename = tablename.toLower(); + else if (dbType == QSqlDriver::PostgreSQL) + tablename = tablename.toUpper(); ++ else if (db.driverName().startsWith("QODBC")) ++ tablename = tablename.toLower(); + + index = db.driver()->primaryIndex(db.driver()->escapeIdentifier(tablename, QSqlDriver::TableName)); + if (dbType == QSqlDriver::MySqlServer || dbType == QSqlDriver::SQLite || dbType == QSqlDriver::Sybase +--- a/kernel/qsqlquery/tst_qsqlquery.cpp ++++ b/kernel/qsqlquery/tst_qsqlquery.cpp +@@ -59,7 +59,7 @@ + void transaction(); + void record_data() { generic_data(); } + void record(); +- void record_sqlite_data() { generic_data("QSQLITE"); } ++ void record_sqlite_data() { generic_data(); } + void record_sqlite(); + void finish_data() { generic_data(); } + void finish(); +@@ -77,13 +77,13 @@ + void psql_forwardOnlyQueryResultsLost(); + + // Bug-specific tests: +- void tds_bitField_data() { generic_data("QTDS"); } ++ void tds_bitField_data() { generic_data(); } + void tds_bitField(); +- void oci_nullBlob_data() { generic_data("QOCI"); } ++ void oci_nullBlob_data() { generic_data(); } + void oci_nullBlob(); + void blob_data() { generic_data(); } + void blob(); +- void oci_rawField_data() { generic_data("QOCI"); } ++ void oci_rawField_data() { generic_data(); } + void oci_rawField(); + void precision_data() { generic_data(); } + void precision(); +@@ -103,11 +103,11 @@ + void oraOutValues(); + void mysql_outValues_data() { generic_data("QMYSQL"); } + void mysql_outValues(); +- void oraClob_data() { generic_data("QOCI"); } ++ void oraClob_data() { generic_data(); } + void oraClob(); +- void oraClobBatch_data() { generic_data("QOCI"); } ++ void oraClobBatch_data() { generic_data(); } + void oraClobBatch(); +- void oraLong_data() { generic_data("QOCI"); } ++ void oraLong_data() { generic_data(); } + void oraLong(); + void oraOCINumber_data() { generic_data("QOCI"); } + void oraOCINumber(); +@@ -141,7 +141,7 @@ + void bindBool(); + void psql_bindWithDoubleColonCastOperator_data() { generic_data("QPSQL"); } + void psql_bindWithDoubleColonCastOperator(); +- void psql_specialFloatValues_data() { generic_data("QPSQL"); } ++ void psql_specialFloatValues_data() { generic_data(); } + void psql_specialFloatValues(); + void queryOnInvalidDatabase_data() { generic_data(); } + void queryOnInvalidDatabase(); +@@ -171,7 +171,7 @@ + void task_250026(); + void crashQueryOnCloseDatabase(); + +- void task_233829_data() { generic_data("QPSQL"); } ++ void task_233829_data() { generic_data(); } + void task_233829(); + + void QTBUG_12477_data() { generic_data("QPSQL"); } +@@ -191,9 +191,9 @@ + void QTBUG_6618(); + void QTBUG_6852_data() { generic_data("QMYSQL"); } + void QTBUG_6852(); +- void QTBUG_5765_data() { generic_data("QMYSQL"); } ++ void QTBUG_5765_data() { generic_data(); } + void QTBUG_5765(); +- void QTBUG_12186_data() { generic_data("QSQLITE"); } ++ void QTBUG_12186_data() { generic_data(); } + void QTBUG_12186(); + void QTBUG_14132_data() { generic_data("QOCI"); } + void QTBUG_14132(); +@@ -201,11 +201,11 @@ + void QTBUG_18435(); + void QTBUG_21884_data() { generic_data("QSQLITE"); } + void QTBUG_21884(); +- void QTBUG_16967_data() { generic_data("QSQLITE"); } ++ void QTBUG_16967_data() { generic_data(); } + void QTBUG_16967(); // clean close + void QTBUG_23895_data() { generic_data("QSQLITE"); } + void QTBUG_23895(); // sqlite boolean type +- void QTBUG_14904_data() { generic_data("QSQLITE"); } ++ void QTBUG_14904_data() { generic_data(); } + void QTBUG_14904(); + + void QTBUG_2192_data() { generic_data(); } +@@ -214,7 +214,7 @@ + void QTBUG_36211_data() { generic_data("QPSQL"); } + void QTBUG_36211(); + +- void QTBUG_53969_data() { generic_data("QMYSQL"); } ++ void QTBUG_53969_data() { generic_data(); } + void QTBUG_53969(); + + void gisPointDatatype_data() { generic_data("QMYSQL"); } +@@ -223,16 +223,16 @@ + void sqlite_constraint_data() { generic_data("QSQLITE"); } + void sqlite_constraint(); + +- void sqlite_real_data() { generic_data("QSQLITE"); } ++ void sqlite_real_data() { generic_data(); } + void sqlite_real(); + + void aggregateFunctionTypes_data() { generic_data(); } + void aggregateFunctionTypes(); + +- void integralTypesMysql_data() { generic_data("QMYSQL"); } ++ void integralTypesMysql_data() { generic_data(); } + void integralTypesMysql(); + +- void QTBUG_57138_data() { generic_data("QSQLITE"); } ++ void QTBUG_57138_data() { generic_data(); } + void QTBUG_57138(); + + void QTBUG_73286_data() { generic_data("QODBC"); } +@@ -364,13 +364,14 @@ + << qTableName("bug2192", __FILE__, db) + << qTableName("tst_record", __FILE__, db); + +- if (dbType == QSqlDriver::PostgreSQL) ++ if (dbType == QSqlDriver::PostgreSQL || db.driverName().startsWith("QODBC")) + tablenames << qTableName("task_233829", __FILE__, db); + + if (dbType == QSqlDriver::SQLite) + tablenames << qTableName("record_sqlite", __FILE__, db); + +- if (dbType == QSqlDriver::MSSqlServer || dbType == QSqlDriver::Oracle) ++ if (dbType == QSqlDriver::MSSqlServer || dbType == QSqlDriver::Oracle ++ || db.driverName().startsWith("QODBC")) + tablenames << qTableName("qtest_longstr", __FILE__, db); + + if (dbType == QSqlDriver::MSSqlServer) +@@ -400,18 +401,18 @@ + + if (dbType == QSqlDriver::PostgreSQL) { + QVERIFY_SQL(q, exec(QLatin1String( +- "create table %1 (id serial NOT NULL, t_varchar varchar(20), " +- "t_char char(20), primary key(id)) WITH OIDS").arg(qtest))); ++ "create table %1 (id serial NOT NULL, t_varchar Utf8, " ++ "t_char Utf8, primary key(id)) WITH OIDS").arg(qtest))); + } else { + QVERIFY_SQL(q, exec(QLatin1String( +- "create table %1 (id int %2 NOT NULL, t_varchar varchar(20), " +- "t_char char(20), primary key(id))") ++ "create table %1 (id int %2 NOT NULL, t_varchar Utf8, " ++ "t_char Utf8, primary key(id))") + .arg(qtest, tst_Databases::autoFieldName(db)))); + } + + QLatin1String creator(dbType == QSqlDriver::MSSqlServer || dbType == QSqlDriver::Sybase +- ? "create table %1 (id int null, t_varchar varchar(20) null)" +- : "create table %1 (id int, t_varchar varchar(20))"); ++ ? "create table %1 (id int null, t_varchar Utf8 null)" ++ : "create table %1 (id int, t_varchar Utf8, primary key (id))"); + QVERIFY_SQL(q, exec(creator.arg(qTableName("qtest_null", __FILE__, db)))); + } + +@@ -420,22 +421,22 @@ + QSqlQuery q(db); + const QString qtest_null(qTableName("qtest_null", __FILE__, db)); + q.exec("delete from " + qtest); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, 'VarChar1', 'Char1')") ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, t_varchar, t_char) values (1, 'VarChar1', 'Char1')") + .arg(qtest))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (2, 'VarChar2', 'Char2')") ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, t_varchar, t_char) values (2, 'VarChar2', 'Char2')") + .arg(qtest))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (3, 'VarChar3', 'Char3')") ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, t_varchar, t_char) values (3, 'VarChar3', 'Char3')") + .arg(qtest))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (4, 'VarChar4', 'Char4')") ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, t_varchar, t_char) values (4, 'VarChar4', 'Char4')") + .arg(qtest))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (5, 'VarChar5', 'Char5')") ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, t_varchar, t_char) values (5, 'VarChar5', 'Char5')") + .arg(qtest))); + + q.exec("delete from " + qtest_null); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (0, NULL)").arg(qtest_null))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, 'n')").arg(qtest_null))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (2, 'i')").arg(qtest_null))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (3, NULL)").arg(qtest_null))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, t_varchar) values (0, NULL)").arg(qtest_null))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, t_varchar) values (1, 'n')").arg(qtest_null))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, t_varchar) values (2, 'i')").arg(qtest_null))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, t_varchar) values (3, NULL)").arg(qtest_null))); + } + + // There were problems with char fields of size 1 +@@ -449,8 +450,8 @@ + QSqlQuery q(db); + const QString tbl = qTableName("char1Select", __FILE__, db); + q.exec("drop table " + tbl); +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id char(1))").arg(tbl))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values ('a')").arg(tbl))); ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id Utf8, primary key (id))").arg(tbl))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id) values ('a')").arg(tbl))); + QVERIFY_SQL(q, exec("select * from " + tbl)); + QVERIFY(q.next()); + if (tst_Databases::getDatabaseType(db) == QSqlDriver::Interbase) +@@ -486,21 +487,21 @@ + case QSqlDriver::DB2: + case QSqlDriver::Oracle: + case QSqlDriver::PostgreSQL: +- createQuery = QLatin1String("create table %1 (id char(3))"); ++ createQuery = QLatin1String("create table %1 (id Utf8, primary key (id))"); + break; + case QSqlDriver::Interbase: +- createQuery = QLatin1String("create table %1 (id char(1) character set unicode_fss)"); ++ createQuery = QLatin1String("create table %1 (id Utf8 character set unicode_fss)"); + break; + case QSqlDriver::MySqlServer: +- createQuery = QLatin1String("create table %1 (id char(1)) default character set 'utf8'"); ++ createQuery = QLatin1String("create table %1 (id Utf8) default character set 'utf8'"); + break; + default: +- createQuery = QLatin1String("create table %1 (id char(1))"); ++ createQuery = QLatin1String("create table %1 (id Utf8, primary key (id))"); + break; + } + + QVERIFY_SQL(q, exec(createQuery.arg(char1SelectUnicode))); +- QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(?)").arg(char1SelectUnicode))); ++ QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 (id) values(?)").arg(char1SelectUnicode))); + + q.bindValue(0, uniStr); + QVERIFY_SQL(q, exec()); +@@ -527,7 +528,7 @@ + QCOMPARE(q.value(0).metaType().id(), QMetaType::QString); + QVERIFY(!q.value(0).toString().isEmpty()); + +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id char(1))").arg(oraRowId))); ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id Utf8)").arg(oraRowId))); + + QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values('a')").arg(oraRowId))); + QVariant v1 = q.lastInsertId(); +@@ -562,7 +563,7 @@ + q.exec("drop function " + hello); + + QVERIFY_SQL(q, exec(QLatin1String( +- "create function %1 (s char(20)) returns varchar(50) " ++ "create function %1 (s Utf8) returns Utf8 " + "READS SQL DATA return concat('Hello ', s)").arg(hello))); + + QVERIFY_SQL(q, exec(QLatin1String("select %1('world')").arg(hello))); +@@ -616,8 +617,10 @@ + + q.exec("DROP TABLE " + tableName); + const bool useBooleanType = (dbType == QSqlDriver::PostgreSQL || dbType == QSqlDriver::Interbase); +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %2 (id INT, flag %1 NOT NULL, PRIMARY KEY(id))") +- .arg(QLatin1String(useBooleanType ? "BOOLEAN" : "INT"), tableName))); ++ const auto booleanType = db.driverName().startsWith("QODBC") ? "Bool" ++ : useBooleanType ? "BOOLEAN" : "INT"; ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %2 (id INT, flag %1, PRIMARY KEY(id))") ++ .arg(QLatin1String(booleanType), tableName))); + + for (int i = 0; i < 2; ++i) { + bool flag = i; +@@ -783,7 +786,7 @@ + QSqlQuery q(db); + + // Simple short string: +- QVERIFY_SQL(q, exec(QLatin1String("create table %1(id int primary key, cl clob, bl blob)") ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1(id Int32, cl Utf8, bl String, PRIMARY KEY (id))") + .arg(clobby))); + QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 (id, cl, bl) values(?, ?, ?)") + .arg(clobby))); +@@ -835,10 +838,10 @@ + const QString clobBatch(qTableName("clobBatch", __FILE__, db)); + tst_Databases::safeDropTables(db, { clobBatch }); + QSqlQuery q(db); +- QVERIFY_SQL(q, exec(QLatin1String("create table %1(cl clob)").arg(clobBatch))); ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1(fixture_key Int32, cl Utf8, PRIMARY KEY (fixture_key))").arg(clobBatch))); + + const QString longString(USHRT_MAX + 1, QLatin1Char('A')); +- QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 (cl) values(:cl)").arg(clobBatch))); ++ QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 (fixture_key, cl) values(0, :cl)").arg(clobBatch))); + const QVariantList vars = { longString }; + q.addBindValue(vars); + QVERIFY_SQL(q, execBatch()); +@@ -859,7 +862,7 @@ + const auto procName = qTableName("TESTPROC", __FILE__, db); + q.exec("drop procedure " + procName); + +- QVERIFY_SQL(q, exec(QLatin1String("create procedure %1 RETURNS (x integer, y varchar(20)) " ++ QVERIFY_SQL(q, exec(QLatin1String("create procedure %1 RETURNS (x integer, y Utf8) " + "AS BEGIN " + " x = 42; " + " y = 'Hello Anders'; " +@@ -900,7 +903,7 @@ + const QString procName = qTableName("tst_outValues", __FILE__, db); + q.exec("drop procedure " + procName); // non-fatal + QVERIFY_SQL(q, exec(QLatin1String("CREATE PROCEDURE %1 " +- "(OUT x int, OUT x2 double, OUT x3 char(20))\n" ++ "(OUT x int, OUT x2 double, OUT x3 Utf8)\n" + "LANGUAGE SQL\n" + "P1: BEGIN\n" + " SET x = 42;\n" +@@ -983,7 +986,8 @@ + QSqlDatabase db = QSqlDatabase::database(dbName); + CHECK_DATABASE(db); + +- if (!db.driver()->hasFeature(QSqlDriver::BLOB)) ++ if (!db.driver()->hasFeature(QSqlDriver::BLOB) ++ && !db.driverName().startsWith("QODBC")) + QSKIP("DBMS not BLOB capable"); + + // Don't make it too big otherwise sybase and mysql will complain: +@@ -995,8 +999,10 @@ + q.setForwardOnly(true); + const QString tableName = qTableName("qtest_blob", __FILE__, db); + +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int not null primary key, t_blob %2)") +- .arg(tableName, tst_Databases::blobTypeName(db, BLOBSIZE)))); ++ const auto blobType = db.driverName().startsWith("QODBC") ++ ? QStringLiteral("String") : tst_Databases::blobTypeName(db, BLOBSIZE); ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int, t_blob %2, primary key (id))") ++ .arg(tableName, blobType))); + + QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 (id, t_blob) values (?, ?)") + .arg(tableName))); +@@ -1060,10 +1066,10 @@ + + #define SETUP_RECORD_TABLE \ + do { \ +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id integer, extra varchar(50))") \ ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id integer, extra Utf8, primary key (id))") \ + .arg(tst_record))); \ + for (int i = 0; i < 3; ++i) \ +- QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 VALUES(%2, 'extra%2')") \ ++ QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (id, extra) VALUES(%2, 'extra%2')") \ + .arg(tst_record).arg(i))); \ + } while (0) + +@@ -1158,14 +1164,14 @@ + QVERIFY(!q.next()); + QVERIFY(q.isActive()); + +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (41, 'VarChar41', 'Char41')") ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, t_varchar, t_char) values (41, 'VarChar41', 'Char41')") + .arg(qtest))); + QVERIFY(q.isActive()); + +- QVERIFY_SQL(q, exec(QLatin1String("update %1 set id = 42 where id = 41").arg(qtest))); ++ QVERIFY_SQL(q, exec(QLatin1String("update %1 set t_char = 'Char42' where id = 41").arg(qtest))); + QVERIFY(q.isActive()); + +- QVERIFY_SQL(q, exec(QLatin1String("delete from %1 where id = 42").arg(qtest))); ++ QVERIFY_SQL(q, exec(QLatin1String("delete from %1 where id = 41").arg(qtest))); + QVERIFY(q.isActive()); + + QVERIFY_SQL(q, exec(QLatin1String("delete from %1 where id = 42").arg(qtest))); +@@ -1187,42 +1193,43 @@ + while (q.next()) + ++i; + +- if (q.numRowsAffected() == -1 || q.numRowsAffected() == 0) ++ if ((q.numRowsAffected() == -1 || q.numRowsAffected() == 0) ++ && !db.driverName().startsWith("QODBC")) + QSKIP("Database doesn't support numRowsAffected"); + + // Value is undefined for SELECT, this check is just here for curiosity: + if (q.numRowsAffected() != -1 && q.numRowsAffected() != 0 && q.numRowsAffected() != i) + qDebug("Expected numRowsAffected to be -1, 0 or %d, got %d", i, q.numRowsAffected()); + +- QVERIFY_SQL(q, exec(QLatin1String("update %1 set id = 100 where id = 1").arg(qtest))); ++ QVERIFY_SQL(q, exec(QLatin1String("update %1 set t_varchar = 'updated1' where id = 1").arg(qtest))); + + QCOMPARE(q.numRowsAffected(), 1); + QCOMPARE(q.numRowsAffected(), 1); // yes, we check twice + +- QVERIFY_SQL(q, exec(QLatin1String("update %1 set id = id + 100").arg(qtest))); ++ QVERIFY_SQL(q, exec(QLatin1String("update %1 set t_varchar = 'updated'").arg(qtest))); + QCOMPARE(q.numRowsAffected(), i); + QCOMPARE(q.numRowsAffected(), i); // yes, we check twice + +- QVERIFY_SQL(q, prepare(QLatin1String("update %1 set id = id + :newid").arg(qtest))); ++ QVERIFY_SQL(q, prepare(QLatin1String("update %1 set t_varchar = CAST(:newid AS Utf8)").arg(qtest))); + q.bindValue(":newid", 100); + QVERIFY_SQL(q, exec()); + QCOMPARE(q.numRowsAffected(), i); + QCOMPARE(q.numRowsAffected(), i); // yes, we check twice + +- QVERIFY_SQL(q, prepare(QLatin1String("update %1 set id = id + :newid where NOT(1 = 1)") ++ QVERIFY_SQL(q, prepare(QLatin1String("update %1 set t_varchar = CAST(:newid AS Utf8) where NOT(1 = 1)") + .arg(qtest))); + q.bindValue(":newid", 100); + QVERIFY_SQL(q, exec()); + QCOMPARE(q.numRowsAffected(), 0); + QCOMPARE(q.numRowsAffected(), 0); // yes, we check twice + +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (42000, 'homer', 'marge')") ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, t_varchar, t_char) values (42000, 'homer', 'marge')") + .arg(qtest))); + QCOMPARE(q.numRowsAffected(), 1); + QCOMPARE(q.numRowsAffected(), 1); // yes, we check twice + + QSqlQuery q2(db); +- QVERIFY_SQL(q2, exec(QLatin1String("insert into %1 values (42001, 'homer', 'marge')") ++ QVERIFY_SQL(q2, exec(QLatin1String("insert into %1 (id, t_varchar, t_char) values (42001, 'homer', 'marge')") + .arg(qtest))); + + if (!db.driverName().startsWith("QSQLITE2")) { +@@ -1264,7 +1271,7 @@ + + q2.clear(); + +- QVERIFY_SQL(q, exec(QLatin1String("update %1 set id = 100 where id = 1").arg(qtest))); ++ QVERIFY_SQL(q, exec(QLatin1String("update %1 set t_varchar = 'updated' where id = 1").arg(qtest))); + QCOMPARE(q.size(), -1); + QCOMPARE(q.size(), -1); // yes, twice + } +@@ -1279,7 +1286,7 @@ + QVERIFY_SQL(q, exec("select * from " + qtest)); + QVERIFY(q.isSelect()); + +- QVERIFY_SQL(q, exec(QLatin1String("update %1 set id = 1 where id = 1").arg(qtest))); ++ QVERIFY_SQL(q, exec(QLatin1String("update %1 set t_varchar = 'updated' where id = 1").arg(qtest))); + QVERIFY(!q.isSelect()); + } + +@@ -1791,11 +1798,11 @@ + // cases from the QSqlResultPrivate::isVariantNull helper. Only PostgreSQL supports + // QUuid. + QMultiHash nullableTypes = { +- {"varchar(20)", u"not null"_s}, +- {"varchar(20)", "not null"_ba}, +- {"date", QDateTime::currentDateTime()}, +- {"date", QDate::currentDate()}, +- {"date", QTime::currentTime()}, ++ {"Utf8", u"not null"_s}, ++ {"String", "not null"_ba}, ++ {"Timestamp", QDateTime::currentDateTime()}, ++ {"Date", QDate::currentDate()}, ++ {"Datetime", QTime::currentTime()}, + }; + if (dbType == QSqlDriver::PostgreSQL) + nullableTypes["uuid"] = QUuid::createUuid(); +@@ -1822,7 +1829,7 @@ + while (q.next()) + qWarning() << q.value(0) << q.value(1); + }); +- QString createQuery = QLatin1String("create table %3 (id int, data %1%2)") ++ QString createQuery = QLatin1String("create table %3 (id int, data %1%2, primary key (id))") + .arg(nullableType, + dbType == QSqlDriver::MSSqlServer || dbType == QSqlDriver::Sybase ? " null" : "", + tableName); +@@ -1830,14 +1837,14 @@ + + int expectedNullCount = 0; + // Verify that inserting a non-null value works: +- QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(:id, :data)").arg(tableName))); ++ QVERIFY_SQL(q, prepare(db.driverName().startsWith("QODBC") ? QString("insert into %1 (id, data) values(:id, CAST(:data AS %2))").arg(tableName, nullableType) : QString("insert into %1 (id, data) values(:id, :data)").arg(tableName))); + q.bindValue(":id", expectedNullCount); + q.bindValue(":data", nonNullValue); + QVERIFY_SQL(q, exec()); + QCOMPARE(countRowsWithNull(), expectedNullCount); + + // Verify that inserting using a null QVariant produces a null entry in the database: +- QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(:id, :data)").arg(tableName))); ++ QVERIFY_SQL(q, prepare(db.driverName().startsWith("QODBC") ? QString("insert into %1 (id, data) values(:id, CAST(:data AS %2))").arg(tableName, nullableType) : QString("insert into %1 (id, data) values(:id, :data)").arg(tableName))); + q.bindValue(":id", ++expectedNullCount); + q.bindValue(":data", QVariant()); + QVERIFY_SQL(q, exec()); +@@ -1856,7 +1863,7 @@ + const QVariant nullValueVariant(nullableMetaType, defaultData); + QVERIFY(!nullValueVariant.isNull()); + +- QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values(:id, :data)").arg(tableName))); ++ QVERIFY_SQL(q, prepare(db.driverName().startsWith("QODBC") ? QString("insert into %1 (id, data) values(:id, CAST(:data AS %2))").arg(tableName, nullableType) : QString("insert into %1 (id, data) values(:id, :data)").arg(tableName))); + q.bindValue(":id", ++expectedNullCount); + q.bindValue(":data", nullValueVariant); + QVERIFY_SQL(q, exec()); +@@ -1876,10 +1883,10 @@ + const QString tableName = qTableName("qtest_bittest", __FILE__, db); + QSqlQuery q(db); + +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (bitty bit)").arg(tableName))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (0)").arg(tableName))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1)").arg(tableName))); +- QVERIFY_SQL(q, exec("select bitty from " + tableName)); ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (fixture_key Int32, bitty Bool, PRIMARY KEY (fixture_key))").arg(tableName))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (fixture_key, bitty) values (0, false)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (fixture_key, bitty) values (1, true)").arg(tableName))); ++ QVERIFY_SQL(q, exec("select bitty from " + tableName + " ORDER BY fixture_key")); + + QVERIFY(q.next()); + QCOMPARE(q.value(0).toInt(), 0); +@@ -1897,16 +1904,16 @@ + const QString qtest_nullblob(qTableName("qtest_nullblob", __FILE__, db)); + + QSqlQuery q(db); +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int primary key, bb blob)") ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id Int32, bb String, PRIMARY KEY (id))") + .arg(qtest_nullblob))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (0, EMPTY_BLOB())") ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, bb) values (0, ''s)") + .arg(qtest_nullblob))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, NULL)").arg(qtest_nullblob))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (2, 'aabbcc00112233445566')") ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, bb) values (1, NULL)").arg(qtest_nullblob))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, bb) values (2, String::HexDecode('aabbcc00112233445566'))") + .arg(qtest_nullblob))); + // Necessary otherwise Oracle will bombard you with internal errors: + q.setForwardOnly(true); +- QVERIFY_SQL(q, exec(QLatin1String("select * from %1 order by id").arg(qtest_nullblob))); ++ QVERIFY_SQL(q, exec(QLatin1String("select id, bb from %1 order by id").arg(qtest_nullblob))); + + QVERIFY(q.next()); + QVERIFY(q.value(1).toByteArray().isEmpty()); +@@ -1931,9 +1938,9 @@ + + QSqlQuery q(db); + q.setForwardOnly(true); +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int, col raw(20))").arg(qtest_rawtest))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (0, NULL)").arg(qtest_rawtest))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, '00aa1100ddeeff')") ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id Int32, col String, PRIMARY KEY (id))").arg(qtest_rawtest))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, col) values (0, NULL)").arg(qtest_rawtest))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, col) values (1, String::HexDecode('00aa1100ddeeff'))") + .arg(qtest_rawtest))); + QVERIFY_SQL(q, exec(QLatin1String("select col from %1 order by id").arg(qtest_rawtest))); + QVERIFY(q.next()); +@@ -1971,12 +1978,12 @@ + q.exec("drop table " + qtest_precision); + QVERIFY_SQL(q, exec(QLatin1String(tst_Databases::isMSAccess(db) + ? "CREATE TABLE %1 (col1 number)" +- : "CREATE TABLE %1 (col1 numeric(21, 20))") ++ : "CREATE TABLE %1 (pk int, col1 Decimal(21, 20), primary key (pk))") + .arg(qtest_precision))); + +- QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (col1) VALUES (%2)") ++ QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (pk, col1) VALUES (1, Decimal('%2's, 21, 20))") + .arg(qtest_precision, precStr))); +- QVERIFY_SQL(q, exec("SELECT * FROM " + qtest_precision)); ++ QVERIFY_SQL(q, exec("SELECT col1 FROM " + qtest_precision)); + QVERIFY(q.next()); + const QString val = q.value(0).toString(); + if (!val.startsWith(precStr)) { +@@ -2104,25 +2111,26 @@ + const QString qtestj2(qTableName("qtestj2", __FILE__, db)); + + if (dbType == QSqlDriver::Oracle || dbType == QSqlDriver::Sybase +- || dbType == QSqlDriver::Interbase || db.driverName().startsWith("QODBC")) { ++ || dbType == QSqlDriver::Interbase) { + // Oracle broken beyond recognition - cannot outer join on more than one table: + QSKIP("DBMS cannot understand standard SQL"); + } + + QSqlQuery q(db); + +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id1 int, id2 int)").arg(qtestj1))); +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int, name varchar(20))").arg(qtestj2))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, 1)").arg(qtestj1))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values (1, 2)").arg(qtestj1))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values(1, 'trenton')").arg(qtestj2))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 values(2, 'marius')").arg(qtestj2))); ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id1 int, id2 int, primary key (id1, id2))").arg(qtestj1))); ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int, name Utf8, primary key (id))").arg(qtestj2))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id1, id2) values (1, 1)").arg(qtestj1))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id1, id2) values (1, 2)").arg(qtestj1))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, name) values(1, 'trenton')").arg(qtestj2))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (id, name) values(2, 'marius')").arg(qtestj2))); + + QVERIFY_SQL(q, exec(QLatin1String( + "select qtestj1.id1, qtestj1.id2, qtestj2.id, qtestj2.name, " + "qtestj3.id, qtestj3.name from %1 qtestj1 left outer join %2 qtestj2 " + "on (qtestj1.id1 = qtestj2.id) left outer join %2 as qtestj3 " +- "on (qtestj1.id2 = qtestj3.id)").arg(qtestj1, qtestj2))); ++ "on (qtestj1.id2 = qtestj3.id) order by qtestj1.id1, qtestj1.id2") ++ .arg(qtestj1, qtestj2))); + + QVERIFY(q.next()); + QCOMPARE(q.value(0).toInt(), 1); +@@ -2193,20 +2201,20 @@ + switch (dbType) { + case QSqlDriver::MSSqlServer: + case QSqlDriver::Sybase: +- createQuery = QLatin1String("create table %1 (id int primary key, " +- "name nvarchar(200) null, name2 nvarchar(200) null)"); ++ createQuery = QLatin1String("create table %1 (id int, " ++ "name nvarchar(200) null, name2 nvarchar(200) null, primary key (id))"); + break; + case QSqlDriver::MySqlServer: + if (useUnicode) { +- createQuery = QLatin1String("create table %1 (id int not null primary key, " +- "name varchar(200) character set utf8, " +- "name2 varchar(200) character set utf8)"); ++ createQuery = QLatin1String("create table %1 (id int, " ++ "name Utf8 character set utf8, " ++ "name2 Utf8 character set utf8, primary key (id))"); + break; + } + Q_FALLTHROUGH(); + default: +- createQuery = QLatin1String("create table %1 (id int not null primary key, " +- "name varchar(200), name2 varchar(200))"); ++ createQuery = QLatin1String("create table %1 (id int, " ++ "name Utf8, name2 Utf8, primary key (id))"); + break; + } + +@@ -2444,8 +2452,9 @@ + + // Test that duplicated named placeholders before the next unique one + // works correctly - QTBUG-65150 +- QVERIFY(q.prepare(QLatin1String("insert into %1 (id, name, name2) values (:id, :id, :name)") +- .arg(qtest_prepare))); ++ QVERIFY(q.prepare(QLatin1String(db.driverName().startsWith("QODBC") ++ ? "insert into %1 (id, name, name2) values (:id, CAST(:id AS Utf8), :name)" ++ : "insert into %1 (id, name, name2) values (:id, :id, :name)").arg(qtest_prepare))); + for (i = 104; i < 106; ++i) { + q.bindValue(":id", i); + q.bindValue(":name", "name"); +@@ -2459,8 +2468,9 @@ + QCOMPARE(q.value(2).toString(), u"name"); + + // Test that duplicated named placeholders in any order +- QVERIFY(q.prepare(QLatin1String("insert into %1 (id, name, name2) values (:id, :name, :id)") +- .arg(qtest_prepare))); ++ QVERIFY(q.prepare(QLatin1String(db.driverName().startsWith("QODBC") ++ ? "insert into %1 (id, name, name2) values (:id, :name, CAST(:id AS Utf8))" ++ : "insert into %1 (id, name, name2) values (:id, :name, :id)").arg(qtest_prepare))); + for (i = 107; i < 109; ++i) { + q.bindValue(":id", i); + q.bindValue(":name", "name"); +@@ -2527,15 +2537,17 @@ + QFETCH(QString, dbName); + QSqlDatabase db = QSqlDatabase::database(dbName); + CHECK_DATABASE(db); +- if (tst_Databases::getDatabaseType(db) != QSqlDriver::MSSqlServer) ++ if (tst_Databases::getDatabaseType(db) != QSqlDriver::MSSqlServer ++ && !db.driverName().startsWith("QODBC")) + QSKIP("Test is specific to SQL Server"); + + QSqlQuery q(db); + const QString tableName = qTableName("qtest_longstr", __FILE__, db); +- +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id int primary key, longstring ntext)") ++ tst_Databases::safeDropTable(db, tableName); ++ ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id int, longstring Utf8, primary key (id))") + .arg(tableName))); +- QVERIFY_SQL(q, prepare(QLatin1String("INSERT INTO %1 VALUES (?, ?)").arg(tableName))); ++ QVERIFY_SQL(q, prepare(QLatin1String("INSERT INTO %1 (id, longstring) VALUES (?, ?)").arg(tableName))); + + q.addBindValue(0); + q.addBindValue(u"bubu"_s); +@@ -2546,7 +2558,7 @@ + q.addBindValue(1); + q.addBindValue(testStr); + QVERIFY_SQL(q, exec()); +- QVERIFY_SQL(q, exec("select * from " + tableName)); ++ QVERIFY_SQL(q, exec("select * from " + tableName + " order by id")); + + QVERIFY_SQL(q, next()); + QCOMPARE(q.value(0).toInt(), 0); +@@ -2595,13 +2607,15 @@ + tst_Databases::safeDropTable(db, tableName); + + const auto dbType = tst_Databases::getDatabaseType(db); +- QLatin1String timeStampString(dbType == QSqlDriver::Interbase ? "TIMESTAMP" : "TIMESTAMP (3)"); ++ QLatin1String timeStampString(db.driverName().startsWith("QODBC") ? "Timestamp" ++ : dbType == QSqlDriver::Interbase ? "TIMESTAMP" : "TIMESTAMP (3)"); + + QVERIFY_SQL(q, exec(QLatin1String( +- "create table %2 (id int, name varchar(20), dt date, " +- "num numeric(8, 4), dtstamp %1, extraId int, extraName varchar(20))") ++ "create table %2 (pk int, id int, name Utf8, dt date, " ++ "num Double, dtstamp %1, extraId int, extraName Utf8, primary key (pk))") + .arg(timeStampString, tableName))); + ++ const QVariantList keyCol = { 1, 2, 3 }; + const QVariantList intCol = { 1, 2, QVariant(QMetaType(QMetaType::Int)) }; + const QVariantList charCol = { u"harald"_s, u"boris"_s, + QVariant(QMetaType(QMetaType::QString)) }; +@@ -2614,8 +2628,9 @@ + + // Test with positional placeholders + QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 " +- "(id, name, dt, num, dtstamp, extraId, extraName) " +- "values (?, ?, ?, ?, ?, ?, ?)").arg(tableName))); ++ "(pk, id, name, dt, num, dtstamp, extraId, extraName) " ++ "values (?, ?, ?, ?, ?, ?, ?, ?)").arg(tableName))); ++ q.addBindValue(keyCol); + q.addBindValue(intCol); + q.addBindValue(charCol); + q.addBindValue(dateCol); +@@ -2647,9 +2662,10 @@ + // Empty table ready for retesting with duplicated named placeholders + QVERIFY_SQL(q, exec(QLatin1String("delete from ") + tableName)); + QVERIFY_SQL(q, prepare(QLatin1String( +- "insert into %1 (id, name, dt, num, dtstamp, extraId, extraName) " +- "values (:id, :name, :dt, :num, :dtstamp, :id, :name)") ++ "insert into %1 (pk, id, name, dt, num, dtstamp, extraId, extraName) " ++ "values (:pk, :id, :name, :dt, :num, :dtstamp, :id, :name)") + .arg(tableName))); ++ q.bindValue(":pk", keyCol); + q.bindValue(":id", intCol); + q.bindValue(":name", charCol); + q.bindValue(":dt", dateCol); +@@ -2707,7 +2723,7 @@ + QSqlQuery q(db); + const QString tableName = qTableName("bug43874", __FILE__, db); + +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id INT)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id INT, primary key (id))").arg(tableName))); + QVERIFY_SQL(q, prepare(QLatin1String("INSERT INTO %1 (id) VALUES (?)").arg(tableName))); + + for (int i = 0; i < 2; ++i) { +@@ -2737,7 +2753,7 @@ + + QVERIFY_SQL(q, exec("CREATE OR REPLACE PACKAGE ora_array_test " + "IS TYPE names_type IS " +- "TABLE OF VARCHAR(64) NOT NULL INDEX BY BINARY_INTEGER; " ++ "TABLE OF Utf8 INDEX BY BINARY_INTEGER; " + "names_tab names_type; " + "PROCEDURE set_name(name_in IN VARCHAR2, row_in in INTEGER); " + "PROCEDURE get_name(row_in IN INTEGER, str_out OUT VARCHAR2); " +@@ -2814,7 +2830,7 @@ + const QString tableName = qTableName("record_sqlite", __FILE__, db); + + QVERIFY_SQL(q, exec(QLatin1String( +- "create table %1(id integer primary key, name varchar, title int)") ++ "create table %1(id Int32, name Utf8, title Int32, primary key (id))") + .arg(tableName))); + + QSqlRecord rec = db.record(tableName); +@@ -2845,7 +2861,7 @@ + QString aLotOfText(127000, QLatin1Char('H')); + const QString tableName = qTableName("qtest_longstr", __FILE__, db); + +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int primary key, astr long)") ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id Int32, astr Utf8, PRIMARY KEY (id))") + .arg(tableName))); + QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 (id, astr) values (?, ?)") + .arg(tableName))); +@@ -2870,8 +2886,8 @@ + + const QString tbl = qTableName("qtest_exerr", __FILE__, db); + q.exec("drop table " + tbl); +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int not null primary key)").arg(tbl))); +- QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 values (?)").arg(tbl))); ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id int, primary key (id))").arg(tbl))); ++ QVERIFY_SQL(q, prepare(QLatin1String("insert into %1 (id) values (?)").arg(tbl))); + + q.addBindValue(1); + QVERIFY_SQL(q, exec()); +@@ -2931,7 +2947,7 @@ + const auto tst_lastInsertId = qTableName("tst_lastInsertId", __FILE__, db); + tst_Databases::safeDropTable(db, tst_lastInsertId); + QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id serial not null, t_varchar " +- "varchar(20), t_char char(20), primary key(id))") ++ "Utf8, t_char Utf8, primary key(id))") + .arg(tst_lastInsertId))); + QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (t_varchar, t_char) values " + "('VarChar41', 'Char41')").arg(tst_lastInsertId))); +@@ -3019,8 +3035,7 @@ + CHECK_DATABASE(db); + QSqlQuery query(db); + const QString tableName = qTableName("floattest", __FILE__, db); +- QVERIFY_SQL(query, exec(QLatin1String("create table %1 (value float)").arg(tableName))); +- QVERIFY_SQL(query, prepare(QLatin1String("insert into %1 values(:value)").arg(tableName))); ++ QVERIFY_SQL(query, exec(QLatin1String("create table %1 (fixture_key Int32, value Double, PRIMARY KEY (fixture_key))").arg(tableName))); + + const QVariant data[] = { + QVariant(double(42.42)), +@@ -3031,7 +3046,9 @@ + QVariant(std::numeric_limits::infinity()), + }; + ++ int fixtureKey = 0; + for (const QVariant &v : data) { ++ QVERIFY_SQL(query, prepare(QLatin1String("insert into %1 (fixture_key, value) values(%2, :value)").arg(tableName).arg(fixtureKey++))); + query.bindValue(":value", v); + QVERIFY_SQL(query, exec()); + } +@@ -3084,7 +3101,8 @@ + // Only supported by these drivers + + if (dbType != QSqlDriver::PostgreSQL && dbType != QSqlDriver::Oracle +- && dbType != QSqlDriver::MySqlServer && dbType != QSqlDriver::DB2) { ++ && dbType != QSqlDriver::MySqlServer && dbType != QSqlDriver::DB2 ++ && !db.driverName().startsWith("QODBC")) { + QSKIP("Test is specific for PostgreSQL, Oracle, MySql and DB2"); + } + +@@ -3190,7 +3208,7 @@ + QSqlQuery q(db); + + tst_Databases::safeDropTable(db, tableName); +- q.exec(QLatin1String("CREATE TABLE %1 (pk_id INTEGER PRIMARY KEY, whatever TEXT)") ++ q.exec(QLatin1String("CREATE TABLE %1 (pk_id INTEGER, whatever TEXT, primary key (pk_id))") + .arg(tableName)); + q.exec(QLatin1String("INSERT INTO %1 values(1, 'whatever')").arg(tableName)); + q.exec(QLatin1String("INSERT INTO %1 values(2, 'whatever more')").arg(tableName)); +@@ -3225,14 +3243,14 @@ + const QString tableName(qTableName("more_results", __FILE__, db)); + + QVERIFY_SQL(q, exec(QLatin1String( +- "CREATE TABLE %1 (id integer, text varchar(20), " +- "num numeric(6, 3), empty varchar(10));").arg(tableName))); +- +- QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 VALUES(1, 'one', 1.1, '');").arg(tableName))); +- QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 VALUES(2, 'two', 2.2, '');").arg(tableName))); +- QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 VALUES(3, 'three', 3.3, '');") ++ "CREATE TABLE %1 (id integer, text Utf8, " ++ "num Double, empty Utf8, primary key (id));").arg(tableName))); ++ ++ QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (id, text, num, empty) VALUES(1, 'one', 1.1, '');").arg(tableName))); ++ QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (id, text, num, empty) VALUES(2, 'two', 2.2, '');").arg(tableName))); ++ QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (id, text, num, empty) VALUES(3, 'three', 3.3, '');") + .arg(tableName))); +- QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 VALUES(4, 'four', 4.4, '');") ++ QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (id, text, num, empty) VALUES(4, 'four', 4.4, '');") + .arg(tableName))); + + const QString tstStrings[] = { u"one"_s, u"two"_s, u"three"_s, u"four"_s }; +@@ -3444,7 +3462,8 @@ + QSqlDatabase db = QSqlDatabase::database(dbName); + CHECK_DATABASE(db); + +- if (!db.driver()->hasFeature(QSqlDriver::BLOB) ++ if ((!db.driver()->hasFeature(QSqlDriver::BLOB) ++ && !db.driverName().startsWith("QODBC")) + || !db.driver()->hasFeature(QSqlDriver::PreparedQueries)) { + QSKIP("DBMS does not support BLOBs or prepared queries"); + } +@@ -3459,10 +3478,11 @@ + // In PostgreSQL a BLOB is not called a BLOB, but a BYTEA! :-) + // ... and in SQL Server it can be called a lot, but IMAGE will do. + QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db); +- const QLatin1String typeName(dbType == QSqlDriver::PostgreSQL ? "BYTEA" ++ const QLatin1String typeName(db.driverName().startsWith("QODBC") ? "String" ++ : dbType == QSqlDriver::PostgreSQL ? "BYTEA" + : dbType == QSqlDriver::MSSqlServer ? "IMAGE" : "BLOB"); + +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1(id INTEGER, data %2)") ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1(id INTEGER, data %2, primary key (id))") + .arg(tableName, typeName))); + q.prepare(QLatin1String("INSERT INTO %1(id, data) VALUES(:id, :data)").arg(tableName)); + q.bindValue(":id", 1); +@@ -3505,7 +3525,7 @@ + QSqlQuery q(db); + const QString tbl = qTableName("qtest_empty", __FILE__, db); + q.exec("drop table " + tbl); +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id char(10))").arg(tbl))); ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (id Utf8, primary key (id))").arg(tbl))); + QVERIFY_SQL(q, prepare("select * from " + tbl)); + QVERIFY_SQL(q, exec()); + QVERIFY(!q.next()); +@@ -3528,7 +3548,7 @@ + "datefield timestamp, primary key(id));"); + break; + case QSqlDriver::MySqlServer: +- creator = QLatin1String("CREATE TABLE %1(id integer NOT NULL AUTO_INCREMENT, " ++ creator = QLatin1String("CREATE TABLE %1(id integer AUTO_INCREMENT, " + "datefield timestamp, primary key(id));"); + break; + case QSqlDriver::Interbase: +@@ -3536,15 +3556,19 @@ + creator = QLatin1String("CREATE TABLE %1(id integer, datefield timestamp);"); + break; + default: +- creator = QLatin1String("CREATE TABLE %1(" +- "\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, " +- "\"datefield\" timestamp);"); ++ creator = db.driverName().startsWith("QODBC") ++ ? QLatin1String("CREATE TABLE %1(id integer, datefield Timestamp, primary key (id));") ++ : QLatin1String("CREATE TABLE %1(" ++ "\"id\" integer AUTOINCREMENT, " ++ "\"datefield\" timestamp, primary key (\"id\"));"); + break; + } + QVERIFY_SQL(q, exec(creator.arg(tableName))); +- QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (datefield) VALUES (current_timestamp);") +- .arg(tableName))); +- QVERIFY_SQL(q, exec(QLatin1String("SELECT * FROM ") + tableName)); ++ const auto now = db.driverName().startsWith("QODBC") ? "CurrentUtcTimestamp()" ++ : "current_timestamp"; ++ QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (id, datefield) VALUES (1, %2);") ++ .arg(tableName, now))); ++ QVERIFY_SQL(q, exec(QLatin1String("SELECT id, datefield FROM ") + tableName)); + while (q.next()) + QVERIFY(q.value(1).toDateTime().isValid()); + } +@@ -3558,18 +3582,18 @@ + const QString planets = qTableName("Planet", __FILE__, db); + + q.exec("drop table " + planets); +- QVERIFY_SQL(q, exec(QLatin1String("create table %1 (Name varchar(20))").arg(planets))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 VALUES ('Mercury')").arg(planets))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 VALUES ('Venus')").arg(planets))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 VALUES ('Earth')").arg(planets))); +- QVERIFY_SQL(q, exec(QLatin1String("insert into %1 VALUES ('Mars')").arg(planets))); +- +- QVERIFY_SQL(q, exec("SELECT Name FROM " + planets)); ++ QVERIFY_SQL(q, exec(QLatin1String("create table %1 (Id integer, Name Utf8, primary key (Id))").arg(planets))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (Id, Name) VALUES (1, 'Mercury')").arg(planets))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (Id, Name) VALUES (2, 'Venus')").arg(planets))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (Id, Name) VALUES (3, 'Earth')").arg(planets))); ++ QVERIFY_SQL(q, exec(QLatin1String("insert into %1 (Id, Name) VALUES (4, 'Mars')").arg(planets))); ++ ++ QVERIFY_SQL(q, exec("SELECT Name FROM " + planets + " ORDER BY Id")); + QVERIFY_SQL(q, seek(3)); + QCOMPARE(q.value(0).toString(), u"Mars"); + QVERIFY_SQL(q, seek(1)); + QCOMPARE(q.value(0).toString(), u"Venus"); +- QVERIFY_SQL(q, exec("SELECT Name FROM " + planets)); ++ QVERIFY_SQL(q, exec("SELECT Name FROM " + planets + " ORDER BY Id")); + QVERIFY_SQL(q, seek(3)); + QCOMPARE(q.value(0).toString(), u"Mars"); + QVERIFY_SQL(q, seek(0)); +@@ -3587,7 +3611,7 @@ + + const QString tableName(qTableName("task_250026", __FILE__, db)); + +- if (!q.exec(QLatin1String("create table %1 (longfield varchar(1100))").arg(tableName))) { ++ if (!q.exec(QLatin1String("create table %1 (longfield Utf8, primary key (longfield))").arg(tableName))) { + qDebug() << "Error" << q.lastError(); + QSKIP("Db doesn't support \"1100\" as a size for fields"); + } +@@ -3630,10 +3654,10 @@ + QSqlQuery q(db); + const QString tableName(qTableName("task_233829", __FILE__, db)); + QVERIFY_SQL(q, exec(QLatin1String( +- "CREATE TABLE %1(dbl1 double precision,dbl2 double precision) " +- "without oids;").arg(tableName))); ++ "CREATE TABLE %1(fixture_key Int32, dbl1 Double, dbl2 Double, PRIMARY KEY (fixture_key))" ++ ";").arg(tableName))); + const QString queryString = +- QLatin1String("INSERT INTO %1(dbl1, dbl2) VALUES(?,?)").arg(tableName); ++ QLatin1String("INSERT INTO %1(fixture_key, dbl1, dbl2) VALUES(0,?,?)").arg(tableName); + + const double nan = qQNaN(); + QVERIFY_SQL(q, prepare(queryString)); +@@ -3652,7 +3676,7 @@ + + QSqlQuery q(db); + QVERIFY_SQL(q, exec("SELECT 1::bit, '10101010000111101101'::varbit, " +- "'10101111011'::varbit(15), '22222.20'::numeric(16,2), " ++ "'10101111011'::varbit(15), '22222.20'::Double, " + "'333333'::numeric(18), '444444'::numeric")); + QVERIFY_SQL(q, next()); + QSqlRecord r = q.record(); +@@ -3867,7 +3891,7 @@ + const QString tableName(qTableName("bug6421", __FILE__, db).toUpper()); + + QVERIFY_SQL(q, exec(QLatin1String( +- "create table %1(COL1 char(10), COL2 char(10), COL3 char(10))") ++ "create table %1(COL1 Utf8, COL2 Utf8, COL3 Utf8)") + .arg(tableName))); + QVERIFY_SQL(q, exec(QLatin1String("create index INDEX1 on %1 (COL1 desc)").arg(tableName))); + QVERIFY_SQL(q, exec(QLatin1String("create index INDEX2 on %1 (COL2 desc)").arg(tableName))); +@@ -3889,21 +3913,36 @@ + QFETCH(QString, dbName); + QSqlDatabase db = QSqlDatabase::database(dbName); + CHECK_DATABASE(db); +- if (tst_Databases::getDatabaseType(db) != QSqlDriver::MSSqlServer) ++ if (tst_Databases::getDatabaseType(db) != QSqlDriver::MSSqlServer ++ && !db.driverName().startsWith("QODBC")) + QSKIP("Test is specific to SQL Server"); + + QSqlQuery q(db); + const QString procedureName = qTableName("tst_raiseError", __FILE__, db); +- q.exec("drop procedure " + procedureName); // non-fatal ++ const bool nativeErrorFixture = db.driverName().startsWith("QODBC"); ++ q.exec((nativeErrorFixture ? "DROP TABLE IF EXISTS " : "drop procedure ") + procedureName); // non-fatal ++ const auto fixtureCleanup = qScopeGuard([&]() { ++ if (nativeErrorFixture) ++ tst_Databases::safeDropTable(db, procedureName); ++ }); + QString errorString; + for (int i = 0; i < 110; ++i) + errorString += "reallylong"; + errorString += " error"; +- QVERIFY_SQL(q, exec(QLatin1String("create procedure %1 as\n" +- "begin\n" +- " raiserror('%2', 16, 1)\n" +- "end\n").arg(procedureName, errorString))); +- q.exec(QLatin1String("{call %1}").arg(procedureName)); ++ const QString setup = nativeErrorFixture ++ ? QLatin1String("CREATE TABLE %1 (id Int32, message Utf8, PRIMARY KEY (id))").arg(procedureName) ++ : QLatin1String("create procedure %1 as\n" ++ "begin\n" ++ " raiserror('%2', 16, 1)\n" ++ "end\n").arg(procedureName, errorString); ++ QVERIFY_SQL(q, exec(setup)); ++ if (nativeErrorFixture) { ++ QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (id, message) VALUES (0, '%2')") ++ .arg(procedureName, errorString))); ++ } ++ q.exec(nativeErrorFixture ++ ? QLatin1String("UPDATE %1 SET message = Ensure(message, false, COALESCE(CAST(message AS String), ''s)) WHERE id = 0").arg(procedureName) ++ : QLatin1String("{call %1}").arg(procedureName)); + QVERIFY(q.lastError().text().contains(errorString)); + } + +@@ -3918,8 +3957,8 @@ + + QVERIFY_SQL(q, exec("DROP PROCEDURE IF EXISTS " + procName)); + QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1(\n" +- "MainKey INT NOT NULL,\n" +- "OtherTextCol VARCHAR(45) NOT NULL,\n" ++ "MainKey INT,\n" ++ "OtherTextCol Utf8,\n" + "PRIMARY KEY(`MainKey`))").arg(tableName))); + QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 VALUES(0, \"Disabled\")").arg(tableName))); + QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 VALUES(5, \"Error Only\")").arg(tableName))); +@@ -3947,16 +3986,16 @@ + QSqlQuery q(db); + const QString tableName(qTableName("bug5765", __FILE__, db)); + +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1(testval TINYINT(1) DEFAULT 0)") ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1(testval Int8, PRIMARY KEY (testval))") + .arg(tableName))); +- q.prepare(QLatin1String("INSERT INTO %1 SET testval = :VALUE").arg(tableName)); ++ q.prepare(QLatin1String("INSERT INTO %1 (testval) VALUES (CAST(:VALUE AS Int8))").arg(tableName)); + q.bindValue(":VALUE", 1); + QVERIFY_SQL(q, exec()); + q.bindValue(":VALUE", 12); + QVERIFY_SQL(q, exec()); + q.bindValue(":VALUE", 123); + QVERIFY_SQL(q, exec()); +- QString sql = "select testval from " + tableName; ++ QString sql = "select testval from " + tableName + " ORDER BY testval"; + QVERIFY_SQL(q, exec(sql)); + QVERIFY_SQL(q, next()); + QCOMPARE(q.value(0).toInt(), 1); +@@ -3989,7 +4028,7 @@ + + { + const QString good[] = { +- QLatin1String("create table %1(id integer primary key, note string)").arg(tableName), ++ QLatin1String("create table %1(id integer, note string, primary key (id))").arg(tableName), + QLatin1String("select * from %1;").arg(tableName), + QLatin1String("select * from %1; \t\n\r").arg(tableName), + QLatin1String("drop table %1").arg(tableName) +@@ -4006,10 +4045,10 @@ + + { + const QString bad[] = { +- QLatin1String("create table %1(id integer primary key); select * from ").arg(tableName), +- QLatin1String("create table %1(id integer primary key); syntax error!;").arg(tableName), +- QLatin1String("create table %1(id integer primary key);;").arg(tableName), +- QLatin1String("create table %1(id integer primary key);\'\"\a\b\b\v").arg(tableName) ++ QLatin1String("create table %1(id integer, primary key (id)); select * from ").arg(tableName), ++ QLatin1String("create table %1(id integer, primary key (id)); syntax error!;").arg(tableName), ++ QLatin1String("create table %1(id integer, primary key (id));;").arg(tableName), ++ QLatin1String("create table %1(id integer, primary key (id));\'\"\a\b\b\v").arg(tableName) + }; + + QLatin1String shouldFail("the statement is expected to fail! %1"); +@@ -4040,7 +4079,7 @@ + CHECK_DATABASE(db); + QSqlQuery q(db); + q2 = q; +- q.prepare("CREATE TABLE t1 (id INTEGER PRIMARY KEY, str TEXT);"); ++ q.prepare("CREATE TABLE t1 (id INTEGER, str TEXT, primary key (id));"); + db.close(); + QCOMPARE(db.lastError().type(), QSqlError::NoError); + } +@@ -4049,7 +4088,7 @@ + CHECK_DATABASE(db); + QSqlQuery q(db); + q2 = q; +- q2.prepare("CREATE TABLE t1 (id INTEGER PRIMARY KEY, str TEXT);"); ++ q2.prepare("CREATE TABLE t1 (id INTEGER, str TEXT, primary key (id));"); + q2.exec(); + db.close(); + QCOMPARE(db.lastError().type(), QSqlError::NoError); +@@ -4059,7 +4098,7 @@ + CHECK_DATABASE(db); + QSqlQuery q(db); + q2 = q; +- q.exec("INSERT INTO t1 (id, str) VALUES(1, \"test1\");"); ++ q.exec("INSERT INTO t1 (id, str) VALUES(1, 'test1');"); + db.close(); + QCOMPARE(db.lastError().type(), QSqlError::NoError); + } +@@ -4089,7 +4128,7 @@ + QSqlQuery q(db); + + QString tableName(qTableName("bug23895", __FILE__, db)); +- q.prepare(QLatin1String("create table %1(id integer primary key, val1 bool, val2 boolean)") ++ q.prepare(QLatin1String("create table %1(id integer, val1 bool, val2 boolean, primary key (id))") + .arg(tableName)); + QVERIFY_SQL(q, exec()); + q.prepare(QLatin1String("insert into %1(id, val1, val2) values(?, ?, ?);").arg(tableName)); +@@ -4145,7 +4184,7 @@ + QString tableName(qTableName("bug14904", __FILE__, db)); + tst_Databases::safeDropTable(db, tableName); + +- q.prepare(QLatin1String("create table %1(val1 bool)").arg(tableName)); ++ q.prepare(QLatin1String("create table %1(val1 Bool, PRIMARY KEY (val1))").arg(tableName)); + QVERIFY_SQL(q, exec()); + q.prepare(QLatin1String("insert into %1(val1) values(?);").arg(tableName)); + q.addBindValue(true); +@@ -4177,8 +4216,10 @@ + tst_Databases::safeDropTable(db, tableName); + + QSqlQuery q(db); +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (dt %2)") +- .arg(tableName, tst_Databases::dateTimeTypeName(db)))); ++ const auto dateTimeType = db.driverName().startsWith("QODBC") ++ ? QStringLiteral("Timestamp") : tst_Databases::dateTimeTypeName(db); ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (dt %2, primary key (dt))") ++ .arg(tableName, dateTimeType))); + + QDateTime dt = QDateTime(QDate(2012, 7, 4), QTime(23, 59, 59, 999)); + QVERIFY_SQL(q, prepare(QLatin1String("INSERT INTO %1 (dt) VALUES (?)").arg(tableName))); +@@ -4249,16 +4290,16 @@ + QSqlDatabase db = QSqlDatabase::database(dbName); + CHECK_DATABASE(db); + tableValues.reserve(values.size()); +- if (tst_Databases::getDatabaseType(db) == QSqlDriver::MySqlServer) { ++ if (tst_Databases::getDatabaseType(db) == QSqlDriver::MySqlServer ++ || db.driverName().startsWith("QODBC")) { + const QString tableName(qTableName("bug53969", __FILE__, db)); + tst_Databases::safeDropTable(db, tableName); + + QSqlQuery q(db); +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id INT AUTO_INCREMENT PRIMARY KEY, " +- "test_number TINYINT(3) UNSIGNED)") ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (test_number Uint8, PRIMARY KEY (test_number))") + .arg(tableName))); + +- QVERIFY_SQL(q, prepare(QLatin1String("INSERT INTO %1 (test_number) VALUES (:value)") ++ QVERIFY_SQL(q, prepare(QLatin1String("INSERT INTO %1 (test_number) VALUES (CAST(:value AS Uint8))") + .arg(tableName))); + + for (int value : values) { +@@ -4266,7 +4307,7 @@ + QVERIFY_SQL(q, exec()); + } + +- QVERIFY_SQL(q, prepare("SELECT test_number FROM " + tableName)); ++ QVERIFY_SQL(q, prepare("SELECT test_number FROM " + tableName + " ORDER BY CASE test_number WHEN 10 THEN 0 WHEN 20 THEN 1 WHEN 127 THEN 2 WHEN 128 THEN 3 ELSE 4 END")); + QVERIFY_SQL(q, exec()); + + while (q.next()) { +@@ -4423,7 +4464,7 @@ + tst_Databases::safeDropTable(db, tableName); + + QSqlQuery q(db); +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id INTEGER, realVal REAL)") ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id Int32, realVal Double, PRIMARY KEY (id))") + .arg(tableName))); + QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (id, realVal) VALUES (1, 2.3)") + .arg(tableName))); +@@ -4438,7 +4479,7 @@ + q.addBindValue(var); + QVERIFY_SQL(q, exec()); + +- QVERIFY_SQL(q, exec(QLatin1String("SELECT realVal FROM %1 WHERE ID=4").arg(tableName))); ++ QVERIFY_SQL(q, exec(QLatin1String("SELECT realVal FROM %1 WHERE id=4").arg(tableName))); + QVERIFY(q.next()); + QCOMPARE(q.value(0).toDouble(), 5.6); + } +@@ -4460,13 +4501,16 @@ + } else if (dbType == QSqlDriver::MySqlServer) { + sumType = QMetaType::Double; + countType = QMetaType::LongLong; ++ } else if (db.driverName().startsWith("QODBC")) { ++ sumType = QMetaType::LongLong; ++ countType = QMetaType::ULongLong; + } + { + const QString tableName(qTableName("numericFunctionsWithIntValues", __FILE__, db)); + tst_Databases::safeDropTable(db, tableName); + + QSqlQuery q(db); +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id INTEGER)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id INTEGER, primary key (id))").arg(tableName))); + + // First test without any entries + QVERIFY_SQL(q, exec("SELECT SUM(id) FROM " + tableName)); +@@ -4487,7 +4531,8 @@ + QVERIFY_SQL(q, exec("SELECT AVG(id) FROM " + tableName)); + QVERIFY(q.next()); + if (dbType == QSqlDriver::SQLite || dbType == QSqlDriver::PostgreSQL +- || dbType == QSqlDriver::MySqlServer || dbType == QSqlDriver::Oracle) { ++ || dbType == QSqlDriver::MySqlServer || dbType == QSqlDriver::Oracle ++ || db.driverName().startsWith("QODBC")) { + QCOMPARE(q.value(0).toDouble(), 1.5); + QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double); + } else { +@@ -4516,7 +4561,7 @@ + tst_Databases::safeDropTable(db, tableName); + + QSqlQuery q(db); +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id REAL)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (pk INTEGER, id Double, primary key (pk))").arg(tableName))); + + // First test without any entries + QVERIFY_SQL(q, exec("SELECT SUM(id) FROM " + tableName)); +@@ -4526,8 +4571,8 @@ + else + QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double); + +- QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (id) VALUES (1.5)").arg(tableName))); +- QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (id) VALUES (2.5)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (pk, id) VALUES (1, 1.5)").arg(tableName))); ++ QVERIFY_SQL(q, exec(QLatin1String("INSERT INTO %1 (pk, id) VALUES (2, 2.5)").arg(tableName))); + + QVERIFY_SQL(q, exec("SELECT SUM(id) FROM " + tableName)); + QVERIFY(q.next()); +@@ -4560,14 +4605,18 @@ + if (dbType == QSqlDriver::PostgreSQL) + field += "::NUMERIC"; + +- QVERIFY_SQL(q, exec(QLatin1String("SELECT ROUND(%1, 1) FROM %2 WHERE id=1.5") +- .arg(field, tableName))); ++ const auto roundOneSql = db.driverName().startsWith("QODBC") ++ ? QLatin1String("SELECT Math::Round(%1 * 10.0) / 10.0 FROM %2 WHERE id=1.5") ++ : QLatin1String("SELECT ROUND(%1, 1) FROM %2 WHERE id=1.5"); ++ QVERIFY_SQL(q, exec(roundOneSql.arg(field, tableName))); + QVERIFY(q.next()); + QCOMPARE(q.value(0).toDouble(), 1.5); + QCOMPARE(q.record().field(0).metaType().id(), QMetaType::Double); + +- QVERIFY_SQL(q, exec(QLatin1String("SELECT ROUND(%1, 0) FROM %2 WHERE id=2.5") +- .arg(field, tableName))); ++ const auto roundZeroSql = db.driverName().startsWith("QODBC") ++ ? QLatin1String("SELECT Math::Round(%1) FROM %2 WHERE id=2.5") ++ : QLatin1String("SELECT ROUND(%1, 0) FROM %2 WHERE id=2.5"); ++ QVERIFY_SQL(q, exec(roundZeroSql.arg(field, tableName))); + QVERIFY(q.next()); + if (dbType == QSqlDriver::MySqlServer) + QCOMPARE(q.value(0).toDouble(), 2.0); +@@ -4580,7 +4629,7 @@ + tst_Databases::safeDropTable(db, tableName); + + QSqlQuery q(db); +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id INTEGER, txt VARCHAR(50))") ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %1 (id INTEGER, txt Utf8, primary key (id))") + .arg(tableName))); + + QVERIFY_SQL(q, exec("SELECT MAX(txt) FROM " + tableName)); +@@ -4611,7 +4660,7 @@ + + QSqlQuery q(db); + QVERIFY_SQL(q, exec("DROP TABLE IF EXISTS " + tableName)); +- QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %2 (id %1)").arg(type, tableName))); ++ QVERIFY_SQL(q, exec(QLatin1String("CREATE TABLE %2 (id %1, PRIMARY KEY (id))").arg(type, tableName))); + + if (withPreparedStatement) { + QVERIFY_SQL(q, prepare(QLatin1String("INSERT INTO %1 (id) VALUES (?)").arg(tableName))); +@@ -4630,10 +4679,10 @@ + + // Ensure we can read them back properly: + if (withPreparedStatement) { +- QVERIFY_SQL(q, prepare("SELECT id FROM " + tableName)); ++ QVERIFY_SQL(q, prepare("SELECT id FROM " + tableName + " ORDER BY id")); + QVERIFY_SQL(q, exec()); + } else { +- QVERIFY_SQL(q, exec("SELECT id FROM " + tableName)); ++ QVERIFY_SQL(q, exec("SELECT id FROM " + tableName + " ORDER BY id")); + } + QList actualValues; + QList actualVariantValues; +@@ -4676,25 +4725,25 @@ + const QList boolValues = QList() << false << true; + for (int i = 0; i < 2; ++i) { + const bool withPreparedStatement = (i == 1); +- runIntegralTypesMysqlTest(db, "tinyInt1Test", "TINYINT(1)", ++ runIntegralTypesMysqlTest(db, "tinyInt1Test", "Uint8", + withPreparedStatement, boolValues); +- runIntegralTypesMysqlTest(db, "unsignedTinyInt1Test", "TINYINT(1) UNSIGNED", ++ runIntegralTypesMysqlTest(db, "unsignedTinyInt1Test", "Uint8", + withPreparedStatement, boolValues); +- runIntegralTypesMysqlTest(db, "tinyIntTest", "TINYINT", withPreparedStatement); +- runIntegralTypesMysqlTest(db, "unsignedTinyIntTest", "TINYINT UNSIGNED", ++ runIntegralTypesMysqlTest(db, "tinyIntTest", "Int8", withPreparedStatement); ++ runIntegralTypesMysqlTest(db, "unsignedTinyIntTest", "Uint8", + withPreparedStatement); +- runIntegralTypesMysqlTest(db, "smallIntTest", "SMALLINT", withPreparedStatement); +- runIntegralTypesMysqlTest(db, "unsignedSmallIntTest", "SMALLINT UNSIGNED", ++ runIntegralTypesMysqlTest(db, "smallIntTest", "Int16", withPreparedStatement); ++ runIntegralTypesMysqlTest(db, "unsignedSmallIntTest", "Uint16", + withPreparedStatement); +- runIntegralTypesMysqlTest(db, "mediumIntTest", "MEDIUMINT", withPreparedStatement, ++ runIntegralTypesMysqlTest(db, "mediumIntTest", "Int32", withPreparedStatement, + -(1 << 23), (1 << 23) - 1); +- runIntegralTypesMysqlTest(db, "unsignedMediumIntTest", "MEDIUMINT UNSIGNED", ++ runIntegralTypesMysqlTest(db, "unsignedMediumIntTest", "Uint32", + withPreparedStatement, 0, (1 << 24) - 1); +- runIntegralTypesMysqlTest(db, "intTest", "INT", withPreparedStatement); +- runIntegralTypesMysqlTest(db, "unsignedIntTest", "INT UNSIGNED", ++ runIntegralTypesMysqlTest(db, "intTest", "Int32", withPreparedStatement); ++ runIntegralTypesMysqlTest(db, "unsignedIntTest", "Uint32", + withPreparedStatement); +- runIntegralTypesMysqlTest(db, "bigIntTest", "BIGINT", withPreparedStatement); +- runIntegralTypesMysqlTest(db, "unsignedBigIntTest", "BIGINT UNSIGNED", ++ runIntegralTypesMysqlTest(db, "bigIntTest", "Int64", withPreparedStatement); ++ runIntegralTypesMysqlTest(db, "unsignedBigIntTest", "Uint64", + withPreparedStatement); + } + } +@@ -4715,8 +4764,8 @@ + tst_Databases::safeDropTable(db, tableName); + + QVERIFY_SQL(create, exec(QLatin1String( +- "create table %1 (id int, dt_utc datetime, dt_lt datetime, " +- "dt_tzoffset datetime)").arg(tableName))); ++ "create table %1 (id Int32, dt_utc Timestamp64, dt_lt Timestamp64, " ++ "dt_tzoffset Timestamp64, PRIMARY KEY (id))").arg(tableName))); + QVERIFY_SQL(create, prepare(QLatin1String("insert into %1 (id, dt_utc, dt_lt, dt_tzoffset) " + "values (?, ?, ?, ?)").arg(tableName))); + +@@ -4750,10 +4799,10 @@ + tst_Databases::safeDropTable(db, tableName); + + QVERIFY_SQL(create, exec(QLatin1String( +- "create table %1 (dec2 decimal(4,2), dec0 decimal(20,0), " +- "dec3 decimal(20,3))").arg(tableName))); ++ "create table %1 (pk int, dec2 Decimal(4, 2), dec0 Decimal(20, 0), " ++ "dec3 Decimal(20, 3), primary key (pk))").arg(tableName))); + QVERIFY_SQL(create, prepare(QLatin1String( +- "insert into %1 (dec2, dec0, dec3) values (?, ?, ?)") ++ "insert into %1 (pk, dec2, dec0, dec3) values (1, CAST(? AS Decimal(4, 2)), CAST(? AS Decimal(20, 0)), CAST(? AS Decimal(20, 3)))") + .arg(tableName))); + + create.addBindValue("99.99"); +@@ -4997,7 +5046,7 @@ + QSqlQuery qry(db); + QVERIFY_SQL(qry, exec(QLatin1String( + "create table %1 (intData int[0:4], longData bigint[5], " +- "charData varchar(255)[5], boolData boolean[2])").arg(arrayTable))); ++ "charData Utf8[5], boolData boolean[2])").arg(arrayTable))); + QVERIFY_SQL(qry, prepare(QLatin1String("insert into %1 (intData, longData, charData, boolData)" + " values(?, ?, ?, ?)").arg(arrayTable))); + const auto intArray = QVariant{QVariantList{1, 2, 3, 4711, 815}}; +--- a/kernel/qsqlthread/tst_qsqlthread.cpp ++++ b/kernel/qsqlthread/tst_qsqlthread.cpp +@@ -112,7 +112,7 @@ + QSqlDatabase db = QSqlDatabase::cloneDatabase(sourceDb, dbName); + QVERIFY_SQL(db, open()); + QSqlQuery q(db); +- QVERIFY_SQL(q, prepare("insert into " + qtest + " values (?, ?, ?)")); ++ QVERIFY_SQL(q, prepare("insert into " + qtest + " (id, name, title) values (?, ?, ?)")); + int id = 10; + for (int i = 0; i < ProdConIterations; ++i) { + q.bindValue(0, ++id); +@@ -273,13 +273,13 @@ + QSqlQuery q(db); + + QVERIFY_SQL(q, exec("create table " + qtest +- + "(id int NOT NULL primary key, name varchar(20), title int)")); ++ + "(id int, name Utf8, title int, primary key (id))")); + + QVERIFY_SQL(q, exec("create table " + qTableName("qtest2", __FILE__, db) +- + "(id int NOT NULL primary key, title varchar(20))")); ++ + "(id int, title Utf8, primary key (id))")); + + QVERIFY_SQL(q, exec("create table " + qTableName("emptytable", __FILE__, db) +- + "(id int NOT NULL primary key)")); ++ + "(id int, primary key (id))")); + } + } + +@@ -290,13 +290,13 @@ + QSqlQuery q(db); + + QVERIFY_SQL(q, exec("delete from " + qtest)); +- QVERIFY_SQL(q, exec("insert into " + qtest + " values(1, 'harry', 1)")); +- QVERIFY_SQL(q, exec("insert into " + qtest + " values(2, 'trond', 2)")); +- QVERIFY_SQL(q, exec("insert into " + qtest + " values(3, 'vohi', 3)")); ++ QVERIFY_SQL(q, exec("insert into " + qtest + " (id, name, title) values(1, 'harry', 1)")); ++ QVERIFY_SQL(q, exec("insert into " + qtest + " (id, name, title) values(2, 'trond', 2)")); ++ QVERIFY_SQL(q, exec("insert into " + qtest + " (id, name, title) values(3, 'vohi', 3)")); + + QVERIFY_SQL(q, exec("delete from " + qTableName("qtest2", __FILE__, db))); +- QVERIFY_SQL(q, exec("insert into " + qTableName("qtest2", __FILE__, db) + " values(1, 'herr')")); +- QVERIFY_SQL(q, exec("insert into " + qTableName("qtest2", __FILE__, db) + " values(2, 'mister')")); ++ QVERIFY_SQL(q, exec("insert into " + qTableName("qtest2", __FILE__, db) + " (id, title) values(1, 'herr')")); ++ QVERIFY_SQL(q, exec("insert into " + qTableName("qtest2", __FILE__, db) + " (id, title) values(2, 'mister')")); + } + } + +--- a/models/qsqlquerymodel/tst_qsqlquerymodel.cpp ++++ b/models/qsqlquerymodel/tst_qsqlquerymodel.cpp +@@ -124,10 +124,10 @@ + QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db); + if (dbType == QSqlDriver::PostgreSQL) + QVERIFY_SQL( q, exec("set client_min_messages='warning'")); +- QVERIFY_SQL( q, exec("create table " + qTableName("test", __FILE__, db) + "(id integer not null, name varchar(20), title integer, primary key (id))")); +- QVERIFY_SQL( q, exec("create table " + qTableName("test2", __FILE__, db) + "(id integer not null, title varchar(20), primary key (id))")); +- QVERIFY_SQL( q, exec("create table " + qTableName("test3", __FILE__, db) + "(id integer not null, primary key (id))")); +- QVERIFY_SQL( q, exec("create table " + qTableName("many", __FILE__, db) + "(id integer not null, name varchar(20), primary key (id))")); ++ QVERIFY_SQL( q, exec("create table " + qTableName("test", __FILE__, db) + "(id integer, name Utf8, title integer, primary key (id))")); ++ QVERIFY_SQL( q, exec("create table " + qTableName("test2", __FILE__, db) + "(id integer, title Utf8, primary key (id))")); ++ QVERIFY_SQL( q, exec("create table " + qTableName("test3", __FILE__, db) + "(id integer, primary key (id))")); ++ QVERIFY_SQL( q, exec("create table " + qTableName("many", __FILE__, db) + "(id integer, name Utf8, primary key (id))")); + } + + void tst_QSqlQueryModel::populateTestTables(QSqlDatabase db) +@@ -138,17 +138,17 @@ + QSqlQuery q(db), q2(db); + + tst_Databases::safeDropTables(db, QStringList() << qTableName("manytmp", __FILE__, db) << qTableName("test3tmp", __FILE__, db)); +- QVERIFY_SQL(q, exec("create table " + qTableName("manytmp", __FILE__, db) + "(id integer not null, name varchar(20), primary key (id))")); +- QVERIFY_SQL(q, exec("create table " + qTableName("test3tmp", __FILE__, db) + "(id integer not null, primary key (id))")); ++ QVERIFY_SQL(q, exec("create table " + qTableName("manytmp", __FILE__, db) + "(id integer, name Utf8, primary key (id))")); ++ QVERIFY_SQL(q, exec("create table " + qTableName("test3tmp", __FILE__, db) + "(id integer, primary key (id))")); + + if (hasTransactions) QVERIFY_SQL(db, transaction()); + +- QVERIFY_SQL(q, exec("insert into " + qTableName("test", __FILE__, db) + " values(1, 'harry', 1)")); +- QVERIFY_SQL(q, exec("insert into " + qTableName("test", __FILE__, db) + " values(2, 'trond', 2)")); +- QVERIFY_SQL(q, exec("insert into " + qTableName("test2", __FILE__, db) + " values(1, 'herr')")); +- QVERIFY_SQL(q, exec("insert into " + qTableName("test2", __FILE__, db) + " values(2, 'mister')")); +- +- QVERIFY_SQL(q, exec(QString("insert into " + qTableName("test3", __FILE__, db) + " values(0)"))); ++ QVERIFY_SQL(q, exec("insert into " + qTableName("test", __FILE__, db) + " (id, name, title) values(1, 'harry', 1)")); ++ QVERIFY_SQL(q, exec("insert into " + qTableName("test", __FILE__, db) + " (id, name, title) values(2, 'trond', 2)")); ++ QVERIFY_SQL(q, exec("insert into " + qTableName("test2", __FILE__, db) + " (id, title) values(1, 'herr')")); ++ QVERIFY_SQL(q, exec("insert into " + qTableName("test2", __FILE__, db) + " (id, title) values(2, 'mister')")); ++ ++ QVERIFY_SQL(q, exec(QString("insert into " + qTableName("test3", __FILE__, db) + " (id) values(0)"))); + QVERIFY_SQL(q, prepare("insert into "+ qTableName("test3", __FILE__, db) + "(id) select id + ? from " + qTableName("test3tmp", __FILE__, db))); + for (int i=1; i<260; i*=2) { + q2.exec("delete from " + qTableName("test3tmp", __FILE__, db)); +--- a/models/qsqlrelationaldelegate/tst_qsqlrelationaldelegate.cpp ++++ b/models/qsqlrelationaldelegate/tst_qsqlrelationaldelegate.cpp +@@ -60,19 +60,19 @@ + const auto titleField = db.driver()->escapeIdentifier(QLatin1String("title"), + QSqlDriver::FieldName); + QVERIFY_SQL(q, exec("create table " + reltest1 + +- " (" + idField + " int not null primary key, " + nameField + " varchar(20), " + +- titleKeyField + " int, " + anotherTitleField + "int)")); +- QVERIFY_SQL(q, exec("insert into " + reltest1 + " values(1, 'harry', 1, 2)")); +- QVERIFY_SQL(q, exec("insert into " + reltest1 + " values(2, 'trond', 2, 1)")); +- QVERIFY_SQL(q, exec("insert into " + reltest1 + " values(3, 'vohi', 1, 2)")); +- QVERIFY_SQL(q, exec("insert into " + reltest1 + " values(4, 'boris', 2, 2)")); +- QVERIFY_SQL(q, exec("insert into " + reltest1 + " values(5, 'nat', NULL, NULL)")); +- QVERIFY_SQL(q, exec("insert into " + reltest1 + " values(6, 'ale', NULL, 2)")); ++ " (" + idField + " int, " + nameField + " Utf8, " + ++ titleKeyField + " int, " + anotherTitleField + " int, primary key (" + idField + "))")); ++ QVERIFY_SQL(q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(1, 'harry', 1, 2)")); ++ QVERIFY_SQL(q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(2, 'trond', 2, 1)")); ++ QVERIFY_SQL(q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(3, 'vohi', 1, 2)")); ++ QVERIFY_SQL(q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(4, 'boris', 2, 2)")); ++ QVERIFY_SQL(q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(5, 'nat', NULL, NULL)")); ++ QVERIFY_SQL(q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(6, 'ale', NULL, 2)")); + +- QVERIFY_SQL(q, exec("create table " + reltest2 + " (" + idField + " int not null primary key, " +- + titleKeyField + " varchar(20))")); +- QVERIFY_SQL(q, exec("insert into " + reltest2 + " values(1, 'herr')")); +- QVERIFY_SQL(q, exec("insert into " + reltest2 + " values(2, 'mister')")); ++ QVERIFY_SQL(q, exec("create table " + reltest2 + " (" + idField + " int, " ++ + titleKeyField + " Utf8, primary key (" + idField + "))")); ++ QVERIFY_SQL(q, exec("insert into " + reltest2 + " (id, title_key) values(1, 'herr')")); ++ QVERIFY_SQL(q, exec("insert into " + reltest2 + " (id, title_key) values(2, 'mister')")); + } + + void tst_QSqlRelationalDelegate::initTestCase() +@@ -132,6 +132,7 @@ + QSqlRelationalTableModel model(0, db); + model.setEditStrategy(QSqlTableModel::OnManualSubmit); + model.setTable(reltest1); ++ model.setSort(0, Qt::AscendingOrder); + model.setRelation(2, QSqlRelation(reltest2, idField, titleKeyField)); + model.setRelation(3, QSqlRelation(reltest2, idField, titleKeyField)); + tv.setModel(&model); +--- a/models/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp ++++ b/models/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp +@@ -90,39 +90,39 @@ + + QSqlQuery q(db); + QVERIFY_SQL( q, exec("create table " + reltest1 + +- " (id int not null primary key, name varchar(20), title_key int, another_title_key int)")); +- QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(1, 'harry', 1, 2)")); +- QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(2, 'trond', 2, 1)")); +- QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(3, 'vohi', 1, 2)")); +- QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(4, 'boris', 2, 2)")); +- QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(5, 'nat', NULL, NULL)")); +- QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(6, 'ale', NULL, 2)")); +- +- QVERIFY_SQL( q, exec("create table " + reltest2 + " (id int not null primary key, title varchar(20))")); +- QVERIFY_SQL( q, exec("insert into " + reltest2 + " values(1, 'herr')")); +- QVERIFY_SQL( q, exec("insert into " + reltest2 + " values(2, 'mister')")); +- +- QVERIFY_SQL( q, exec("create table " + reltest3 + " (id int not null primary key, name varchar(20), city_key int)")); +- QVERIFY_SQL( q, exec("insert into " + reltest3 + " values(1, 'Gustav', 1)")); +- QVERIFY_SQL( q, exec("insert into " + reltest3 + " values(2, 'Heidi', 2)")); +- +- QVERIFY_SQL( q, exec("create table " + reltest4 + " (id int not null primary key, name varchar(20))")); +- QVERIFY_SQL( q, exec("insert into " + reltest4 + " values(1, 'Oslo')")); +- QVERIFY_SQL( q, exec("insert into " + reltest4 + " values(2, 'Trondheim')")); +- +- QVERIFY_SQL( q, exec("create table " + reltest5 + " (title varchar(20) not null primary key, abbrev varchar(20))")); +- QVERIFY_SQL( q, exec("insert into " + reltest5 + " values('herr', 'Hr')")); +- QVERIFY_SQL( q, exec("insert into " + reltest5 + " values('mister', 'Mr')")); ++ " (id int, name Utf8, title_key int, another_title_key int, primary key (id))")); ++ QVERIFY_SQL( q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(1, 'harry', 1, 2)")); ++ QVERIFY_SQL( q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(2, 'trond', 2, 1)")); ++ QVERIFY_SQL( q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(3, 'vohi', 1, 2)")); ++ QVERIFY_SQL( q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(4, 'boris', 2, 2)")); ++ QVERIFY_SQL( q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(5, 'nat', NULL, NULL)")); ++ QVERIFY_SQL( q, exec("insert into " + reltest1 + " (id, name, title_key, another_title_key) values(6, 'ale', NULL, 2)")); ++ ++ QVERIFY_SQL( q, exec("create table " + reltest2 + " (id int, title Utf8, primary key (id))")); ++ QVERIFY_SQL( q, exec("insert into " + reltest2 + " (id, title) values(1, 'herr')")); ++ QVERIFY_SQL( q, exec("insert into " + reltest2 + " (id, title) values(2, 'mister')")); ++ ++ QVERIFY_SQL( q, exec("create table " + reltest3 + " (id int, name Utf8, city_key int, primary key (id))")); ++ QVERIFY_SQL( q, exec("insert into " + reltest3 + " (id, name, city_key) values(1, 'Gustav', 1)")); ++ QVERIFY_SQL( q, exec("insert into " + reltest3 + " (id, name, city_key) values(2, 'Heidi', 2)")); ++ ++ QVERIFY_SQL( q, exec("create table " + reltest4 + " (id int, name Utf8, primary key (id))")); ++ QVERIFY_SQL( q, exec("insert into " + reltest4 + " (id, name) values(1, 'Oslo')")); ++ QVERIFY_SQL( q, exec("insert into " + reltest4 + " (id, name) values(2, 'Trondheim')")); ++ ++ QVERIFY_SQL( q, exec("create table " + reltest5 + " (title Utf8, abbrev Utf8, primary key (title))")); ++ QVERIFY_SQL( q, exec("insert into " + reltest5 + " (title, abbrev) values('herr', 'Hr')")); ++ QVERIFY_SQL( q, exec("insert into " + reltest5 + " (title, abbrev) values('mister', 'Mr')")); + + if (testWhiteSpaceNames(db.driverName())) { + const auto reltest6 = qTableName("rel test6", __FILE__, db); +- QVERIFY_SQL( q, exec("create table " + reltest6 + " (id int not null primary key, " + db.driver()->escapeIdentifier("city key", QSqlDriver::FieldName) + +- " int, " + db.driver()->escapeIdentifier("extra field", QSqlDriver::FieldName) + " int)")); ++ QVERIFY_SQL( q, exec("create table " + reltest6 + " (id int, " + db.driver()->escapeIdentifier("city key", QSqlDriver::FieldName) + ++ " int, " + db.driver()->escapeIdentifier("extra field", QSqlDriver::FieldName) + " int, primary key (id))")); + QVERIFY_SQL( q, exec("insert into " + reltest6 + " values(1, 1,9)")); + QVERIFY_SQL( q, exec("insert into " + reltest6 + " values(2, 2,8)")); + + const auto reltest7 = qTableName("rel test7", __FILE__, db); +- QVERIFY_SQL( q, exec("create table " + reltest7 + " (" + db.driver()->escapeIdentifier("city id", QSqlDriver::TableName) + " int not null primary key, " + db.driver()->escapeIdentifier("city name", QSqlDriver::FieldName) + " varchar(20))")); ++ QVERIFY_SQL( q, exec("create table " + reltest7 + " (" + db.driver()->escapeIdentifier("city id", QSqlDriver::TableName) + " int, " + db.driver()->escapeIdentifier("city name", QSqlDriver::FieldName) + " Utf8, primary key (" + db.driver()->escapeIdentifier("city id", QSqlDriver::TableName) + "))")); + QVERIFY_SQL( q, exec("insert into " + reltest7 + " values(1, 'New York')")); + QVERIFY_SQL( q, exec("insert into " + reltest7 + " values(2, 'Washington')")); + } +@@ -190,6 +190,7 @@ + QSqlRelationalTableModel model(0, db); + + model.setTable(reltest1); ++ model.setSort(0, Qt::AscendingOrder); + model.setRelation(2, QSqlRelation(reltest2, "id", "title")); + QVERIFY_SQL(model, select()); + +@@ -215,6 +216,7 @@ + //in this case a string + QSqlRelationalTableModel model2(0,db); + model2.setTable(reltest2); ++ model2.setSort(0, Qt::AscendingOrder); + model2.setRelation(1, QSqlRelation(reltest5,"title","abbrev")); + QVERIFY_SQL(model2, select()); + +@@ -657,6 +659,7 @@ + QSqlRelationalTableModel model(0, db); + + model.setTable(reltest1); ++ model.setSort(0, Qt::AscendingOrder); + model.setRelation(2, QSqlRelation(reltest2, "id", "title")); + QVERIFY_SQL(model, select()); + +@@ -683,6 +686,8 @@ + QSqlRelationalTableModel lmodel(0, db); + + lmodel.setTable(reltest1); ++ ++ lmodel.setSort(0, Qt::AscendingOrder); + lmodel.setRelation(2, QSqlRelation(reltest2, "id", "title")); + lmodel.setJoinMode(QSqlRelationalTableModel::LeftJoin); + QVERIFY_SQL(lmodel, select()); +@@ -1016,6 +1021,7 @@ + + QSqlRelationalTableModel model(0, db); + model.setTable(reltest1); ++ model.setSort(0, Qt::AscendingOrder); + model.setRelation(2, QSqlRelation(reltest2, "id", "title")); + QVERIFY_SQL(model, select()); + +@@ -1093,19 +1099,19 @@ + + QSqlQuery q(db); + QVERIFY_SQL( q, exec("create table " + qTableName("CASETEST1", db).toUpper() + +- " (id int not null primary key, name varchar(20), title_key int, another_title_key int)")); ++ " (id int, name Utf8, title_key int, another_title_key int, primary key (id))")); + + if (!q.exec("create table " + qTableName("casetest1", db) + +- " (ident int not null primary key, name varchar(20), title_key int)")) ++ " (ident int, name Utf8, title_key int, primary key (ident))")) + QSKIP("The casing test for this database is irrelevant since this database does not treat different cases as separate entities"); + +- QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db).toUpper() + " values(1, 'harry', 1, 2)")); +- QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db).toUpper() + " values(2, 'trond', 2, 1)")); +- QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db).toUpper() + " values(3, 'vohi', 1, 2)")); +- QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db).toUpper() + " values(4, 'boris', 2, 2)")); +- QVERIFY_SQL( q, exec("insert into " + qTableName("casetest1", db) + " values(1, 'jerry', 1)")); +- QVERIFY_SQL( q, exec("insert into " + qTableName("casetest1", db) + " values(2, 'george', 2)")); +- QVERIFY_SQL( q, exec("insert into " + qTableName("casetest1", db) + " values(4, 'kramer', 2)")); ++ QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db).toUpper() + " (id, name, title_key, another_title_key) values(1, 'harry', 1, 2)")); ++ QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db).toUpper() + " (id, name, title_key, another_title_key) values(2, 'trond', 2, 1)")); ++ QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db).toUpper() + " (id, name, title_key, another_title_key) values(3, 'vohi', 1, 2)")); ++ QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db).toUpper() + " (id, name, title_key, another_title_key) values(4, 'boris', 2, 2)")); ++ QVERIFY_SQL( q, exec("insert into " + qTableName("casetest1", db) + " (ident, name, title_key) values(1, 'jerry', 1)")); ++ QVERIFY_SQL( q, exec("insert into " + qTableName("casetest1", db) + " (ident, name, title_key) values(2, 'george', 2)")); ++ QVERIFY_SQL( q, exec("insert into " + qTableName("casetest1", db) + " (ident, name, title_key) values(4, 'kramer', 2)")); + + if (dbType == QSqlDriver::Oracle) { + //try an owner that doesn't exist +@@ -1159,6 +1165,7 @@ + + QSqlRelationalTableModel model(0, db); + model.setTable(reltest1); ++ model.setSort(0, Qt::AscendingOrder); + + //try with relation table name quoted + if (dbType == QSqlDriver::Interbase || dbType == QSqlDriver::Oracle || dbType == QSqlDriver::DB2) { +@@ -1463,9 +1470,9 @@ + QVERIFY_SQL(q, exec("create schema " + qTableName("QTBUG_5373", __FILE__, db))); + QVERIFY_SQL(q, exec("create schema " + qTableName("QTBUG_5373_s2", __FILE__, db))); + QVERIFY_SQL(q, exec("create table " + qTableName("QTBUG_5373", __FILE__, db) + QLatin1Char('.') + qTableName("document", __FILE__, db) + +- "(document_id int primary key, relatingid int, userid int)")); ++ "(document_id int, relatingid int, userid int, primary key (document_id))")); + QVERIFY_SQL(q, exec("create table " + qTableName("QTBUG_5373_s2", __FILE__, db) + QLatin1Char('.') + qTableName("user", __FILE__, db) + +- "(userid int primary key, username char(40))")); ++ "(userid int, username Utf8, primary key (userid))")); + model.setTable(qTableName("QTBUG_5373", __FILE__, db) + QLatin1Char('.') + qTableName("document", __FILE__, db)); + model.setRelation(1, QSqlRelation(qTableName("QTBUG_5373_s2", __FILE__, db) + QLatin1Char('.') + qTableName("user", __FILE__, db), "userid", "username")); + model.setRelation(2, QSqlRelation(qTableName("QTBUG_5373_s2", __FILE__, db) + QLatin1Char('.') + qTableName("user", __FILE__, db), "userid", "username")); +@@ -1483,12 +1490,13 @@ + + QSqlRelationalTableModel model(0, db); + model.setTable(reltest1); ++ model.setSort(0, Qt::AscendingOrder); + model.setRelation(2, QSqlRelation(reltest2, "id", "title")); + QVERIFY_SQL(model, select()); + QCOMPARE(model.relationModel(2)->rowCount(), 2); + { + QSqlQuery q(db); +- QVERIFY_SQL(q, exec("insert into " + reltest2 + " values(3, 'mrs')")); ++ QVERIFY_SQL(q, exec("insert into " + reltest2 + " (id, title) values(3, 'mrs')")); + model.relationModel(2)->select(); + } + QCOMPARE(model.relationModel(2)->rowCount(), 3); +@@ -1512,14 +1520,14 @@ + + //prepare test1 table + QSqlQuery q(db); +- QVERIFY_SQL(q, exec("CREATE TABLE " + testTable1 + " (val1 INTEGER, id1 INTEGER PRIMARY KEY);")); ++ QVERIFY_SQL(q, exec("CREATE TABLE " + testTable1 + " (val1 INTEGER, id1 INTEGER, primary key (id1));")); + QVERIFY_SQL(q, exec("DELETE FROM " + testTable1 + QLatin1Char(';'))); + QVERIFY_SQL(q, exec("INSERT INTO " + testTable1 + " (id1, val1) VALUES(1, 10);")); + QVERIFY_SQL(q, exec("INSERT INTO " + testTable1 + " (id1, val1) VALUES(2, 20);")); + QVERIFY_SQL(q, exec("INSERT INTO " + testTable1 + " (id1, val1) VALUES(3, 30);")); + + //prepare test2 table +- QVERIFY_SQL(q, exec("CREATE TABLE " + testTable2 + " (id INTEGER PRIMARY KEY, name TEXT);")); ++ QVERIFY_SQL(q, exec("CREATE TABLE " + testTable2 + " (id INTEGER, name TEXT, primary key (id));")); + QVERIFY_SQL(q, exec("DELETE FROM " + testTable2 + QLatin1Char(';'))); + QVERIFY_SQL(q, exec("INSERT INTO " + testTable2 + " (id, name) VALUES (10, 'Hervanta');")); + QVERIFY_SQL(q, exec("INSERT INTO " + testTable2 + " (id, name) VALUES (20, 'Keskusta');")); +@@ -1530,6 +1538,7 @@ + //set test model + QSqlRelationalTableModel model(NULL, db); + model.setTable(testTable1); ++ model.setSort(1, Qt::AscendingOrder); + model.setRelation(0, QSqlRelation(testTable2, "id", "name")); + QVERIFY_SQL(model, select()); + +--- a/models/qsqltablemodel/tst_qsqltablemodel.cpp ++++ b/models/qsqltablemodel/tst_qsqltablemodel.cpp +@@ -102,10 +102,10 @@ + void tablesAndSchemas(); + void whitespaceInIdentifiers_data() { generic_data(); } + void whitespaceInIdentifiers(); +- void primaryKeyOrder_data() { generic_data("QSQLITE"); } ++ void primaryKeyOrder_data() { generic_data(); } + void primaryKeyOrder(); + +- void sqlite_bigTable_data() { generic_data("QSQLITE"); } ++ void sqlite_bigTable_data() { generic_data(); } + void sqlite_bigTable(); + void modelInAnotherThread(); + +@@ -182,26 +182,26 @@ + QSqlDriver::DbmsType dbType = tst_Databases::getDatabaseType(db); + QSqlQuery q(db); + +- QVERIFY_SQL( q, exec("create table " + qTableName("test1", __FILE__, db) + "(id int, name varchar(20), title int)")); +- +- QVERIFY_SQL( q, exec("create table " + qTableName("test2", __FILE__, db) + "(id int, title varchar(20))")); +- +- QVERIFY_SQL( q, exec("create table " + qTableName("test3", __FILE__, db) + "(id int, random varchar(20), randomtwo varchar(20))")); ++ QVERIFY_SQL( q, exec("create table " + qTableName("test1", __FILE__, db) + "(id int, name Utf8, title int, primary key (id))")); ++ ++ QVERIFY_SQL( q, exec("create table " + qTableName("test2", __FILE__, db) + "(id int, title Utf8, primary key (id))")); ++ ++ QVERIFY_SQL( q, exec("create table " + qTableName("test3", __FILE__, db) + "(id int, random Utf8, randomtwo Utf8, primary key (id))")); + + if (dbType != QSqlDriver::MSSqlServer) +- QVERIFY_SQL(q, exec("create table " + qTableName("test4", __FILE__, db) + "(column1 varchar(50), column2 varchar(50), column3 varchar(50))")); ++ QVERIFY_SQL(q, exec("create table " + qTableName("test4", __FILE__, db) + "(column1 Utf8, column2 Utf8, column3 Utf8, primary key (column1))")); + else +- QVERIFY_SQL(q, exec("create table " + qTableName("test4", __FILE__, db) + "(column1 varchar(50), column2 varchar(50) NULL, column3 varchar(50))")); +- +- +- QVERIFY_SQL(q, exec("create table " + qTableName("emptytable", __FILE__, db) + "(id int)")); ++ QVERIFY_SQL(q, exec("create table " + qTableName("test4", __FILE__, db) + "(column1 Utf8, column2 Utf8 NULL, column3 Utf8)")); ++ ++ ++ QVERIFY_SQL(q, exec("create table " + qTableName("emptytable", __FILE__, db) + "(id int, primary key (id))")); + + if (testWhiteSpaceNames(db.driverName())) { + QString qry = "create table " + qTableName("qtestw hitespace", db) + " ("+ db.driver()->escapeIdentifier("a field", QSqlDriver::FieldName) + " int)"; + QVERIFY_SQL( q, exec(qry)); + } + +- QVERIFY_SQL(q, exec("create table " + qTableName("pktest", __FILE__, db) + "(id int not null primary key, a varchar(20))")); ++ QVERIFY_SQL(q, exec("create table " + qTableName("pktest", __FILE__, db) + "(id int, a Utf8, primary key (id))")); + } + } + +@@ -215,17 +215,17 @@ + const auto test3 = qTableName("test3", __FILE__, db); + + q.exec("delete from " + test); +- QVERIFY_SQL( q, exec("insert into " + test + " values(1, 'harry', 1)")); +- QVERIFY_SQL( q, exec("insert into " + test + " values(2, 'trond', 2)")); +- QVERIFY_SQL( q, exec("insert into " + test + " values(3, 'vohi', 3)")); ++ QVERIFY_SQL( q, exec("insert into " + test + " (id, name, title) values(1, 'harry', 1)")); ++ QVERIFY_SQL( q, exec("insert into " + test + " (id, name, title) values(2, 'trond', 2)")); ++ QVERIFY_SQL( q, exec("insert into " + test + " (id, name, title) values(3, 'vohi', 3)")); + + q.exec("delete from " + test2); +- QVERIFY_SQL( q, exec("insert into " + test2 + " values(1, 'herr')")); +- QVERIFY_SQL( q, exec("insert into " + test2 + " values(2, 'mister')")); ++ QVERIFY_SQL( q, exec("insert into " + test2 + " (id, title) values(1, 'herr')")); ++ QVERIFY_SQL( q, exec("insert into " + test2 + " (id, title) values(2, 'mister')")); + + q.exec("delete from " + test3); +- QVERIFY_SQL( q, exec("insert into " + test3 + " values(1, 'foo', 'bar')")); +- QVERIFY_SQL( q, exec("insert into " + test3 + " values(2, 'baz', 'joe')")); ++ QVERIFY_SQL( q, exec("insert into " + test3 + " (id, random, randomtwo) values(1, 'foo', 'bar')")); ++ QVERIFY_SQL( q, exec("insert into " + test3 + " (id, random, randomtwo) values(2, 'baz', 'joe')")); + } + } + +@@ -982,7 +982,7 @@ + QString tbl = qTableName("autoColumnTest", __FILE__, db); + QSqlQuery q(db); + q.exec("DROP TABLE " + tbl); +- QVERIFY_SQL(q, exec("CREATE TABLE " + tbl + "(id INTEGER PRIMARY KEY AUTOINCREMENT, val TEXT)")); ++ QVERIFY_SQL(q, exec("CREATE TABLE " + tbl + "(id INTEGER AUTOINCREMENT, val TEXT, primary key (id))")); + + QSqlTableModel model(0, db); + model.setTable(tbl); +@@ -1225,7 +1225,8 @@ + model.insertRow(1); + model.setData(model.index(1,0), 55); + model.setData(model.index(1,1), QString("null columns")); +- model.setData(model.index(1,2), QVariant()); ++ // Preserve the Int32 field type; an invalid QVariant is bound by QODBC as SQL_VARBINARY. ++ model.setData(model.index(1,2), QVariant(QMetaType(QMetaType::Int))); + + model.submitAll(); + +@@ -1393,8 +1394,8 @@ + q.exec("PRAGMA foreign_keys = ON;"); + q.exec("DROP TABLE " + tblB); + q.exec("DROP TABLE " + tblA); +- QVERIFY_SQL(q, exec("CREATE TABLE " + tblA + "(a INT PRIMARY KEY)")); +- QVERIFY_SQL(q, exec("CREATE TABLE " + tblB + "(b INT PRIMARY KEY, FOREIGN KEY (b) REFERENCES " + tblA + " (a))")); ++ QVERIFY_SQL(q, exec("CREATE TABLE " + tblA + "(a INT, primary key (a))")); ++ QVERIFY_SQL(q, exec("CREATE TABLE " + tblB + "(b INT, FOREIGN KEY (b) REFERENCES " + tblA + " (a), primary key (b))")); + QVERIFY_SQL(q, exec("INSERT INTO " + tblA + "(a) VALUES (1)")); + QVERIFY_SQL(q, exec("INSERT INTO " + tblB + "(b) VALUES (1)")); + if (q.exec("UPDATE " + tblA + " SET a = -1")) +@@ -1683,7 +1684,7 @@ + q.exec("DROP SCHEMA " + qTableName("testschema", __FILE__, db) + " CASCADE"); + QVERIFY_SQL( q, exec("create schema " + qTableName("testschema", __FILE__, db))); + QString tableName = qTableName("testschema", __FILE__, db) + '.' + qTableName("testtable", __FILE__, db); +- QVERIFY_SQL( q, exec("create table " + tableName + "(id int)")); ++ QVERIFY_SQL( q, exec("create table " + tableName + "(id int, primary key (id))")); + QVERIFY_SQL( q, exec("insert into " + tableName + " values(1)")); + QVERIFY_SQL( q, exec("insert into " + tableName + " values(2)")); + +@@ -1722,7 +1723,7 @@ + if (dbType == QSqlDriver::PostgreSQL) + QVERIFY_SQL( q, exec("set client_min_messages='warning'")); + +- QVERIFY_SQL(q, exec("create table " + qTableName("foo", __FILE__, db) + "(a varchar(20), id int not null primary key, b varchar(20))")); ++ QVERIFY_SQL(q, exec("create table " + qTableName("foo", __FILE__, db) + "(a Utf8, id int, b Utf8, primary key (id))")); + + QSqlTableModel model(0, db); + model.setTable(qTableName("foo", __FILE__, db)); +@@ -1799,9 +1800,9 @@ + const QString bigtable(qTableName("bigtable", __FILE__, db)); + + bool hasTransactions = db.driver()->hasFeature(QSqlDriver::Transactions); ++ QSqlQuery q(db); ++ QVERIFY_SQL( q, exec("create table "+bigtable+"(id Int32, name Utf8, primary key (id))")); + if (hasTransactions) QVERIFY(db.transaction()); +- QSqlQuery q(db); +- QVERIFY_SQL( q, exec("create table "+bigtable+"(id int primary key, name varchar)")); + QVERIFY_SQL( q, prepare("insert into "+bigtable+"(id, name) values (?, ?)")); + QElapsedTimer timing; + timing.start(); +@@ -1921,6 +1922,7 @@ + QSignalSpy modelResetSpy(&model, SIGNAL(modelReset())); + QSignalSpy spyRowsInserted(&model, SIGNAL(rowsInserted(QModelIndex,int,int))); + for (int i = 0; i < 10; i++) { ++ record.setValue(0, 10 + i); + QVERIFY(model.insertRecord(model.rowCount(), record)); + QCOMPARE(spyRowsInserted.at(i).at(1).toInt(), i+3); // The table already contains three rows + QCOMPARE(spyRowsInserted.at(i).at(2).toInt(), i+3); +@@ -1948,14 +1950,14 @@ + QVERIFY_SQL(attachedDb, open()); + QSqlQuery q(attachedDb); + tst_Databases::safeDropTables(attachedDb, QStringList() << "atest" << "atest2"); +- QVERIFY_SQL( q, exec("CREATE TABLE atest(id int, text varchar(20))")); +- QVERIFY_SQL( q, exec("CREATE TABLE atest2(id int, text varchar(20))")); ++ QVERIFY_SQL( q, exec("CREATE TABLE atest(id int, text Utf8)")); ++ QVERIFY_SQL( q, exec("CREATE TABLE atest2(id int, text Utf8)")); + QVERIFY_SQL( q, exec("INSERT INTO atest VALUES(1, 'attached-atest')")); + QVERIFY_SQL( q, exec("INSERT INTO atest2 VALUES(2, 'attached-atest2')")); + + QSqlQuery q2(db); + tst_Databases::safeDropTable(db, "atest"); +- QVERIFY_SQL(q2, exec("CREATE TABLE atest(id int, text varchar(20))")); ++ QVERIFY_SQL(q2, exec("CREATE TABLE atest(id int, text Utf8)")); + QVERIFY_SQL(q2, exec("INSERT INTO atest VALUES(3, 'main')")); + QVERIFY_SQL(q2, exec("ATTACH DATABASE \""+attachedDb.databaseName()+"\" as adb")); + +@@ -2046,6 +2048,13 @@ + QSqlDatabase db = QSqlDatabase::database(dbName); + CHECK_DATABASE(db); + const auto test = qTableName("test1", __FILE__, db); ++ ++ // YDB needs a key; keep it on a column this case does not remove. ++ QSqlQuery fixture(db); ++ QVERIFY_SQL(fixture, exec("DROP TABLE " + test)); ++ QVERIFY_SQL(fixture, exec("CREATE TABLE " + test ++ + "(id Int32, name Utf8, title Int32, PRIMARY KEY (title))")); ++ repopulateTestTables(); + + QSqlTableModel model(0, db); + model.setTable(test); +@@ -2077,8 +2086,8 @@ + const auto test = qTableName("test1", __FILE__, db); + + QSqlQuery q(db); +- QVERIFY_SQL( q, exec("insert into " + test + " values(9, 'andrew', 9)")); +- QVERIFY_SQL( q, exec("insert into " + test + " values(10, 'justin', 10)")); ++ QVERIFY_SQL( q, exec("insert into " + test + " (id, name, title) values(9, 'andrew', 9)")); ++ QVERIFY_SQL( q, exec("insert into " + test + " (id, name, title) values(10, 'justin', 10)")); + + QSqlTableModel model(0, db); + model.setTable(test); +@@ -2150,8 +2159,8 @@ + const auto fieldDot = qTableName("fieldDot", __FILE__, db); + tst_Databases::safeDropTable(db, fieldDot); + QSqlQuery qry(db); +- QVERIFY_SQL(qry, exec("create table " + fieldDot + " (id int primary key, " +- "\"person.firstname\" varchar(20))")); ++ QVERIFY_SQL(qry, exec("create table " + fieldDot + " (id int, " ++ "\"person.firstname\" Utf8, primary key (id))")); + QVERIFY_SQL(qry, exec("insert into " + fieldDot + " values(1, 'Andy')")); + QSqlTableModel model(0, db); + model.setTable(fieldDot); +@@ -2163,8 +2172,8 @@ + { + tst_Databases::safeDropTable(db, tableDot); + QSqlQuery qry(db); +- QVERIFY_SQL(qry, exec("create table " + tableDot + " (id int primary key, " +- "\"person.firstname\" varchar(20))")); ++ QVERIFY_SQL(qry, exec("create table " + tableDot + " (id int, " ++ "\"person.firstname\" Utf8, primary key (id))")); + QVERIFY_SQL(qry, exec("insert into " + tableDot + " values(1, 'Andy')")); + QSqlTableModel model(0, db); + model.setTable(tableDot); diff --git a/odbc/tests/frameworks/r/dbitest.patch b/odbc/tests/frameworks/r/dbitest.patch new file mode 100644 index 00000000000..9b3cfbef353 --- /dev/null +++ b/odbc/tests/frameworks/r/dbitest.patch @@ -0,0 +1,1019 @@ +--- a/R/spec-result-fetch.R ++++ b/R/spec-result-fetch.R +@@ -89,7 +89,7 @@ + #' Calling `dbFetch()` on a result set from a data manipulation query + #' created by [dbSendStatement()] + #' can be fetched and return an empty data frame, with a warning. +- query <- paste0("CREATE TABLE ", table_name, " (a integer)") ++ query <- paste0("CREATE TABLE ", table_name, " (a integer, PRIMARY KEY (a))") + + res <- local_result(dbSendStatement(con, query)) + expect_warning(rows <- check_df(dbFetch(res))) +--- a/R/spec-meta-get-statement.R ++++ b/R/spec-meta-get-statement.R +@@ -21,7 +21,7 @@ + }, + # + get_statement_statement = function(con, table_name) { +- query <- paste0("CREATE TABLE ", table_name, " (a integer)") ++ query <- paste0("CREATE TABLE ", table_name, " (a integer, PRIMARY KEY (a))") + #' or [dbSendStatement()]. + res <- local_result(dbSendStatement(con, query)) + s <- dbGetStatement(res) +--- a/R/spec-meta-has-completed.R ++++ b/R/spec-meta-has-completed.R +@@ -23,7 +23,7 @@ + # + has_completed_statement = function(con, table_name) { + #' For a query initiated by [dbSendStatement()], +- res <- local_result(dbSendStatement(con, paste0("CREATE TABLE ", table_name, " (a integer)"))) ++ res <- local_result(dbSendStatement(con, paste0("CREATE TABLE ", table_name, " (a integer, PRIMARY KEY (a))"))) + #' `dbHasCompleted()` always returns `TRUE`. + expect_true(expect_visible(dbHasCompleted(res))) + }, +--- a/R/spec-meta-get-rows-affected.R ++++ b/R/spec-meta-get-rows-affected.R +@@ -13,7 +13,7 @@ + #' @return + #' `dbGetRowsAffected()` returns a scalar number (integer or numeric), + #' the number of rows affected by a data manipulation statement +- dbWriteTable(con, table_name, data.frame(a = 1:10)) ++ dbWriteTable(con, table_name, data.frame(a = 1:10), field.types = ydb_field_types(con, data.frame(a = 1:10))) + + query <- paste0( + "DELETE FROM ", dbQuoteIdentifier(con, table_name), " ", +@@ -57,7 +57,7 @@ + get_rows_affected_error = function(con, table_name) { + #' @section Failure modes: + query <- paste0( +- "CREATE TABLE ", dbQuoteIdentifier(con, table_name), " (a integer)" ++ "CREATE TABLE ", dbQuoteIdentifier(con, table_name), " (a integer, PRIMARY KEY (a))" + ) + res <- dbSendStatement(con, query) + dbClearResult(res) +--- a/R/spec-meta-is-valid.R ++++ b/R/spec-meta-is-valid.R +@@ -44,7 +44,7 @@ + }, + # + is_valid_result_statement = function(con, table_name) { +- query <- paste0("CREATE TABLE ", table_name, " (a ", dbDataType(con, 1L), ")") ++ query <- paste0("CREATE TABLE ", table_name, " (a ", dbDataType(con, 1L), ", PRIMARY KEY (a))") + res <- dbSendStatement(con, query) + on.exit(dbClearResult(res)) + #' A [DBIResult-class] object is also valid after a call to [dbSendStatement()], +--- a/R/spec-result-create-table-with-data-type.R ++++ b/R/spec-result-create-table-with-data-type.R +@@ -12,7 +12,7 @@ + table_name <- random_table_name() + local_remove_test_table(con, table_name) + #' `"CREATE TABLE test (a ...)"`. +- query <- paste0("CREATE TABLE ", table_name, " (a ", dbDataType(con, value), ")") ++ query <- paste0("CREATE TABLE ", table_name, " (a ", dbDataType(con, value), ", ydb_fixture_id Int32, PRIMARY KEY (ydb_fixture_id))") + eval(bquote(dbExecute(con, .(query)))) + } + +--- a/R/spec-getting-started.R ++++ b/R/spec-getting-started.R +@@ -20,6 +20,7 @@ + }, + # + package_name = function(ctx) { ++ skip("Optional R-prefix package naming convention") + pkg_name <- package_name(ctx) + + #' For better or worse, the names of many existing backends start with +--- a/R/spec-result-roundtrip.R ++++ b/R/spec-result-roundtrip.R +@@ -23,7 +23,7 @@ + int_values <- 1:0 + values <- ctx$tweaks$logical_return(as.logical(int_values)) + +- sql_names <- paste0("CAST(", int_values, " AS ", dbDataType(con, logical()), ")") ++ sql_names <- paste0("CAST(", int_values, " AS Bool)") + + #' with NA for SQL `NULL` values + test_select_with_null(.ctx = ctx, con, .dots = setNames(values, sql_names)) +@@ -33,7 +33,7 @@ + #' - [character] for text, + values <- get_texts() + test_funs <- rep(list(has_utf8_or_ascii_encoding), length(values)) +- sql_names <- as.character(dbQuoteString(con, values)) ++ sql_names <- paste0("CAST(",as.character(dbQuoteString(con, values))," AS Utf8)") + + #' with NA for SQL `NULL` values + test_select_with_null(.ctx = ctx, con, .dots = setNames(values, sql_names)) +@@ -77,7 +77,7 @@ + #' (also applies to the return value of the SQL function `current_date`) + test_select_with_null( + .ctx = ctx, con, +- "current_date" ~ is_roughly_current_date ++ "CurrentUtcDate()" ~ is_roughly_current_date + ) + }, + +@@ -101,7 +101,7 @@ + #' (also applies to the return value of the SQL function `current_time`) + test_select_with_null( + .ctx = ctx, con, +- "current_time" ~ coercible_to_time ++ "CAST(DateTime::Format('%H:%M:%S')(CurrentUtcTimestamp()) AS Utf8)" ~ coercible_to_time + ) + }, + +@@ -124,7 +124,7 @@ + #' (also applies to the return value of the SQL function `current_timestamp`) + test_select_with_null( + .ctx = ctx, con, +- "current_timestamp" ~ function(x) { ++ "CurrentUtcTimestamp()" ~ function(x) { + coercible_to_timestamp <- function(x) { + x_timestamp <- try_silent(as.POSIXct(x)) + !is.null(x_timestamp) && all(is.na(x) == is.na(x_timestamp)) +@@ -159,7 +159,7 @@ + + test_select_with_null( + .ctx = ctx, con, +- "current_date" ~ is_roughly_current_date_typed ++ "CurrentUtcDate()" ~ is_roughly_current_date_typed + ) + }, + +@@ -184,7 +184,7 @@ + + test_select_with_null( + .ctx = ctx, con, +- "current_timestamp" ~ is_roughly_current_timestamp_typed ++ "CurrentUtcTimestamp()" ~ is_roughly_current_timestamp_typed + ) + }, + +--- a/R/spec-meta-get-row-count.R ++++ b/R/spec-meta-get-row-count.R +@@ -58,7 +58,7 @@ + }, + # + row_count_statement = function(con, table_name) { +- query <- paste0("CREATE TABLE ", table_name, " (a integer)") ++ query <- paste0("CREATE TABLE ", table_name, " (a integer, PRIMARY KEY (a))") + #' For data manipulation statements issued with + #' [dbSendStatement()], + res <- local_result(dbSendStatement(con, query)) +--- a/R/spec-meta-bind-runner.R ++++ b/R/spec-meta-bind-runner.R +@@ -104,5 +104,5 @@ + }) else expr({ +- data <- data.frame(a = rep(1:5, 1:5), b = 1:15) ++ data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE) ++ dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) + +--- a/R/spec-meta-bind.R ++++ b/R/spec-meta-bind.R +@@ -41,5 +41,5 @@ + names(bind_values) <- names(placeholder) +- data <- data.frame(a = rep(1:5, 1:5), b = 1:15) ++ data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE) ++ dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) + sql <- paste0("UPDATE ", dbQuoteIdentifier(con, table_name), " SET b = b + 1 WHERE ") +@@ -136,5 +136,5 @@ + } +- data <- data.frame(a = rep(1:5, 1:5), b = 1:15) ++ data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE) ++ dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) + sql <- paste0("UPDATE ", dbQuoteIdentifier(con, table_name), " SET b = b + 1 WHERE ") +@@ -300,5 +300,5 @@ + names(bind_values) <- names(placeholder) +- data <- data.frame(a = rep(1:5, 1:5), b = 1:15) ++ data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE) ++ dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) + sql <- paste0("UPDATE ", dbQuoteIdentifier(con, table_name), " SET b = b + 1 WHERE ") +@@ -351,5 +351,5 @@ + names(bind_values) <- names(placeholder) +- data <- data.frame(a = rep(1:5, 1:5), b = 1:15) ++ data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE) ++ dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) + sql <- paste0("UPDATE ", dbQuoteIdentifier(con, table_name), " SET b = b + 1 WHERE ") +@@ -403,5 +403,5 @@ + names(bind_values) <- names(placeholder) +- data <- data.frame(a = rep(1:5, 1:5), b = 1:15) ++ data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE) ++ dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) + sql <- paste0("UPDATE ", dbQuoteIdentifier(con, table_name), " SET b = b + 1 WHERE ") +--- a/R/spec-meta-column-info.R ++++ b/R/spec-meta-column-info.R +@@ -15,3 +15,3 @@ + penguins <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins) ++ dbWriteTable(con, table_name, penguins, field.types = ydb_field_types(con, penguins)) + +@@ -53,3 +53,3 @@ + #' A column named `row_names` is treated like any other column. +- dbWriteTable(con, table_name, data.frame(a = 1L, row_names = 2L)) ++ dbWriteTable(con, table_name, data.frame(a = 1L, row_names = 2L), field.types = ydb_field_types(con, data.frame(a = 1L, row_names = 2L))) + res <- local_result(dbSendQuery(con, paste0("SELECT * FROM ", table_name))) +--- a/R/spec-result-execute.R ++++ b/R/spec-result-execute.R +@@ -70,3 +70,3 @@ + local_remove_test_table(con, table_name) +- dbWriteTable(con, table_name, data.frame(a = as.numeric(1:3))) ++ dbWriteTable(con, table_name, ydb_keyed_fixture(data.frame(a = as.numeric(1:3))), field.types = ydb_field_types(con, ydb_keyed_fixture(data.frame(a = as.numeric(1:3))))) + placeholder <- placeholder_fun(1) +--- a/R/spec-result-send-statement.R ++++ b/R/spec-result-send-statement.R +@@ -114,3 +114,3 @@ + local_remove_test_table(con, table_name) +- dbWriteTable(con, table_name, data.frame(a = as.numeric(1:3))) ++ dbWriteTable(con, table_name, ydb_keyed_fixture(data.frame(a = as.numeric(1:3))), field.types = ydb_field_types(con, ydb_keyed_fixture(data.frame(a = as.numeric(1:3))))) + placeholder <- placeholder_fun(1) +--- a/R/spec-sql-append-table.R ++++ b/R/spec-sql-append-table.R +@@ -14,4 +14,4 @@ + #' `dbAppendTable()` returns a +- test_in <- trivial_df() +- dbCreateTable(con, table_name, test_in) ++ test_in <- ydb_keyed_fixture(trivial_df()) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + ret <- dbAppendTable(con, table_name, test_in) +@@ -35,4 +35,4 @@ + #' an error is raised; the remote table remains unchanged. +- test_in <- trivial_df() +- dbCreateTable(con, table_name, test_in) ++ test_in <- ydb_keyed_fixture(trivial_df()) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + expect_error(dbAppendTable(con, table_name, unclass(test_in))) +@@ -43,4 +43,4 @@ + append_table_append_incompatible = function(con, table_name) { +- test_in <- trivial_df() +- dbCreateTable(con, table_name, test_in) ++ test_in <- ydb_keyed_fixture(trivial_df()) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + dbAppendTable(con, table_name, test_in) +@@ -220,4 +220,4 @@ + append_roundtrip_64_bit_roundtrip = function(con, table_name) { +- tbl_in <- data.frame(a = c(-1e14, 1e15)) +- dbWriteTable(con, table_name, tbl_in, field.types = c(a = "BIGINT")) ++ tbl_in <- ydb_keyed_fixture(data.frame(a = c(-1e14, 1e15))) ++ dbWriteTable(con, table_name, tbl_in, field.types = ydb_field_types(con, tbl_in, c(a = "BIGINT"))) + tbl_out <- dbReadTable(con, table_name) +@@ -495,3 +495,3 @@ + for (table_name in table_names) { +- test_in <- trivial_df() ++ test_in <- ydb_keyed_fixture(trivial_df()) + +@@ -499,3 +499,3 @@ + #' - If an unquoted table name as string: `dbAppendTable()` will do the quoting, +- dbCreateTable(con, table_name, test_in) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + dbAppendTable(con, table_name, test_in) +@@ -519,6 +519,6 @@ + for (table_name in table_names) { +- test_in <- trivial_df() ++ test_in <- ydb_keyed_fixture(trivial_df()) + + local_remove_test_table(con, table_name) +- dbCreateTable(con, dbQuoteIdentifier(con, table_name), test_in) ++ dbCreateTable(con, dbQuoteIdentifier(con, table_name), test_in, field.types = ydb_field_types(con, test_in)) + dbAppendTable(con, dbQuoteIdentifier(con, table_name), test_in) +@@ -533,4 +533,4 @@ + #' The `row.names` argument must be `NULL`, the default value. +- mtcars_in <- datasets::mtcars +- dbCreateTable(con, table_name, mtcars_in) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbCreateTable(con, table_name, mtcars_in, field.types = ydb_field_types(con, mtcars_in)) + dbAppendTable(con, table_name, mtcars_in) +@@ -544,4 +544,4 @@ + #' Row names are ignored. +- mtcars_in <- datasets::mtcars +- dbCreateTable(con, table_name, mtcars_in) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbCreateTable(con, table_name, mtcars_in, field.types = ydb_field_types(con, mtcars_in)) + dbAppendTable(con, table_name, mtcars_in, row.names = NULL) +@@ -557,4 +557,4 @@ + #' Passing a `value` argument different to `NULL` to the `row.names` argument +- mtcars_in <- datasets::mtcars +- dbCreateTable(con, table_name, mtcars_in) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbCreateTable(con, table_name, mtcars_in, field.types = ydb_field_types(con, mtcars_in)) + +@@ -574,4 +574,4 @@ + #' The `value` argument must be a data frame +- test_in <- trivial_df() +- dbCreateTable(con, table_name, test_in) ++ test_in <- ydb_keyed_fixture(trivial_df()) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + dbAppendTable(con, table_name, test_in) +@@ -584,5 +584,5 @@ + #' with a subset of the columns of the existing table. +- test_in <- trivial_df(3, letters[1:3]) +- dbCreateTable(con, table_name, test_in) +- dbAppendTable(con, table_name, test_in[2]) ++ test_in <- ydb_keyed_fixture(trivial_df(3, letters[1:3])) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) ++ dbAppendTable(con, table_name, test_in[c(2, 4)]) + +@@ -596,5 +596,5 @@ + #' The order of the columns does not matter. +- test_in <- trivial_df(3, letters[1:3]) +- dbCreateTable(con, table_name, test_in) +- dbAppendTable(con, table_name, test_in[c(2, 3, 1)]) ++ test_in <- ydb_keyed_fixture(trivial_df(3, letters[1:3])) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) ++ dbAppendTable(con, table_name, test_in[c(2, 3, 1, 4)]) + +@@ -606,5 +606,5 @@ + append_table_value_shuffle_subset = function(ctx, con, table_name) { +- test_in <- trivial_df(4, letters[1:4]) +- dbCreateTable(con, table_name, test_in) +- dbAppendTable(con, table_name, test_in[c(4, 1, 3)]) ++ test_in <- ydb_keyed_fixture(trivial_df(4, letters[1:4])) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) ++ dbAppendTable(con, table_name, test_in[c(4, 1, 3, 5)]) + +--- a/R/spec-sql-create-table.R ++++ b/R/spec-sql-create-table.R +@@ -14,3 +14,3 @@ + #' `dbCreateTable()` returns `TRUE`, invisibly. +- expect_invisible_true(dbCreateTable(con, table_name, trivial_df())) ++ expect_invisible_true(dbCreateTable(con, table_name, ydb_keyed_fixture(trivial_df()), field.types = ydb_field_types(con, ydb_keyed_fixture(trivial_df())))) + }, +@@ -21,5 +21,5 @@ + #' If the table exists, an error is raised; the remote table remains unchanged. +- test_in <- trivial_df() +- +- dbCreateTable(con, table_name, test_in) ++ test_in <- ydb_keyed_fixture(trivial_df()) ++ ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + dbAppendTable(con, table_name, test_in) +@@ -90,3 +90,3 @@ + for (table_name in table_names) { +- test_in <- trivial_df() ++ test_in <- ydb_keyed_fixture(trivial_df()) + +@@ -94,3 +94,3 @@ + #' - If an unquoted table name as string: `dbCreateTable()` will do the quoting, +- dbCreateTable(con, table_name, test_in) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + test_out <- check_df(dbReadTable(con, dbQuoteIdentifier(con, table_name))) +@@ -112,6 +112,6 @@ + for (table_name in table_names) { +- test_in <- trivial_df() ++ test_in <- ydb_keyed_fixture(trivial_df()) + + local_remove_test_table(con, table_name) +- dbCreateTable(con, dbQuoteIdentifier(con, table_name), test_in) ++ dbCreateTable(con, dbQuoteIdentifier(con, table_name), test_in, field.types = ydb_field_types(con, test_in)) + test_out <- check_df(dbReadTable(con, table_name)) +@@ -131,3 +131,3 @@ + penguins <- get_penguins(ctx) +- dbCreateTable(con, table_name, penguins, temporary = TRUE) ++ dbCreateTable(con, table_name, penguins, temporary = TRUE, field.types = ydb_field_types(con, penguins)) + penguins_out <- check_df(dbReadTable(con, table_name)) +@@ -149,3 +149,3 @@ + table_name <- "dbit04" +- dbCreateTable(local_con, table_name, penguins) ++ dbCreateTable(local_con, table_name, penguins, field.types = ydb_field_types(local_con, penguins)) + penguins_out <- check_df(dbReadTable(local_con, table_name)) +@@ -207,4 +207,4 @@ + #' The `row.names` argument must be missing +- mtcars_in <- datasets::mtcars +- dbCreateTable(con, table_name, mtcars_in) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbCreateTable(con, table_name, mtcars_in, field.types = ydb_field_types(con, mtcars_in)) + mtcars_out <- check_df(dbReadTable(con, table_name, row.names = FALSE)) +@@ -216,4 +216,4 @@ + #' or `NULL`, the default value. +- mtcars_in <- datasets::mtcars +- dbCreateTable(con, table_name, mtcars_in, row.names = NULL) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbCreateTable(con, table_name, mtcars_in, row.names = NULL, field.types = ydb_field_types(con, mtcars_in, row.names = NULL)) + mtcars_out <- check_df(dbReadTable(con, table_name, row.names = NULL)) +@@ -226,3 +226,3 @@ + #' All other values for the `row.names` argument +- mtcars_in <- datasets::mtcars ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) + +--- a/R/spec-sql-exists-table.R ++++ b/R/spec-sql-exists-table.R +@@ -17,3 +17,3 @@ + penguins <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins) ++ dbWriteTable(con, table_name, penguins, field.types = ydb_field_types(con, penguins)) + +@@ -33,3 +33,3 @@ + if (isTRUE(ctx$tweaks$temporary_tables)) { +- dbWriteTable(con, table_name, data.frame(a = 1L), temporary = TRUE) ++ dbWriteTable(con, table_name, data.frame(a = 1L), temporary = TRUE, field.types = ydb_field_types(con, data.frame(a = 1L))) + expect_true(expect_visible(dbExistsTable(con, table_name))) +@@ -52,3 +52,3 @@ + #' An error is also raised +- dbWriteTable(con, table_name, data.frame(a = 1L)) ++ dbWriteTable(con, table_name, data.frame(a = 1L), field.types = ydb_field_types(con, data.frame(a = 1L))) + #' if `name` cannot be processed with [dbQuoteIdentifier()] +@@ -74,3 +74,3 @@ + test_in <- data.frame(a = 1L) +- dbWriteTable(con, table_name, test_in) ++ dbWriteTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + +@@ -88,3 +88,3 @@ + #' For all tables listed by [dbListTables()], `dbExistsTable()` returns `TRUE`. +- dbWriteTable(con, table_name, data.frame(a = 1)) ++ dbWriteTable(con, table_name, ydb_keyed_fixture(data.frame(a = 1)), field.types = ydb_field_types(con, ydb_keyed_fixture(data.frame(a = 1)))) + for (table_name in dbListTables(con)) { +--- a/R/spec-sql-list-fields.R ++++ b/R/spec-sql-list-fields.R +@@ -15,3 +15,3 @@ + penguins <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins) ++ dbWriteTable(con, table_name, penguins, field.types = ydb_field_types(con, penguins)) + +@@ -27,3 +27,3 @@ + if (isTRUE(ctx$tweaks$temporary_tables) && isTRUE(ctx$tweaks$list_temporary_tables)) { +- dbWriteTable(con, table_name, data.frame(a = 1L, b = 2L), temporary = TRUE) ++ dbWriteTable(con, table_name, data.frame(a = 1L, b = 2L), temporary = TRUE, field.types = ydb_field_types(con, data.frame(a = 1L, b = 2L))) + fields <- dbListFields(con, table_name) +@@ -73,3 +73,3 @@ + #' - the return value of [dbQuoteIdentifier()] +- dbWriteTable(con, table_name, data.frame(a = 1L, b = 2L)) ++ dbWriteTable(con, table_name, data.frame(a = 1L, b = 2L), field.types = ydb_field_types(con, data.frame(a = 1L, b = 2L))) + expect_identical( +@@ -83,3 +83,3 @@ + #' [dbListObjects()] where `is_prefix` is `FALSE` +- dbWriteTable(con, table_name, data.frame(a = 1L, b = 2L)) ++ dbWriteTable(con, table_name, data.frame(a = 1L, b = 2L), field.types = ydb_field_types(con, data.frame(a = 1L, b = 2L))) + objects <- dbListObjects(con) +@@ -96,3 +96,3 @@ + #' A column named `row_names` is treated like any other column. +- dbWriteTable(con, table_name, data.frame(a = 1L, row_names = 2L)) ++ dbWriteTable(con, table_name, data.frame(a = 1L, row_names = 2L), field.types = ydb_field_types(con, data.frame(a = 1L, row_names = 2L))) + expect_identical(dbListFields(con, table_name), c("a", "row_names")) +--- a/R/spec-sql-list-objects.R ++++ b/R/spec-sql-list-objects.R +@@ -41,3 +41,3 @@ + penguins <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins) ++ dbWriteTable(con, table_name, penguins, field.types = ydb_field_types(con, penguins)) + +@@ -63,3 +63,3 @@ + if (isTRUE(ctx$tweaks$temporary_tables) && isTRUE(ctx$tweaks$list_temporary_tables)) { +- dbWriteTable(con, table_name, data.frame(a = 1L), temporary = TRUE) ++ dbWriteTable(con, table_name, data.frame(a = 1L), temporary = TRUE, field.types = ydb_field_types(con, data.frame(a = 1L))) + +@@ -82,3 +82,3 @@ + local_remove_test_table(con, table_name) +- dbWriteTable(con, dbQuoteIdentifier(con, table_name), data.frame(a = 2L)) ++ dbWriteTable(con, dbQuoteIdentifier(con, table_name), data.frame(a = 2L), field.types = ydb_field_types(con, data.frame(a = 2L))) + objects <- dbListObjects(con) +--- a/R/spec-sql-list-tables.R ++++ b/R/spec-sql-list-tables.R +@@ -26,3 +26,3 @@ + penguins <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins) ++ dbWriteTable(con, table_name, penguins, field.types = ydb_field_types(con, penguins)) + +@@ -44,3 +44,3 @@ + if (isTRUE(ctx$tweaks$temporary_tables) && isTRUE(ctx$tweaks$list_temporary_tables)) { +- dbWriteTable(con, table_name, data.frame(a = 1L), temporary = TRUE) ++ dbWriteTable(con, table_name, data.frame(a = 1L), temporary = TRUE, field.types = ydb_field_types(con, data.frame(a = 1L))) + tables <- dbListTables(con) +@@ -61,3 +61,3 @@ + local_remove_test_table(con, table_name) +- dbWriteTable(con, dbQuoteIdentifier(con, table_name), data.frame(a = 2L)) ++ dbWriteTable(con, dbQuoteIdentifier(con, table_name), data.frame(a = 2L), field.types = ydb_field_types(con, data.frame(a = 2L))) + tables <- dbListTables(con) +--- a/R/spec-sql-read-table.R ++++ b/R/spec-sql-read-table.R +@@ -17,3 +17,3 @@ + penguins_in <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins_in) ++ dbWriteTable(con, table_name, penguins_in, field.types = ydb_field_types(con, penguins_in)) + penguins_out <- check_df(dbReadTable(con, table_name)) +@@ -35,3 +35,3 @@ + penguins_in <- get_penguins(ctx)[integer(), ] +- dbWriteTable(con, table_name, penguins_in) ++ dbWriteTable(con, table_name, penguins_in, field.types = ydb_field_types(con, penguins_in)) + penguins_out <- check_df(dbReadTable(con, table_name)) +@@ -50,4 +50,4 @@ + local_remove_test_table(con, table_name) +- mtcars_in <- datasets::mtcars +- dbWriteTable(con, table_name, mtcars_in, row.names = TRUE) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbWriteTable(con, table_name, mtcars_in, row.names = TRUE, field.types = ydb_field_types(con, mtcars_in, row.names = TRUE)) + mtcars_out <- check_df(dbReadTable(con, table_name, row.names = row.names)) +@@ -65,4 +65,4 @@ + +- mtcars_in <- datasets::mtcars +- dbWriteTable(con, table_name, mtcars_in, row.names = NA) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbWriteTable(con, table_name, mtcars_in, row.names = NA, field.types = ydb_field_types(con, mtcars_in, row.names = NA)) + mtcars_out <- check_df(dbReadTable(con, table_name, row.names = row.names)) +@@ -78,3 +78,3 @@ + penguins_in <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins_in, row.names = NA) ++ dbWriteTable(con, table_name, penguins_in, row.names = NA, field.types = ydb_field_types(con, penguins_in, row.names = NA)) + expect_error(dbReadTable(con, table_name, row.names = row.names)) +@@ -87,4 +87,4 @@ + +- mtcars_in <- datasets::mtcars +- dbWriteTable(con, table_name, mtcars_in, row.names = TRUE) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbWriteTable(con, table_name, mtcars_in, row.names = TRUE, field.types = ydb_field_types(con, mtcars_in, row.names = TRUE)) + mtcars_out <- check_df(dbReadTable(con, table_name, row.names = row.names)) +@@ -99,3 +99,3 @@ + penguins_in <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins_in, row.names = FALSE) ++ dbWriteTable(con, table_name, penguins_in, row.names = FALSE, field.types = ydb_field_types(con, penguins_in, row.names = FALSE)) + penguins_out <- check_df(dbReadTable(con, table_name, row.names = row.names)) +@@ -110,3 +110,3 @@ + +- mtcars_in <- datasets::mtcars ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) + mtcars_in$make_model <- rownames(mtcars_in) +@@ -114,3 +114,3 @@ + +- dbWriteTable(con, table_name, mtcars_in, row.names = FALSE) ++ dbWriteTable(con, table_name, mtcars_in, row.names = FALSE, field.types = ydb_field_types(con, mtcars_in, row.names = FALSE)) + mtcars_out <- check_df(dbReadTable(con, table_name, row.names = row.names)) +@@ -129,3 +129,3 @@ + penguins_in <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins_in, row.names = FALSE) ++ dbWriteTable(con, table_name, penguins_in, row.names = FALSE, field.types = ydb_field_types(con, penguins_in, row.names = FALSE)) + expect_error(dbReadTable(con, table_name, row.names = row.names)) +@@ -137,4 +137,4 @@ + #' +- mtcars_in <- datasets::mtcars +- dbWriteTable(con, table_name, mtcars_in, row.names = TRUE) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbWriteTable(con, table_name, mtcars_in, row.names = TRUE, field.types = ydb_field_types(con, mtcars_in, row.names = TRUE)) + mtcars_out <- check_df(dbReadTable(con, table_name)) +@@ -158,3 +158,3 @@ + names(test_in) <- c("with spaces", "with,comma") +- dbWriteTable(con, table_name, test_in) ++ dbWriteTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + #' if the `check.names` argument is `TRUE`, +@@ -174,3 +174,3 @@ + names(test_in) <- c("with spaces", "with,comma") +- dbWriteTable(con, table_name, test_in) ++ dbWriteTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + test_out <- check_df(dbReadTable(con, table_name, check.names = FALSE)) +@@ -184,3 +184,3 @@ + #' An error is raised when calling this method for a closed +- dbWriteTable(con, table_name, data.frame(a = 1)) ++ dbWriteTable(con, table_name, ydb_keyed_fixture(data.frame(a = 1)), field.types = ydb_field_types(con, ydb_keyed_fixture(data.frame(a = 1)))) + con2 <- local_closed_connection(ctx = ctx) +@@ -191,3 +191,3 @@ + #' or invalid connection. +- dbWriteTable(con, table_name, data.frame(a = 1)) ++ dbWriteTable(con, table_name, ydb_keyed_fixture(data.frame(a = 1)), field.types = ydb_field_types(con, ydb_keyed_fixture(data.frame(a = 1)))) + con2 <- local_invalid_connection(ctx) +@@ -198,3 +198,3 @@ + #' An error is raised +- dbWriteTable(con, table_name, data.frame(a = 1L)) ++ dbWriteTable(con, table_name, data.frame(a = 1L), field.types = ydb_field_types(con, data.frame(a = 1L))) + #' if `name` cannot be processed with [dbQuoteIdentifier()] +@@ -238,3 +238,3 @@ + test_in <- data.frame(a = 1L) +- dbWriteTable(con, table_name, test_in) ++ dbWriteTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + +--- a/R/spec-sql-remove-table.R ++++ b/R/spec-sql-remove-table.R +@@ -15,3 +15,3 @@ + penguins <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins) ++ dbWriteTable(con, table_name, penguins, field.types = ydb_field_types(con, penguins)) + +@@ -32,3 +32,3 @@ + #' An error is raised when calling this method for a closed +- dbWriteTable(con, table_name, data.frame(a = 1)) ++ dbWriteTable(con, table_name, ydb_keyed_fixture(data.frame(a = 1)), field.types = ydb_field_types(con, ydb_keyed_fixture(data.frame(a = 1)))) + con2 <- local_closed_connection(ctx = ctx) +@@ -39,3 +39,3 @@ + #' or invalid connection. +- dbWriteTable(con, table_name, data.frame(a = 1)) ++ dbWriteTable(con, table_name, ydb_keyed_fixture(data.frame(a = 1)), field.types = ydb_field_types(con, ydb_keyed_fixture(data.frame(a = 1)))) + con2 <- local_invalid_connection(ctx) +@@ -46,3 +46,3 @@ + #' An error is also raised +- dbWriteTable(con, table_name, data.frame(a = 1L)) ++ dbWriteTable(con, table_name, data.frame(a = 1L), field.types = ydb_field_types(con, data.frame(a = 1L))) + #' if `name` cannot be processed with [dbQuoteIdentifier()] +@@ -72,5 +72,5 @@ + +- dbWriteTable(con, table_name, data.frame(a = 1.5)) +- expect_equal(dbReadTable(con, table_name), data.frame(a = 1.5)) +- dbCreateTable(con, table_name, data.frame(b = 2.5), temporary = TRUE) ++ dbWriteTable(con, table_name, ydb_keyed_fixture(data.frame(a = 1.5)), field.types = ydb_field_types(con, ydb_keyed_fixture(data.frame(a = 1.5)))) ++ expect_equal(dbReadTable(con, table_name), ydb_keyed_fixture(data.frame(a = 1.5))) ++ dbCreateTable(con, table_name, ydb_keyed_fixture(data.frame(b = 2.5)), temporary = TRUE, field.types = ydb_field_types(con, ydb_keyed_fixture(data.frame(b = 2.5)))) + dbRemoveTable(con, table_name, temporary = TRUE) +@@ -78,3 +78,3 @@ + expect_error(dbRemoveTable(con, table_name, temporary = TRUE)) +- expect_equal(dbReadTable(con, table_name), data.frame(a = 1.5)) ++ expect_equal(dbReadTable(con, table_name), ydb_keyed_fixture(data.frame(a = 1.5))) + }, +@@ -93,3 +93,3 @@ + #' and [dbExistsTable()] returns `FALSE`. +- dbWriteTable(con, table_name, data.frame(a = 1L)) ++ dbWriteTable(con, table_name, data.frame(a = 1L), field.types = ydb_field_types(con, data.frame(a = 1L))) + expect_true(table_name %in% dbListTables(con)) +@@ -105,3 +105,3 @@ + con2 <- local_connection(ctx) +- dbWriteTable(con, table_name, data.frame(a = 1L)) ++ dbWriteTable(con, table_name, data.frame(a = 1L), field.types = ydb_field_types(con, data.frame(a = 1L))) + expect_true(table_name %in% dbListTables(con2)) +@@ -120,3 +120,3 @@ + +- dbWriteTable(con, table_name, data.frame(a = 1L), temporary = TRUE) ++ dbWriteTable(con, table_name, data.frame(a = 1L), temporary = TRUE, field.types = ydb_field_types(con, data.frame(a = 1L))) + if (isTRUE(ctx$tweaks$list_temporary_tables)) { +@@ -149,3 +149,3 @@ + #' quoting, +- dbWriteTable(con, table_name, test_in) ++ dbWriteTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + expect_true(dbRemoveTable(con, table_name)) +@@ -169,3 +169,3 @@ + local_remove_test_table(con, table_name) +- dbWriteTable(con, table_name, test_in) ++ dbWriteTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + expect_true(dbRemoveTable(con, dbQuoteIdentifier(con, table_name))) +--- a/R/spec-sql-write-table.R ++++ b/R/spec-sql-write-table.R +@@ -15,3 +15,3 @@ + #' `dbWriteTable()` returns `TRUE`, invisibly. +- expect_invisible_true(dbWriteTable(con, table_name, data.frame(a = 1L))) ++ expect_invisible_true(dbWriteTable(con, table_name, data.frame(a = 1L), field.types = ydb_field_types(con, data.frame(a = 1L)))) + }, +@@ -23,3 +23,3 @@ + test_in <- data.frame(a = 1L) +- dbWriteTable(con, table_name, test_in) ++ dbWriteTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + expect_error(dbWriteTable(con, table_name, data.frame(a = 2L))) +@@ -35,3 +35,3 @@ + test_in <- data.frame(a = 1L) +- dbWriteTable(con, table_name, test_in) ++ dbWriteTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + expect_error(dbWriteTable(con, table_name, data.frame(b = 2L), append = TRUE)) +@@ -90,3 +90,3 @@ + #' incompatible columns) +- dbWriteTable(con, table_name, test_in) ++ dbWriteTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + expect_error(dbWriteTable(con, table_name, data.frame(b = 2L, c = 3L), append = TRUE)) +@@ -120,6 +120,6 @@ + for (table_name in table_names) { +- test_in <- data.frame(a = 1) ++ test_in <- ydb_keyed_fixture(data.frame(a = 1)) + local_remove_test_table(con, table_name) + #' - If an unquoted table name as string: `dbWriteTable()` will do the quoting, +- dbWriteTable(con, table_name, test_in) ++ dbWriteTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + test_out <- check_df(dbReadTable(con, dbQuoteIdentifier(con, table_name))) +@@ -141,6 +141,6 @@ + for (table_name in table_names) { +- test_in <- data.frame(a = 1) ++ test_in <- ydb_keyed_fixture(data.frame(a = 1)) + + local_remove_test_table(con, table_name) +- dbWriteTable(con, dbQuoteIdentifier(con, table_name), test_in) ++ dbWriteTable(con, dbQuoteIdentifier(con, table_name), test_in, field.types = ydb_field_types(con, test_in)) + test_out <- check_df(dbReadTable(con, table_name)) +@@ -153,4 +153,4 @@ + #' The `value` argument must be a data frame +- test_in <- trivial_df() +- dbWriteTable(con, table_name, test_in) ++ test_in <- ydb_keyed_fixture(trivial_df()) ++ dbWriteTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) + +@@ -162,5 +162,5 @@ + #' with a subset of the columns of the existing table if `append = TRUE`. +- test_in <- trivial_df(3, letters[1:3]) +- dbCreateTable(con, table_name, test_in) +- dbWriteTable(con, table_name, test_in[2], append = TRUE) ++ test_in <- ydb_keyed_fixture(trivial_df(3, letters[1:3])) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) ++ dbWriteTable(con, table_name, test_in[c(2, 4)], append = TRUE) + +@@ -174,5 +174,5 @@ + #' The order of the columns does not matter with `append = TRUE`. +- test_in <- trivial_df(3, letters[1:3]) +- dbCreateTable(con, table_name, test_in) +- dbWriteTable(con, table_name, test_in[c(2, 3, 1)], append = TRUE) ++ test_in <- ydb_keyed_fixture(trivial_df(3, letters[1:3])) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) ++ dbWriteTable(con, table_name, test_in[c(2, 3, 1, 4)], append = TRUE) + +@@ -184,5 +184,5 @@ + write_table_value_shuffle_subset = function(ctx, con, table_name) { +- test_in <- trivial_df(4, letters[1:4]) +- dbCreateTable(con, table_name, test_in) +- dbWriteTable(con, table_name, test_in[c(4, 1, 3)], append = TRUE) ++ test_in <- ydb_keyed_fixture(trivial_df(4, letters[1:4])) ++ dbCreateTable(con, table_name, test_in, field.types = ydb_field_types(con, test_in)) ++ dbWriteTable(con, table_name, test_in[c(4, 1, 3, 5)], append = TRUE) + +@@ -199,5 +199,5 @@ + penguins <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins) ++ dbWriteTable(con, table_name, penguins, field.types = ydb_field_types(con, penguins)) + expect_error( +- dbWriteTable(con, table_name, penguins[1, ], overwrite = TRUE), ++ dbWriteTable(con, table_name, penguins[1, ], overwrite = TRUE, field.types = ydb_field_types(con, penguins[1, ])), + NA +@@ -212,3 +212,3 @@ + expect_error( +- dbWriteTable(con, table_name, penguins_in[1, ], overwrite = TRUE), ++ dbWriteTable(con, table_name, penguins_in[1, ], overwrite = TRUE, field.types = ydb_field_types(con, penguins_in[1, ])), + NA +@@ -224,6 +224,8 @@ + penguins <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins) +- expect_error(dbWriteTable(con, table_name, penguins[1, ], append = TRUE), NA) ++ dbWriteTable(con, table_name, penguins, field.types = ydb_field_types(con, penguins)) ++ appended <- penguins[1, ] ++ appended$ydb_fixture_id <- nrow(penguins) + 1L ++ expect_error(dbWriteTable(con, table_name, appended, append = TRUE), NA) + penguins_out <- check_df(dbReadTable(con, table_name)) +- expect_equal_df(penguins_out, rbind(penguins, penguins[1, ])) ++ expect_equal_df(penguins_out, rbind(penguins, appended)) + }, +@@ -248,3 +250,3 @@ + penguins <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins, temporary = TRUE) ++ dbWriteTable(con, table_name, penguins, temporary = TRUE, field.types = ydb_field_types(con, penguins)) + penguins_out <- check_df(dbReadTable(con, table_name)) +@@ -271,3 +273,3 @@ + +- dbWriteTable(local_con, table_name, penguins30) ++ dbWriteTable(local_con, table_name, penguins30, field.types = ydb_field_types(local_con, penguins30)) + penguins_out <- check_df(dbReadTable(local_con, table_name)) +@@ -431,4 +433,4 @@ + roundtrip_64_bit_roundtrip = function(con, table_name) { +- tbl_in <- data.frame(a = c(-1e14, 1e15)) +- dbWriteTable(con, table_name, tbl_in, field.types = c(a = "BIGINT")) ++ tbl_in <- ydb_keyed_fixture(data.frame(a = c(-1e14, 1e15))) ++ dbWriteTable(con, table_name, tbl_in, field.types = ydb_field_types(con, tbl_in, c(a = "BIGINT"))) + tbl_out <- dbReadTable(con, table_name) +@@ -714,4 +716,4 @@ + local_remove_test_table(con, table_name) +- mtcars_in <- datasets::mtcars +- dbWriteTable(con, table_name, mtcars_in, row.names = row.names) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbWriteTable(con, table_name, mtcars_in, row.names = row.names, field.types = ydb_field_types(con, mtcars_in, row.names = row.names)) + mtcars_out <- check_df(dbReadTable(con, table_name, row.names = FALSE)) +@@ -727,4 +729,4 @@ + +- mtcars_in <- datasets::mtcars +- dbWriteTable(con, table_name, mtcars_in, row.names = row.names) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbWriteTable(con, table_name, mtcars_in, row.names = row.names, field.types = ydb_field_types(con, mtcars_in, row.names = row.names)) + mtcars_out <- check_df(dbReadTable(con, table_name, row.names = FALSE)) +@@ -742,3 +744,3 @@ + penguins_in <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins_in, row.names = row.names) ++ dbWriteTable(con, table_name, penguins_in, row.names = row.names, field.types = ydb_field_types(con, penguins_in, row.names = row.names)) + penguins_out <- check_df(dbReadTable(con, table_name, row.names = FALSE)) +@@ -755,4 +757,4 @@ + +- mtcars_in <- datasets::mtcars +- dbWriteTable(con, table_name, mtcars_in, row.names = row.names) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbWriteTable(con, table_name, mtcars_in, row.names = row.names, field.types = ydb_field_types(con, mtcars_in, row.names = row.names)) + mtcars_out <- check_df(dbReadTable(con, table_name, row.names = FALSE)) +@@ -770,3 +772,3 @@ + penguins_in <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins_in, row.names = row.names) ++ dbWriteTable(con, table_name, penguins_in, row.names = row.names, field.types = ydb_field_types(con, penguins_in, row.names = row.names)) + penguins_out <- check_df(dbReadTable(con, table_name, row.names = FALSE)) +@@ -781,5 +783,5 @@ + +- mtcars_in <- datasets::mtcars +- +- dbWriteTable(con, table_name, mtcars_in, row.names = row.names) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ ++ dbWriteTable(con, table_name, mtcars_in, row.names = row.names, field.types = ydb_field_types(con, mtcars_in, row.names = row.names)) + mtcars_out <- check_df(dbReadTable(con, table_name, row.names = FALSE)) +@@ -797,3 +799,3 @@ + penguins_in <- get_penguins(ctx) +- dbWriteTable(con, table_name, penguins_in, row.names = row.names) ++ dbWriteTable(con, table_name, penguins_in, row.names = row.names, field.types = ydb_field_types(con, penguins_in, row.names = row.names)) + penguins_out <- check_df(dbReadTable(con, table_name, row.names = FALSE)) +@@ -809,4 +811,4 @@ + #' The default is `row.names = FALSE`. +- mtcars_in <- datasets::mtcars +- dbWriteTable(con, table_name, mtcars_in) ++ mtcars_in <- ydb_keyed_fixture(datasets::mtcars) ++ dbWriteTable(con, table_name, mtcars_in, field.types = ydb_field_types(con, mtcars_in)) + mtcars_out <- check_df(dbReadTable(con, table_name, row.names = FALSE)) +@@ -844,2 +846,6 @@ + ++ tbl_in <- ydb_keyed_fixture(tbl_in) ++ tbl_expected <- ydb_keyed_fixture(tbl_expected) ++ field.types <- ydb_field_types(con, tbl_in, field.types) ++ + if (is.null(name)) { +@@ -851,3 +857,3 @@ + if (use_append) { +- dbCreateTable(con, name, field.types %||% tbl_in) ++ dbCreateTable(con, name, tbl_in, field.types = field.types) + dbAppendTable(con, name, tbl_in) +--- a/R/spec-transaction-begin-commit-rollback.R ++++ b/R/spec-transaction-begin-commit-rollback.R +@@ -101,3 +101,3 @@ + table_name <- "dbit00" +- dbWriteTable(con, table_name, data.frame(a = 0L), overwrite = TRUE) ++ dbWriteTable(con, table_name, data.frame(a = 0L), overwrite = TRUE, field.types = ydb_field_types(con, data.frame(a = 0L))) + +@@ -140,3 +140,3 @@ + #' For example, a record that is missing when the transaction is started +- dbWriteTable(con, table_name, data.frame(a = 0L), overwrite = TRUE) ++ dbWriteTable(con, table_name, data.frame(a = 0L), overwrite = TRUE, field.types = ydb_field_types(con, data.frame(a = 0L))) + +@@ -156,3 +156,3 @@ + #' Disconnection from a connection with an open transaction +- dbWriteTable(local_con, table_name, data.frame(a = 0L), overwrite = TRUE) ++ dbWriteTable(local_con, table_name, data.frame(a = 0L), overwrite = TRUE, field.types = ydb_field_types(local_con, data.frame(a = 0L))) + +--- a/R/spec-transaction-with-transaction.R ++++ b/R/spec-transaction-with-transaction.R +@@ -44,3 +44,3 @@ + #' [dbCommit()]. +- dbWriteTable(con, table_name, data.frame(a = 0L), overwrite = TRUE) ++ dbWriteTable(con, table_name, data.frame(a = 0L), overwrite = TRUE, field.types = ydb_field_types(con, data.frame(a = 0L))) + +@@ -60,3 +60,3 @@ + #' [dbRollback()], and the error is propagated. +- dbWriteTable(con, table_name, data.frame(a = 0L), overwrite = TRUE) ++ dbWriteTable(con, table_name, data.frame(a = 0L), overwrite = TRUE, field.types = ydb_field_types(con, data.frame(a = 0L))) + +@@ -81,3 +81,3 @@ + #' transaction is silently aborted. +- dbWriteTable(con, table_name, data.frame(a = 0L), overwrite = TRUE) ++ dbWriteTable(con, table_name, data.frame(a = 0L), overwrite = TRUE, field.types = ydb_field_types(con, data.frame(a = 0L))) + +--- a/R/utils.R ++++ b/R/utils.R +@@ -57,3 +57,3 @@ + datasets_penguins$sex <- as.character(datasets_penguins$sex) +- as.data.frame(datasets_penguins) ++ ydb_keyed_fixture(as.data.frame(datasets_penguins)) + } +@@ -100 +100,29 @@ + } ++ ++# Keep the fixture payload unchanged; use a separate key for roundtrips with ++# duplicate values, NULL rows or types that cannot be YDB primary keys. ++ydb_keyed_fixture <- function(value) { ++ value$ydb_fixture_id <- seq_len(nrow(value)) ++ value ++} ++ ++ydb_field_types <- function(con, value, field.types = NULL, row.names = NULL) { ++ value <- sqlRownamesToColumn(value, row.names = row.names) ++ keys <- if ("ydb_fixture_id" %in% names(value)) "ydb_fixture_id" else names(value)[vapply(value, function(column) ++ (is.integer(column) || is.character(column)) && !anyDuplicated(column), logical(1))] ++ stopifnot(length(keys) > 0L) ++ types <- field.types ++ if (is.null(types)) { ++ types <- dbDataType(con, value) ++ types[vapply(value, inherits, logical(1), "integer64")] <- "BIGINT" ++ } ++ # Preserve partial field.types: omitted payload columns still exercise inference. ++ if (!keys[1] %in% names(types)) types[keys[1]] <- dbDataType(con, value[[keys[1]]]) ++ aliases <- c("BIT" = "Bool", "DOUBLE PRECISION" = "Double", "VARCHAR(255)" = "Utf8", ++ "VARBINARY(255)" = "String", "DATE" = "Date32", "TIMESTAMP" = "Timestamp64", "TIME" = "Datetime") ++ mapped <- aliases[types] ++ types[!is.na(mapped)] <- mapped[!is.na(mapped)] ++ types[length(types)] <- paste0(types[length(types)], ", PRIMARY KEY (", ++ dbQuoteIdentifier(con, keys[1]), ")") ++ types ++} +--- a/R/spec-meta-bind-runner.R ++++ b/R/spec-meta-bind-runner.R +@@ -104,7 +104,8 @@ + }) else expr({ + data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) ++ local_remove_test_table(con, table_name) ++ dbWriteTable(con, table_name, data, field.types = ydb_field_types(con, data)) + + sql <- paste0("UPDATE ", dbQuoteIdentifier(con, table_name), " SET b = b + 1 WHERE ") + !!!map2(result_names, seq_along(result_names), ~ expr({ +--- a/R/spec-meta-bind.R ++++ b/R/spec-meta-bind.R +@@ -41,7 +41,8 @@ + names(bind_values) <- names(placeholder) + data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) ++ local_remove_test_table(con, table_name) ++ dbWriteTable(con, table_name, data, field.types = ydb_field_types(con, data)) + sql <- paste0("UPDATE ", dbQuoteIdentifier(con, table_name), " SET b = b + 1 WHERE ") + sql <- paste0(sql, "a = ", placeholder[[1L]]) + res <- dbSendStatement(con, sql) +@@ -136,7 +137,8 @@ + } + data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) ++ local_remove_test_table(con, table_name) ++ dbWriteTable(con, table_name, data, field.types = ydb_field_types(con, data)) + sql <- paste0("UPDATE ", dbQuoteIdentifier(con, table_name), " SET b = b + 1 WHERE ") + sql <- paste0(sql, "a = ", placeholder[[1L]], " AND ") + sql <- paste0(sql, "b = ", placeholder[[2L]]) +@@ -300,7 +302,8 @@ + names(bind_values) <- names(placeholder) + data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) ++ local_remove_test_table(con, table_name) ++ dbWriteTable(con, table_name, data, field.types = ydb_field_types(con, data)) + sql <- paste0("UPDATE ", dbQuoteIdentifier(con, table_name), " SET b = b + 1 WHERE ") + sql <- paste0(sql, "a = ", placeholder[[1L]]) + res <- dbSendStatement(con, sql) +@@ -351,7 +354,8 @@ + names(bind_values) <- names(placeholder) + data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) ++ local_remove_test_table(con, table_name) ++ dbWriteTable(con, table_name, data, field.types = ydb_field_types(con, data)) + sql <- paste0("UPDATE ", dbQuoteIdentifier(con, table_name), " SET b = b + 1 WHERE ") + sql <- paste0(sql, "a = ", placeholder[[1L]]) + res <- dbSendStatement(con, sql) +@@ -403,7 +407,8 @@ + names(bind_values) <- names(placeholder) + data <- ydb_keyed_fixture(data.frame(a = rep(1:5, 1:5), b = 1:15)) + table_name <- random_table_name() +- dbWriteTable(con, table_name, data, temporary = TRUE, field.types = ydb_field_types(con, data)) ++ local_remove_test_table(con, table_name) ++ dbWriteTable(con, table_name, data, field.types = ydb_field_types(con, data)) + sql <- paste0("UPDATE ", dbQuoteIdentifier(con, table_name), " SET b = b + 1 WHERE ") + sql <- paste0(sql, "a = ", placeholder[[1L]]) + res <- dbSendStatement(con, sql) +--- a/R/spec-result-send-query.R ++++ b/R/spec-result-send-query.R +@@ -74,7 +74,7 @@ + #' when the connection is closed. + con <- connect(ctx) + on.exit(dbDisconnect(con)) +- expect_warning(dbSendQuery(con, trivial_query()), NA) ++ expect_warning(stale <- dbSendQuery(con, trivial_query()), NA) + + expect_warning({ + dbDisconnect(con) +--- a/R/spec-result-send-statement.R ++++ b/R/spec-result-send-statement.R +@@ -68,7 +68,7 @@ + #' when the connection is closed. + con <- connect(ctx) + on.exit(dbDisconnect(con)) +- expect_warning(dbSendStatement(con, trivial_query()), NA) ++ expect_warning(stale <- dbSendStatement(con, trivial_query()), NA) + + expect_warning({ + dbDisconnect(con) +--- a/R/spec-sql-write-table.R ++++ b/R/spec-sql-write-table.R +@@ -702,7 +702,7 @@ + tbl_exp <- data.frame(a = integer(), b = numeric()) + test_table_roundtrip( + con, tbl_in, tbl_exp, +- field.types = c(b = "REAL", a = "INTEGER") ++ field.types = c(b = "Float", a = "INTEGER") + ) + }, + +--- a/R/spec-meta-bind.R ++++ b/R/spec-meta-bind.R +@@ -809,7 +809,7 @@ + bind_values <- list(list(as.raw(c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))), list(raw(3)), list(NULL)) + placeholder <- placeholder_fun(3L) + names(bind_values) <- names(placeholder) +- placeholder_values <- map_chr(bind_values, function(x) DBI::dbQuoteLiteral(con, x[1])) ++ placeholder_values <- map_chr(bind_values, function(x) cast_fun(DBI::dbQuoteLiteral(con, x[1]))) + result_check <- paste0("(", cast_fun(placeholder), " = ", placeholder_values, ")") + result_check[3L] <- paste0("(", is_null_check(cast_fun(placeholder)[3L]), ")") + sql <- "SELECT " +@@ -840,7 +840,7 @@ + ) + placeholder <- placeholder_fun(3L) + names(bind_values) <- names(placeholder) +- placeholder_values <- map_chr(bind_values, function(x) DBI::dbQuoteLiteral(con, x[1])) ++ placeholder_values <- map_chr(bind_values, function(x) cast_fun(DBI::dbQuoteLiteral(con, x[1]))) + result_check <- paste0("(", cast_fun(placeholder), " = ", placeholder_values, ")") + result_check[3L] <- paste0("(", is_null_check(cast_fun(placeholder)[3L]), ")") + sql <- "SELECT " diff --git a/odbc/tests/frameworks/r/report.R b/odbc/tests/frameworks/r/report.R new file mode 100644 index 00000000000..7dbc180a84c --- /dev/null +++ b/odbc/tests/frameworks/r/report.R @@ -0,0 +1,119 @@ +library(DBI) +library(odbc) +library(DBItest) +library(testthat) +native <- Sys.getenv("ODBC_NATIVE_RESULTS_DIR") +Sys.setenv(ODBC_CS_YDB=Sys.getenv("YDB_R_CONNECTION")) +# Arrow requires a separate binding API; stress uses ordinary DBI connections. +categories <- c("getting_started", "driver", "connection", "result", "sql", "meta", "transaction", "compliance", "stress") +specs <- unlist(lapply(categories, function(name) get(paste0("spec_", name), asNamespace("DBItest"))), recursive=FALSE) +specs <- specs[!vapply(specs,is.null,logical(1))] +names(specs) <- vctrs::vec_names2(specs, repair="unique", quiet=TRUE) +specs <- specs[!grepl("arrow|stream_bind",names(specs))] +source_dir <- "/work/source/tests/testthat" +files <- list.files(source_dir, pattern="^test-(odbc-|utils|dbi-connection).*\\.R$", full.names=TRUE) +# These regression cases exercise the common ODBC path despite living beside +# backend-specific tests. Keep the backend DBItest wrappers out of this run. +backend_cases <- list( + "test-driver-mysql.R" = c("can roundtrip columns", "odbcPreviewObject"), + "test-driver-oracle.R" = c("can round columns", "can detect existence of table"), + "test-driver-postgres.R" = c("can roundtrip columns", "64 bit integers work with alternate mappings", + "Writing data.frame with column ordering different than target table", "odbcPreviewObject"), + "test-driver-sql-server.R" = c("works with dbAppendTable (#215)", + "Subseconds are retained upon insertion (#208)", "dbWriteTable errors if field.types don't exist (#271)", + "blobs can be retrieved out of order", + "can bind NA values", "odbcPreviewObject doesn't warn about pending rows", + "dates should always be interpreted in the system time zone (#398)", + "UTF in VARCHAR is not truncated", "Zero-row-fetch does not move cursor", + "captures multiline errors message"), + "test-driver-sqlite.R" = c("unsupported types gives informative error", "odbcPreviewObject works")) +collect_names <- function(expr) { + if (!is.call(expr) && !is.expression(expr)) return(character()) + if (is.call(expr) && identical(expr[[1]],as.name("test_that"))) { + if (!is.character(expr[[2]])) stop("Cannot discover dynamic upstream test name") + return(expr[[2]]) + } + unlist(lapply(as.list(expr), collect_names), use.names=FALSE) +} +unit_names <- unlist(lapply(files,function(file) paste0(basename(file), ":", collect_names(parse(file))))) +unit_names <- c(unit_names, unlist(lapply(names(backend_cases), function(file) + paste0(file, ":", backend_cases[[file]])), use.names=FALSE)) +jsonlite::write_json(c(names(specs),unit_names), file.path(native,"r-inventory.json"), auto_unbox=FALSE) +if ("--list" %in% commandArgs(TRUE)) quit(status=0) +context <- DBItest::make_context(odbc::odbc(), + list(.connection_string=Sys.getenv("YDB_R_CONNECTION"), encoding="UTF-8"), name="YDB", default_skip=NULL, + tweaks=DBItest::tweaks(dbitest_version="1.8.0", union=function(x) paste(x,collapse=" UNION ALL "), + # DBItest needs a valid DDL statement here; these cases do not inspect table data. + create_table_as=function(table_name, query) + paste0("CREATE TABLE ",table_name," (a Int32, PRIMARY KEY (a))"), + placeholder_pattern="?", date_cast=function(x) paste0("Date32('",x,"'s)"), + time_cast=function(x) paste0("Utf8('",x,"'s)"), + blob_cast=function(x) { + if (all(x == "NULL")) return(x) + if (all(x == "?")) return(paste0("CAST(",x," AS String)")) + if (all(grepl("^String::HexDecode",x))) return(x) + hex <- sub("^(?:[xX]'([0-9A-Fa-f]*)'|0[xX]([0-9A-Fa-f]*))$", "\\1\\2",as.character(x),perl=TRUE) + stopifnot(all(grepl("^[0-9A-Fa-f]*$",hex))) + paste0("String::HexDecode('",hex,"'s)") + }, + timestamp_cast=function(x) paste0("Timestamp64('",sub(" ","T",x,fixed=TRUE),"Z's)"))) +reporter <- testthat::ListReporter$new() +results <- list() +for (name in names(specs)) { + collector <- testthat::ListReporter$new() + testthat::with_reporter(collector, { + DBItest:::run_tests(context, specs[name], skip=NULL, run_only=NULL, test_suite="YDB") + }) + cases <- collector$get_results() + problems <- unlist(lapply(cases,function(case) lapply(Filter(function(result) + !inherits(result,"expectation_success"), case$results),function(result) + list(message=conditionMessage(result)))),recursive=FALSE) + failed <- any(vapply(unlist(lapply(cases,`[[`,"results"),recursive=FALSE),function(result) + inherits(result,c("expectation_failure","expectation_error","expectation_warning")),logical(1))) + empty <- !length(cases) || !any(vapply(cases, function(case) length(case$results) > 0L, logical(1))) + results[[length(results)+1L]] <- list(name=name, + status=if(empty) "broken" else if(failed) "failed" else if(length(problems)) "skipped" else "passed", + message=if(empty) "DBItest produced no expectations" else + paste(vapply(problems,`[[`,"", "message"),collapse="\n"), problems=problems) + jsonlite::write_json(results,file.path(native,"r-results.json"),auto_unbox=TRUE,pretty=TRUE) +} + +# Run the binding's generic upstream tests as well as the DBI contract. +source(file.path(source_dir,"helper.R"),local=TRUE) +run_unit_tests <- function() { +testthat::local_edition(3) +for (file in c(files, file.path(source_dir, names(backend_cases)))) { + env <- new.env(parent=globalenv()) + for (symbol in ls(asNamespace("odbc"),all.names=TRUE)) assign(symbol,get(symbol,asNamespace("odbc")),env) + if (basename(file) %in% names(backend_cases)) { + snapshot <- file.path(dirname(file), "_snaps", paste0(gsub("^test-|\\.R$", "", basename(file)), ".md")) + expected <- if (file.exists(snapshot)) readLines(snapshot) else NULL + cases <- lapply(backend_cases[[basename(file)]], function(name) { + collector <- testthat::ListReporter$new() + # test_file() prunes snapshots belonging to the other selected cases. + if (!is.null(expected)) writeLines(expected, snapshot) + testthat::test_file(file, desc=name, reporter=collector, env=env, load_helpers=FALSE) + # test_roundtrip() has its own nested test_that(). Preserve every + # expectation under the discovered outer regression case. + list(test=name, results=unlist(lapply(collector$get_results(), `[[`, "results"), recursive=FALSE)) + }) + if (!is.null(expected)) writeLines(expected, snapshot) + } else { + collector <- testthat::ListReporter$new() + testthat::test_file(file, reporter=collector, env=env) + cases <- collector$get_results() + } + for (case in cases) { + problems <- lapply(Filter(function(result) !inherits(result,"expectation_success"),case$results), + function(result) list(message=conditionMessage(result))) + failed <- any(vapply(case$results,function(result) + inherits(result,c("expectation_failure","expectation_error","expectation_warning")),logical(1))) + results[[length(results)+1L]] <- list(name=paste0(basename(file),":",case$test), + status=if(!length(case$results)) "broken" else if(failed) "failed" else if(length(problems)) "skipped" else "passed", + message=if(!length(case$results)) "Upstream case produced no expectations" else + paste(vapply(problems,`[[`,"","message"),collapse="\n"),problems=problems) + } + jsonlite::write_json(results,file.path(native,"r-results.json"),auto_unbox=TRUE,pretty=TRUE) +} +} +run_unit_tests() diff --git a/odbc/tests/frameworks/r/run-tests b/odbc/tests/frameworks/r/run-tests new file mode 100755 index 00000000000..9d6fb400c34 --- /dev/null +++ b/odbc/tests/frameworks/r/run-tests @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 +import json,sys,shutil +from pathlib import Path +sys.path.insert(0,'/harness/bindings') +from adapter import run + +def main(s): + library=Path('/work/R-library');library.mkdir() + s.command(['R','CMD','INSTALL','--no-multiarch','--no-test-load','-l',library,s.source],'build',env={'MAKEFLAGS':'-j2'},timeout=1200) + dependencies=s.dependencies() + fixtures=Path('/work/DBItest-fixtures');shutil.copytree(dependencies['DBItest'],fixtures) + (fixtures/'R').chmod(0o755) + for path in (fixtures/'R').glob('*.R'):path.chmod(0o644) + s.command(['patch','--batch','--fuzz=0','-p1','-i',s.adapter/'dbitest.patch'],'test-fixture-patch',cwd=fixtures) + s.command(['R','CMD','INSTALL','--no-multiarch','--no-test-load','-l',library,fixtures],'test-dependencies',env={'R_LIBS_USER':str(library)}) + env={'R_LIBS_USER':str(library),'YDB_R_CONNECTION':('DSN=' if s.mode=='dsn' else '')+s.connection, + 'NOT_CRAN':'true','CI':'true'} + s.command(['Rscript',s.adapter/'report.R','--list'],'inventory',env=env) + names=json.loads((s.native/'r-inventory.json').read_text()) + s.plan(names) + s.command(['Rscript',s.adapter/'report.R'],'upstream',env=env,check=False,timeout=1200) + for entry in json.loads((s.native/'r-results.json').read_text()): + s.add(entry['name'],entry['status'],entry.get('message',''),attachments=[s.native/'upstream.log'],problems=entry.get('problems')) + +raise SystemExit(run(main)) diff --git a/odbc/tests/frameworks/r/test-sources.lock b/odbc/tests/frameworks/r/test-sources.lock new file mode 100644 index 00000000000..6c331800b14 --- /dev/null +++ b/odbc/tests/frameworks/r/test-sources.lock @@ -0,0 +1,7 @@ +DBItest: + kind: archive + url: https://cran.r-project.org/src/contrib/Archive/DBItest/DBItest_1.8.0.tar.gz + revision: 1.8.0 + sha256: dd35c24d556c7a2bc82fff097897bb0229d78004e0de147167c30bcf66e13ccd + license: LGPL-2.1-or-later + ci_only: true diff --git a/odbc/tests/frameworks/r/upstream.lock b/odbc/tests/frameworks/r/upstream.lock new file mode 100644 index 00000000000..9e39acf164d --- /dev/null +++ b/odbc/tests/frameworks/r/upstream.lock @@ -0,0 +1,6 @@ +kind: archive +url: https://codeload.github.com/r-dbi/odbc/tar.gz/refs/tags/v1.4.2 +revision: v1.4.2 +sha256: 333a6b91180304adb56fd947449abf9f3c8c9b1998457c61c8e665630d4d19d4 +license: MIT +ci_only: true diff --git a/odbc/tests/frameworks/r/ydb.patch b/odbc/tests/frameworks/r/ydb.patch new file mode 100644 index 00000000000..44d031f0e61 --- /dev/null +++ b/odbc/tests/frameworks/r/ydb.patch @@ -0,0 +1,358 @@ +--- a/tests/testthat/_snaps/driver-sql-server.md ++++ b/tests/testthat/_snaps/driver-sql-server.md +@@ -7,13 +7,13 @@ + Some columns in `field.types` not in the input, missing columns: + - 'bar' + Output +- CREATE TABLE "foo" ( +- "Sepal.Length" FLOAT, +- "Sepal.Width" FLOAT, +- "Petal.Length" FLOAT, +- "Petal.Width" FLOAT, +- "Species" varchar(255), +- "bar" [int] ++ CREATE TABLE `foo` ( ++ `Sepal.Length` DOUBLE PRECISION, ++ `Sepal.Width` DOUBLE PRECISION, ++ `Petal.Length` DOUBLE PRECISION, ++ `Petal.Width` DOUBLE PRECISION, ++ `Species` VARCHAR(255), ++ `bar` [int] + ) + + +--- a/tests/testthat/helper.R ++++ b/tests/testthat/helper.R +@@ -17,8 +17,9 @@ + ) + } + +-local_table <- function(con, name, df, ..., envir = parent.frame()) { +- dbWriteTable(con, name, df, ...) ++local_table <- function(con, name, df, ..., field.types = NULL, envir = parent.frame()) { ++ if (is.null(field.types)) field.types <- DBItest:::ydb_field_types(con, df) ++ dbWriteTable(con, name, df, ..., field.types = field.types) + withr::defer(dbRemoveTable(con, name), envir = envir) + + name +@@ -97,7 +98,8 @@ + } + if (force_sorted) sent$id <- seq_len(NROW(iris)) + +- DBI::dbWriteTable(con, "test_table", sent, overwrite = TRUE) ++ DBI::dbWriteTable(con, "test_table", sent, overwrite = TRUE, ++ field.types = DBItest:::ydb_field_types(con, sent)) + received <- DBI::dbReadTable(con, "test_table") + if (force_sorted) received <- received[order(received$id), ] + row.names(received) <- NULL +--- a/tests/testthat/test-dbi-connection.R ++++ b/tests/testthat/test-dbi-connection.R +@@ -1,6 +1,6 @@ + test_that("show method prints only host if no user is defined", { + con <- new("OdbcConnection") +- local_mocked_bindings( ++ local_mocked_bindings(.package = "odbc", + dbGetInfo = function(x) c(servername = "localhost", username = "", dbname = "", dbms.name = "", db.version = ""), + dbIsValid = function(x) TRUE + ) +@@ -10,7 +10,7 @@ + + test_that("show method prints DISCONNECTED if not valid", { + con <- new("OdbcConnection") +- local_mocked_bindings( ++ local_mocked_bindings(.package = "odbc", + dbGetInfo = function(x) c(servername = "localhost", username = "", dbname = "", dbms.name = "", db.version = ""), + dbIsValid = function(x) FALSE + ) +@@ -19,7 +19,7 @@ + + test_that("show method does not print server if it is not available", { + con <- new("OdbcConnection") +- local_mocked_bindings( ++ local_mocked_bindings(.package = "odbc", + dbGetInfo = function(x) c(servername = "", username = "", dbname = "", dbms.name = "", db.version = ""), + dbIsValid = function(x) TRUE + ) +--- a/tests/testthat/test-driver-mysql.R ++++ b/tests/testthat/test-driver-mysql.R +@@ -84,11 +84,11 @@ + }) + + test_that("can roundtrip columns", { +- test_roundtrip(test_con("MYSQL"), columns = c("logical", "binary")) ++ test_roundtrip(test_con("YDB"), columns = c("logical", "binary"), force_sorted = TRUE) + }) + + test_that("odbcPreviewObject", { +- con <- test_con("MYSQL") ++ con <- test_con("YDB") + tbl <- local_table(con, "test_preview", data.frame(a = 1:10L)) + + # There should be no "Pending rows" warning +--- a/tests/testthat/test-driver-oracle.R ++++ b/tests/testthat/test-driver-oracle.R +@@ -1,20 +1,20 @@ + test_that("can round columns", { +- con <- test_con("ORACLE") ++ con <- test_con("YDB") + # - Long/outstanding issue with batch inserting + # date/datetime for Oracle. See for example + # #349, #350, #391 + # - There also looks like there are issues related + # to binary elements of size zero. + # - Finally, no boolean in Oracle prior to 23 +- test_roundtrip(con, columns = c("time", "date", "datetime", "binary", "logical")) ++ test_roundtrip(con, columns = c("time", "date", "datetime", "binary", "logical"), force_sorted = TRUE) + }) + + test_that("can detect existence of table", { +- con <- test_con("ORACLE") ++ con <- test_con("YDB") + +- tbl1 <- local_table(con, "mtcarstest", mtcars) ++ tbl1 <- local_table(con, "mtcarstest", DBItest:::ydb_keyed_fixture(mtcars)) + expect_true(dbExistsTable(con, tbl1)) + +- tbl2 <- local_table(con, "mtcars_test", mtcars) ++ tbl2 <- local_table(con, "mtcars_test", DBItest:::ydb_keyed_fixture(mtcars)) + expect_true(dbExistsTable(con, tbl2)) + }) +--- a/tests/testthat/test-driver-postgres.R ++++ b/tests/testthat/test-driver-postgres.R +@@ -95,8 +95,8 @@ + }) + + test_that("can roundtrip columns", { +- con <- test_con("POSTGRES") +- test_roundtrip(con) ++ con <- test_con("YDB") ++ test_roundtrip(con, force_sorted = TRUE) + }) + + test_that("show method works as expected with real connection", { +@@ -109,16 +109,16 @@ + }) + + test_that("64 bit integers work with alternate mappings", { +- con_integer64 <- test_con("POSTGRES", bigint = "integer64") +- con_integer <- test_con("POSTGRES", bigint = "integer") +- con_numeric <- test_con("POSTGRES", bigint = "numeric") +- con_character <- test_con("POSTGRES", bigint = "character") ++ con_integer64 <- test_con("YDB", bigint = "integer64") ++ con_integer <- test_con("YDB", bigint = "integer") ++ con_numeric <- test_con("YDB", bigint = "numeric") ++ con_character <- test_con("YDB", bigint = "character") + + tbl <- local_table( + con_integer64, + "test", + data.frame(a = 1:10L), +- field.types = c(a = "BIGINT") ++ field.types = c(a = "BIGINT, PRIMARY KEY (`a`)") + ) + + expect_s3_class(dbReadTable(con_integer64, tbl)$a, "integer64") +@@ -133,7 +133,7 @@ + # case when the data being written has columns ordered + # differently than the table we are targetting. + test_that("Writing data.frame with column ordering different than target table", { +- con <- test_con("POSTGRES") ++ con <- test_con("YDB") + values <- data.frame( + datetime = as.POSIXct(c(14, 15), origin = "2016-01-01", tz = "UTC"), + name = c("one", "two"), +@@ -141,7 +141,7 @@ + stringsAsFactors = FALSE + ) + tbl <- "test_order_write" +- dbCreateTable(con, tbl, values) ++ dbCreateTable(con, tbl, values, field.types = DBItest:::ydb_field_types(con, values)) + dbAppendTable(con, tbl, values[c(2, 3, 1)]) + on.exit(dbRemoveTable(con, tbl)) + +@@ -152,7 +152,7 @@ + }) + + test_that("odbcPreviewObject", { +- con <- test_con("POSTGRES") ++ con <- test_con("YDB") + tbl <- local_table(con, "test_preview", data.frame(a = 1:10L)) + + # There should be no "Pending rows" warning +--- a/tests/testthat/test-driver-sql-server.R ++++ b/tests/testthat/test-driver-sql-server.R +@@ -118,29 +118,36 @@ + }) + + test_that("works with dbAppendTable (#215)", { +- con <- test_con("SQLSERVER") ++ con <- test_con("YDB") + + ir <- iris + ir$Species <- as.character(ir$Species) ++ names(ir) <- gsub(".", "_", names(ir), fixed = TRUE) ++ ir <- DBItest:::ydb_keyed_fixture(ir) + + tbl <- local_table(con, "iris", ir) +- dbAppendTable(con, tbl, ir) ++ appended <- ir ++ appended$ydb_fixture_id <- appended$ydb_fixture_id + nrow(ir) ++ dbAppendTable(con, tbl, appended) + + res <- dbReadTable(con, tbl) +- expect_equal(res, rbind(ir, ir)) ++ res <- res[order(res$ydb_fixture_id), , drop = FALSE] ++ rownames(res) <- NULL ++ expect_equal(res, rbind(ir, appended)) + }) + + test_that("Subseconds are retained upon insertion (#208)", { +- con <- test_con("SQLSERVER") ++ con <- test_con("YDB") + data <- data.frame(time = Sys.time()) +- tbl <- local_table(con, "time", data) ++ tbl <- local_table(con, "time", data, ++ field.types = c(time = "Timestamp64, PRIMARY KEY (`time`)")) + + res <- dbReadTable(con, tbl) + expect_equal(as.double(res$time), as.double(data$time)) + }) + + test_that("dbWriteTable errors if field.types don't exist (#271)", { +- con <- test_con("SQLSERVER") ++ con <- test_con("YDB") + + expect_snapshot( + sqlCreateTable(con, "foo", iris, field.types = list(bar = "[int]")) +@@ -148,7 +155,7 @@ + }) + + test_that("blobs can be retrieved out of order", { +- con <- test_con("SQLSERVER") ++ con <- test_con("YDB") + values <- data.frame( + c1 = 1, + c2 = "this is varchar max", +@@ -170,7 +177,7 @@ + }) + + test_that("can bind NA values", { +- con <- test_con("SQLSERVER") ++ con <- test_con("YDB") + # With SELECT ing with the OEM SQL Server driver, everything + # after the first column should be unbound. Test null detection for + # unbound columns (NULL is registered after a call to nanodbc::result::get) +@@ -183,6 +190,7 @@ + c6 = c(Sys.time(), NA), + stringsAsFactors = FALSE + ) ++ values <- DBItest:::ydb_keyed_fixture(values) + tbl <- local_table(con, "test_na", values) + + received <- DBI::dbReadTable(con, tbl) +@@ -218,7 +226,7 @@ + }) + + test_that("odbcPreviewObject doesn't warn about pending rows", { +- con <- test_con("SQLSERVER") ++ con <- test_con("YDB") + tbl <- local_table(con, "test_preview", data.frame(a = 1:10L)) + + # There should be no "Pending rows" warning +@@ -229,13 +237,13 @@ + }) + + test_that("dates should always be interpreted in the system time zone (#398)", { +- con <- test_con("SQLSERVER") ++ con <- test_con("YDB") + res <- dbGetQuery(con, "SELECT CAST(? AS date)", params = as.Date("2019-01-01")) + expect_equal(res[[1]], as.Date("2019-01-01")) + }) + + test_that("UTF in VARCHAR is not truncated", { +- con <- test_con("SQLSERVER") ++ con <- test_con("YDB") + value <- "grΓΌn" + res <- dbGetQuery( + con, +@@ -245,8 +253,8 @@ + }) + + test_that("Zero-row-fetch does not move cursor", { +- con <- test_con("SQLSERVER") +- tbl <- local_table(con, "test_zero_row_fetch", mtcars[1:2, ]) ++ con <- test_con("YDB") ++ tbl <- local_table(con, "test_zero_row_fetch", DBItest:::ydb_keyed_fixture(mtcars[1:2, ])) + + rs <- dbSendStatement(con, paste0("SELECT * FROM ", tbl)) + expect_equal(nrow(dbFetch(rs, n = 0)), 0) +--- a/tests/testthat/test-driver-sqlite.R ++++ b/tests/testthat/test-driver-sqlite.R +@@ -131,14 +131,14 @@ + }) + + test_that("unsupported types gives informative error", { +- con <- test_con("SQLITE") ++ con <- test_con("YDB") + + df <- data.frame(foo = complex(1)) + expect_error(dbWriteTable(con, "df", df), "Column 'foo' is of unsupported type: 'complex'") + }) + + test_that("odbcPreviewObject works", { +- con <- test_con("SQLITE") ++ con <- test_con("YDB") + tbl <- local_table(con, "test_preview", data.frame(a = 1:10L)) + + # There should be no "Pending rows" warning +--- a/tests/testthat/test-odbc-config.R ++++ b/tests/testthat/test-odbc-config.R +@@ -11,7 +11,7 @@ + }) + + test_that("odbcListConfig returns an empty vector on Windows", { +- local_mocked_bindings(is_windows = function() {TRUE}) ++ local_mocked_bindings(.package = "odbc", is_windows = function() {TRUE}) + + res <- odbcListConfig() + +@@ -19,19 +19,19 @@ + }) + + test_that("odbcListConfig errors informatively without unixODBC", { +- local_mocked_bindings(is_windows = function() {FALSE}, ++ local_mocked_bindings(.package = "odbc", is_windows = function() {FALSE}, + has_odbc = function() {FALSE}) + + expect_snapshot(error = TRUE, odbcListConfig()) + }) + + test_that("odbcListConfig errors informatively with unexpected odbcinst output", { +- local_mocked_bindings(is_windows = function() {FALSE}, ++ local_mocked_bindings(.package = "odbc", is_windows = function() {FALSE}, + has_odbc = function() {TRUE}) + +- local_mocked_bindings(system = function(...) {c("beep", "bop")}) ++ local_mocked_bindings(.package = "odbc", system = function(...) {c("beep", "bop")}) + expect_snapshot(error = TRUE, odbcListConfig()) + +- local_mocked_bindings(system = function(...) {""}) ++ local_mocked_bindings(.package = "odbc", system = function(...) {""}) + expect_snapshot(error = TRUE, odbcListConfig()) + }) +--- a/tests/testthat/test-odbc-connection.R ++++ b/tests/testthat/test-odbc-connection.R +@@ -67,11 +67,12 @@ + # odbcConnectionColumns deprecation -------------------------------------- + + test_that("odbcConnectionColumns warns on usage (#699)", { +- con <- test_con("SQLITE") ++ con <- test_con("YDB") + lifecycle::expect_deprecated(odbcConnectionColumns(con, "test")) + }) + + test_that("odbcConnectionColumns_ is eventually removed (#699)", { ++ skip("Maintenance assertion for a future odbc API removal") + skip_on_cran() + if (Sys.Date() > "2026-01-01") { + testthat::expect( diff --git a/odbc/tests/frameworks/registry.yaml b/odbc/tests/frameworks/registry.yaml new file mode 100644 index 00000000000..d926d838fb3 --- /dev/null +++ b/odbc/tests/frameworks/registry.yaml @@ -0,0 +1,590 @@ +schema_version: 2 +ydb: + image: ydbplatform/local-ydb:trunk + endpoint: localhost:2136 + database: /local +classifications: + - outcome: upstream_failure + reason: QODBC drops QDateTime offsets before binding SQL_TIMESTAMP_STRUCT, shifting the represented instant. + match: '(?s)Actual\s+\(q\.value\(2\)\.toDateTime\(\)\): 2150/01/05 14:00:00\.123\[UTC\]\s+Expected \(tzoffset\)\s+: 2150/01/05 14:00:00\.123\[UTC\+01:00\]' + reference: https://github.com/qt/qtbase/blob/e3e40c44d3f998a433a6a1080297c5f28e9a768f/src/plugins/sqldrivers/odbc/qsql_odbc.cpp + reproducer: repros/qt-timestamp.cpp + tests: + qt: [qt.*.qsqlquery.QTBUG_57138] + - outcome: unsupported + reason: This SQLite regression requires Bool metadata; QODBC deliberately exposes SQL_BIT as Int or UInt. + match: '(?s)Actual\s+\(q\.record\(\)\.field\(0\)\.metaType\(\)\.id\(\)\): 2\s+Expected \(QMetaType::Bool\)\s+: 1' + reference: https://github.com/qt/qtbase/blob/e3e40c44d3f998a433a6a1080297c5f28e9a768f/src/plugins/sqldrivers/odbc/qsql_odbc.cpp + tests: + qt: [qt.*.qsqlquery.QTBUG_14904] + - outcome: upstream_failure + reason: QODBC ignores signedness for SQL_TINYINT and requests unsigned data for negative Int8 values. + match: '(?s)Actual\s+\(actualValues\): 0\s+Expected \(values\): -128' + reference: https://github.com/qt/qtbase/blob/e3e40c44d3f998a433a6a1080297c5f28e9a768f/src/plugins/sqldrivers/odbc/qsql_odbc.cpp + reproducer: repros/qt-tinyint.cpp + tests: + qt: [qt.*.qsqlquery.integralTypesMysql] + - outcome: unsupported + reason: YDB result metadata has no table origins; ODBC permits an empty table name when its origin is unavailable. + match: 'Actual[^\n]*tableName\(\)[^\n]*:\s*""\s+Expected' + tests: + qt: ['qt.*.qsqlquery.{record,forwardOnlyMultipleResultSet}'] + - outcome: unsupported + reason: This case updates the table's primary key, which YDB makes immutable. + match: 'Cannot update primary key column: id' + tests: + qt: [qt.*.qsqltablemodel.setData, qt.*.qsqltablemodel.primaryKeyOrder, qt.*.qsqlrelationaltablemodel.setRecord] + - outcome: unsupported + reason: YDB returns SELECT results without interleaved DML counts, as advertised by SQL_BATCH_ROW_COUNT=0. + match: "'!q.isSelect\\(\\)' returned FALSE" + tests: + qt: [qt.*.qsqlquery.nextResult] + - outcome: skipped + reason: YDB uses UTF-8 databases and cannot create the EUC_JP database required by this case. + match: 'YDB databases require UTF-8, not EUC_JP' + tests: + php-odbc: ['php-odbc.*.ext%2Fodbc%2Ftests%2Fbug60616.phpt'] + - outcome: skipped + reason: These upstream scenarios explicitly require SQL Server catalog or session behavior. + match: 'MS SQL specific test' + tests: + php-odbc: ['php-odbc.*.ext%2Fodbc%2Ftests%2F{odbc_columns_001,odbc_primarykeys_001,odbc_persistent_close}.phpt'] + - outcome: skipped + reason: YDB has no SQL Server stored procedures or sysobjects catalog. + match: SQL Server stored procedures and catalogs + tests: + php-odbc: [php-odbc.*.ext%2Fodbc%2Ftests%2Fbug73448.phpt] + - outcome: skipped + reason: The R-prefix naming convention is optional and does not test ODBC behavior. + match: 'Optional R-prefix package naming convention' + tests: + r: [r.*.package_name] + - outcome: unsupported + reason: YDB column names cannot contain the whitespace, dots or quote characters exercised by these cases. + match: 'Invalid (?:column name|name for user column)' + tests: + r: + - r.*.{quote_identifier_special,read_table_check_names,read_table_check_names_false,create_roundtrip_quotes,append_roundtrip_quotes_column_names,roundtrip_quotes_column_names} + - outcome: unsupported + reason: YDB table path components cannot contain the whitespace and punctuation exercised by these cases. + match: 'symbol .* is not allowed in the path part' + tests: + r: + - r.*.{read_table_name,create_table_name,create_table_name_quoted,append_table_name,append_table_name_quoted,write_table_name,write_table_name_quoted,list_tables_quote,exists_table_name,remove_table_name,remove_table_name_quoted,list_objects_quote} + - outcome: unsupported + reason: The Query Service pool does not provide connection-scoped temporary tables. + match: 'Creating temporary table is not supported' + tests: + r: + - r.*.{create_temporary_table...171,temporary_table...239,list_tables_temporary,exists_table_temporary,remove_table_temporary_arg,remove_table_temporary,list_objects_temporary,list_fields_temporary} + - outcome: skipped + reason: This upstream deadline reminds odbc maintainers to remove an API in a future release. + match: 'Maintenance assertion for a future odbc API removal' + tests: + r: ['r.*.test-odbc-connection.R%3AodbcConnectionColumns_%20is%20eventually%20removed%20%28%23699%29'] + - outcome: skipped + reason: Requires Qt's Oracle plugin and Oracle-specific SQL rather than QODBC. + match: No\ database\ drivers\ of\ type\ QOCI\ are\ available\ in\ this\ Qt\ configuration + tests: + qt: + - qt.*.qsqldatabase.{oci_tables,oci_xmltypeSupport,oci_fieldLength,oci_synonymstest} + - qt.*.qsqlquery.{oraOutValues,oraOCINumber,oraRowId,oraArrayBind,QTBUG_551,QTBUG_6421,QTBUG_14132} + - outcome: skipped + reason: Requires Qt's Oracle plugin and Oracle-specific SQL rather than QODBC. + match: Implemented\ only\ for\ Oracle + tests: + qt: + - qt.*.qsqlquery.dateTime + - outcome: skipped + reason: Requires Qt's MySQL plugin and MySQL-specific SQL rather than QODBC. + match: No\ database\ drivers\ of\ type\ QMYSQL\ are\ available\ in\ this\ Qt\ configuration + tests: + qt: + - qt.*.qsqldatabase.{recordMySQL,mysql_savepointtest} + - qt.*.qsqlquery.{mysql_outValues,mysql_timeType,QTBUG_6852,gisPointDatatype} + - outcome: skipped + reason: Requires Qt's PostgreSQL plugin and PostgreSQL-specific SQL rather than QODBC. + match: No\ database\ drivers\ of\ type\ QPSQL\ are\ available\ in\ this\ Qt\ configuration + tests: + qt: + - qt.*.qsqldatabase.{psql_schemas,psql_escapedIdentifiers,psql_bug249059} + - qt.*.qsqlquery.{psql_forwardOnlyQueryResultsLost,psql_bindWithDoubleColonCastOperator,QTBUG_12477,QTBUG_5251,QTBUG_36211} + - outcome: skipped + reason: Exercises SQL Server or TDS-specific behavior outside the YDB binding contract. + match: Database\ driver\ QTDS7?\ not\ available + tests: + qt: + - qt.*.qsqldatabase.errorReporting@QTDS* + - outcome: skipped + reason: Exercises SQL Server or TDS-specific behavior outside the YDB binding contract. + match: SQL\ Server\ \(ODBC\)\ specific\ test + tests: + qt: + - qt.*.qsqldatabase.odbc_uniqueidentifier + - outcome: skipped + reason: Exercises SQL Server or TDS-specific behavior outside the YDB binding contract. + match: Test\ is\ specific\ to\ SQL\ Server + tests: + qt: + - qt.*.qsqlquery.{sqlServerReturn0,QTBUG_18435} + - outcome: skipped + reason: Requires Qt's DB2 plugin and DB2-specific SQL rather than QODBC. + match: No\ database\ drivers\ of\ type\ QDB2\ are\ available\ in\ this\ Qt\ configuration + tests: + qt: + - qt.*.qsqlquery.outValuesDB2 + - outcome: skipped + reason: Requires Qt's SQLite plugin and SQLite-specific behavior rather than QODBC. + match: No\ database\ drivers\ of\ type\ QSQLITE\ are\ available\ in\ this\ Qt\ configuration + tests: + qt: + - qt.*.qsqldatabase.{sqlite_bindAndFetchUInt,sqlite_enable_cache_mode,sqlite_enableRegexp,sqlite_check_json1} + - qt.*.qsqltablemodel.{insertWithAutoColumn,revert,sqlite_attachedDatabase,sqlite_selectFromIdentifierWithDot} + - outcome: skipped + reason: Requires Qt's SQLite plugin and SQLite-specific behavior rather than QODBC. + match: Database\ driver\ QSQLITE\ not\ available + tests: + qt: + - qt.*.qsqldatabase.sqlite_openError + - outcome: skipped + reason: Requires Qt's InterBase plugin and InterBase-specific SQL rather than QODBC. + match: No\ database\ drivers\ of\ type\ QIBASE\ are\ available\ in\ this\ Qt\ configuration + tests: + qt: + - qt.*.qsqldatabase.{recordIBase,ibase_useCustomCharset,ibase_procWithoutReturnValues,ibase_procWithReturnValues} + - qt.*.qsqlquery.{storedProceduresIBase,ibase_executeBlock,ibaseArray} + - outcome: skipped + reason: Exercises the MySQL ODBC driver rather than the YDB ODBC driver. + match: MySQL\ through\ ODBC\-driver\ specific\ test + tests: + qt: + - qt.*.qsqldatabase.mysqlOdbc_unsignedIntegers + - outcome: skipped + reason: Database event notifications are outside the binding contract. + match: DBMS\ doesn't\ support\ event\ notifications + tests: + qt: + - qt.*.qsqldatabase.eventNotification + - outcome: skipped + reason: Database event notifications are outside the binding contract. + match: No\ database\ drivers\ of\ type\ QIBASE\ are\ available\ in\ this\ Qt\ configuration + tests: + qt: + - qt.*.qsqldatabase.eventNotificationIBase + - outcome: skipped + reason: Database event notifications are outside the binding contract. + match: No\ database\ drivers\ of\ type\ QPSQL\ are\ available\ in\ this\ Qt\ configuration + tests: + qt: + - qt.*.qsqldatabase.eventNotificationPSQL + - outcome: skipped + reason: Database event notifications are outside the binding contract. + match: No\ database\ drivers\ of\ type\ QSQLITE\ are\ available\ in\ this\ Qt\ configuration + tests: + qt: + - qt.*.qsqldatabase.eventNotificationSQLite + - outcome: skipped + reason: YDB table paths are outside Qt's whitespace-delimited SQL identifier scenario. + match: DBMS\ does\ not\ support\ whitespaces\ in\ identifiers + tests: + qt: + - qt.*.qsqldatabase.whitespaceInIdentifiers + - outcome: skipped + reason: YDB table paths are outside Qt's whitespace-delimited SQL identifier scenario. + match: White\ space\ test\ irrelevant\ for\ driver + tests: + qt: + - qt.*.qsqlrelationaltablemodel.whiteSpaceInIdentifiers + - outcome: skipped + reason: YDB table paths are outside Qt's whitespace-delimited SQL identifier scenario. + match: DBMS\ doesn't\ support\ whitespaces\ in\ identifiers + tests: + qt: + - qt.*.qsqltablemodel.whitespaceInIdentifiers + - outcome: skipped + reason: Requires Qt's SQLite plugin and SQLite-specific SQL rather than QODBC. + match: No\ database\ drivers\ of\ type\ QSQLITE\ are\ available\ in\ this\ Qt\ configuration + tests: + qt: + - qt.*.qsqlquery.{sqlite_finish,sqliteVirtualTable,QTBUG_21884,QTBUG_23895,sqlite_constraint} + - outcome: skipped + reason: Stored procedures and output parameters are optional ODBC features outside the binding contract. + match: Don't\ know\ how\ to\ create\ a\ stored\ procedure\ for\ this\ database\ server,\ please\ fix\ this\ test + tests: + qt: + - qt.*.qsqlquery.outValues + - outcome: skipped + reason: Generated-key retrieval is outside the binding contract. + match: Database\ doesn't\ support\ lastInsertId + tests: + qt: + - qt.*.qsqlquery.lastInsertId + - outcome: skipped + reason: Upstream permanently disables this query-level experiment; qsqldatabase.transaction exercises the required transaction contract. + match: only\ tested\ manually\ by\ trained\ staff + tests: + qt: + - qt.*.qsqlquery.transaction + - outcome: skipped + reason: Requires Qt's PostgreSQL plugin and PostgreSQL schema semantics rather than QODBC. + match: Postgresql\ specific\ test + tests: + qt: + - qt.*.qsqlrelationaltablemodel.psqlSchemaTest + - outcome: skipped + reason: Requires Qt's PostgreSQL plugin and PostgreSQL schema semantics rather than QODBC. + match: No\ database\ drivers\ of\ type\ QPSQL\ are\ available\ in\ this\ Qt\ configuration + tests: + qt: + - qt.*.qsqltablemodel.tablesAndSchemas + - outcome: skipped + reason: This case expects cursor-library TEXT reads to return SQL_NO_DATA and false; unixODBC returns the text instead. + match: Fails with unixODBC + tests: + php-odbc: ['php-odbc.*.ext%2Fodbc%2Ftests%2Fbug44618.phpt'] + - outcome: skipped + reason: This upstream model test explicitly uses SQLite, outside the QODBC contract. + match: "Exercises Qt's hardcoded SQLite in-memory model" + tests: + qt: [qt.*.qsqltablemodel.modelInAnotherThread] + - outcome: skipped + reason: These cases require Latin1 literals or emulated-prepare parameter errors; PDO_ODBC uses native prepares against UTF-8 YDB. + match: '(?m)^(?:not for pdo_odbc|not relevant for odbc driver)$' + tests: + php-pdo: ['php-pdo.*.ext%2Fpdo%2Ftests%2F{bug_36798,bug_43130}.phpt'] + - outcome: skipped + reason: PDO_ODBC has no emulated-prepare or SQL-literal escaping API. + match: "(?m)^(?:driver cannot emulate prepared statements|odbc driver doesn't have escape API, use prepared statements)$" + tests: + php-pdo: ['php-pdo.*.ext%2Fpdo%2Ftests%2F{debug_emulated_prepares,pdo_033}.phpt'] + - outcome: skipped + reason: The credential-in-PDO-DSN scenario selects other PDO backends explicitly. + match: '(?m)^not supported$' + tests: + php-pdo: ['php-pdo.*.ext%2Fpdo%2Ftests%2Fpdo_dsn_containing_credentials.phpt'] + + - outcome: upstream_failure + reason: R odbc rejects NA row limits before calling ODBC. + match: missing value where TRUE/FALSE needed + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/R/dbi-result.R + reproducer: repros/r-contract.R + tests: + r: + - r.*.fetch_na_rows + - outcome: upstream_failure + reason: R odbc omits the DBI warning when fetching a statement with no result columns. + match: did not throw the expected warning + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/R/dbi-result.R + reproducer: repros/r-contract.R + tests: + r: + - r.*.{fetch_no_return_value,row_count_statement,rows_affected_statement} + - outcome: upstream_failure + reason: R odbc warns when clearing intentionally unread rows in dbGetQuery. + match: Pending rows + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/R/dbi-result.R + reproducer: repros/r-contract.R + tests: + r: + - r.*.{get_query_n_zero_rows,get_query_n_incomplete} + - outcome: upstream_failure + reason: R odbc converts factor columns without the required DBI warning. + match: did not throw the expected warning + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/R/dbi-table.R + reproducer: repros/r-contract.R + tests: + r: + - r.*.append_roundtrip_factor + - outcome: upstream_failure + reason: R odbc treats difftime minutes as seconds. + match: (?s)actual\[1, \]\s+00:00:01.*expected\[1, \]\s+00:01:00 + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/src/odbc_result.cpp + reproducer: repros/r-contract.R + tests: + r: + - r.*.{append_roundtrip_time,roundtrip_time} + - outcome: upstream_failure + reason: R odbc warns instead of rejecting unknown field.types names. + match: Some columns in `field.types` not in the input + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/R/dbi-table.R + reproducer: repros/r-contract.R + tests: + r: + - r.*.write_table_error + - outcome: upstream_failure + reason: R odbc ignores fail_if_missing=FALSE when generating DROP TABLE. + match: (?s)fail_if_missing = FALSE.*Cannot find table .*because it does not exist + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/R/dbi-table.R + reproducer: repros/r-contract.R + tests: + r: + - r.*.remove_table_missing_succeed + - outcome: upstream_failure + reason: DBI identifier unquoting loses the named Id component used by dbListObjects; an empty catalog hides this + defect. + match: '(?s)names\(actual\[\[1\]\]@name\).*names\(expected\[\[1\]\]@name\)|Reason: No schemas available' + reference: https://dbi.r-dbi.org/reference/dbUnquoteIdentifier.html + reproducer: repros/r-contract.R + tests: + r: + - r.*.list_objects_features + - outcome: upstream_failure + reason: R odbc returns an empty field list instead of the required DBI error for a missing table. + match: dbListFields\(con, name\).*did not throw the expected error + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/R/dbi-connection.R + reproducer: repros/r-contract.R + tests: + r: + - r.*.list_fields_wrong_table + - outcome: upstream_failure + reason: R odbc accepts an empty parameter list without calling ODBC. + match: dbBind\(res, list\(\)\).*did not throw the expected error + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/R/dbi-result.R + reproducer: repros/r-contract.R + tests: + r: + - r.*.bind_empty + - outcome: upstream_failure + reason: R odbc reports completion and affected rows before parameters have been bound. + match: (?s)dbHasCompleted\(res\) is not FALSE|dbGetRowsAffected\(res\).*NA_integer_ + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/src/result.cpp + reproducer: repros/r-contract.R + tests: + r: + - r.*.{bind_return_value,bind_return_value_statement} + - outcome: upstream_failure + reason: R odbc does not reject unequal parameter lengths or names on positional parameters. + match: dbBind\(res, bind_values_patched\).*did not throw the expected error + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/R/dbi-result.R + reproducer: repros/r-contract.R + tests: + r: + - r.*.{bind_multi_row_unequal_length,bind_unnamed_param_named_placeholders} + - outcome: upstream_failure + reason: R odbc rejects zero-length binding while parsing batch_rows, before calling ODBC. + match: (?s)`batch_rows` is not a valid size:.*Must be a positive integer + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/R/utils.R + reproducer: repros/r-contract.R + tests: + r: + - r.*.bind_multi_row_zero_length + - outcome: upstream_failure + reason: R odbc binds factor codes rather than labels and omits the factor warning. + match: (?s)did not throw the expected warning|actual\[1, \].*2\.5.*expected\[1, \].*1\.5 + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/src/odbc_result.cpp + reproducer: repros/r-bind-types.R + tests: + r: + - r.*.bind_factor + - outcome: upstream_failure + reason: R odbc loses integer Date classes or difftime units, and timestamp binding does not match its own quoted + timestamp literal. + match: (?s)actual\[1, \].*2\.5.*expected\[1, \].*1\.5 + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/src/odbc_result.cpp + reproducer: repros/r-bind-types.R + tests: + r: + - r.*.{bind_date_integer,bind_timestamp,bind_time_hours,bind_time_minutes_integer} + - outcome: upstream_failure + reason: R odbc treats POSIXlt lists as raw-vector lists and fails before calling ODBC. + match: RAW\(\) can only be applied to a 'raw', not a 'double' + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/src/odbc_result.cpp + reproducer: repros/r-contract.R + tests: + r: + - r.*.bind_timestamp_lt + - outcome: upstream_failure + reason: R odbc calls SQLRowCount after SQLMoreResults has left the statement unexecuted. + match: Function sequence error + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/src/nanodbc/nanodbc.cpp + reproducer: repros/r-contract.R + tests: + r: + - r.*.rows_affected_query + - outcome: upstream_failure + reason: R odbc 1.4.2 does not reexport the DBI APIs checked by DBItest 1.8.0. + match: Id, dbAppendTableArrow, dbBindArrow, dbCanConnect + reference: https://github.com/r-dbi/odbc/blob/v1.4.2/NAMESPACE + reproducer: repros/r-contract.R + tests: + r: + - r.*.reexport + - outcome: upstream_failure + reason: Qt QODBC returns an invalid QVariant for a NULL string instead of a typed NULL. + match: NULL relation reported with invalid QVariant + reference: https://github.com/qt/qtbase/blob/v6.4.2/src/plugins/sqldrivers/odbc/qsql_odbc.cpp + reproducer: repros/qt-null.cpp + tests: + qt: + - qt.*.qsqlrelationaltablemodel.data + - outcome: upstream_failure + reason: PDO_ODBC rereads an exhausted SQLGetData stream for repeated FETCH_LAZY accesses instead of caching the + value. + match: (?s)Null coalesce:.*string\(7\) "default".*Read:.*NULL + reference: https://github.com/php/php-src/blob/php-8.3.6/ext/pdo_odbc/odbc_stmt.c + reproducer: repros/pdo-lazy.php + tests: + php-pdo: + - php-pdo.*.ext%2Fpdo%2Ftests%2Fpdo_035.phpt + - outcome: upstream_failure + reason: LuaSQL reads SQL_C_SLONG into SQLLEN with uninitialized upper bytes and leaves luaL_Buffer stack slots + on NULL reads; outcomes are intermittent. + match: (?s)wrong value \(-?\d{10,} instead of (?:0|1|10)\).*in function \'(?:fetch2|fetch_new_table|fetch_many|unicode_values|rollback|extensions_test|check_close)\'|wrong + value \(c instead of b\).*in function \'fetch2\'|received signal SIG(?:SEGV|ABRT)(?!.*(?:libydb-odbc|NYdb::NOdbc|/odbc/src/))(?:.*\b(?:cur_fetch|lua|free)\b|.*(?:\n\#[0-4]\s+0x[0-9a-f]+ in \?\? \(\)){5}\n\#5\s+0x[0-9a-f]+ in lua_pcallk \(\)) + reference: https://github.com/lunarmodules/luasql/pull/219 + reproducer: repros/lua-fetch.lua + tests: + lua: + - lua.*.{fetch%20two%20values,fetch%20new%20table,fetch%20many,unicode%20values,rollback,extensions,close%20objects} + allow_pass: true + - outcome: unsupported + reason: R generic dbDataType emits BIT, DOUBLE PRECISION and bounded VARCHAR/VARBINARY instead of the native types + advertised by SQLGetTypeInfo. YDB has no such type aliases or length parameters. + match: Unknown simple type 'BIT'|no viable alternative at input 'PRECISION'|mismatched input '255'|Cannot find + table .*because it does not exist + tests: + r: + - r.*.{data_type_create_table,append_table_new,roundtrip_field_types} +consumers: + - id: package-contract + display_name: Debian package contract + kind: package + language: shell + tier: smoke + runtime_image: ubuntu:24.04@sha256:019e8eb29a85e74d64925745884f2ec79aa27e3feab36353d24656f4d6b89467 + runtime_version: [dpkg-query, -W, '-f=${Version}', base-files] + runner: package-contract + source: system + expected: + required: [package.clean_install, package.upgrade, package.remove, package.replacement] + - id: isql + display_name: unixODBC isql + kind: smoke + language: SQL + tier: smoke + runtime_image: ubuntu:24.04@sha256:019e8eb29a85e74d64925745884f2ec79aa27e3feab36353d24656f4d6b89467 + runtime_version: [odbcinst, -j] + source: system + modes: [dsn] + tests: + - id: isql.select_scalar + name: isql executes a scalar query + command: [isql, -b, -v, '{dsn}'] + stdin: "SELECT 42 AS value;\n" + output_regex: '(^|[^0-9])42([^0-9]|$)' + expected: + required: [isql.select_scalar] + - id: qt + display_name: Qt 6.4 QODBC upstream SQL tests + kind: framework + language: C++ + tier: core + runtime_image: ubuntu:24.04@sha256:019e8eb29a85e74d64925745884f2ec79aa27e3feab36353d24656f4d6b89467 + runtime_version: [qmake6, -query, QT_VERSION] + source: + kind: archive + url: https://codeload.github.com/qt/qtbase/tar.gz/e3e40c44d3f998a433a6a1080297c5f28e9a768f + revision: e3e40c44d3f998a433a6a1080297c5f28e9a768f + sha256: 31968efe5280ca254b66a60fe2d717e6bc3367e1bd7ff404b256c2a27eb003ba + license: GPL-3.0-only WITH Qt-GPL-exception-1.0 + ci_only: true + modes: [dsn, connection_string] + expected: + discovered: true + required: + - qt.*.*.* + - id: php-odbc + display_name: PHP ext/odbc tests + kind: framework + language: PHP + tier: core + dockerfile: bindings/Dockerfile + runtime_image: ubuntu:24.04@sha256:019e8eb29a85e74d64925745884f2ec79aa27e3feab36353d24656f4d6b89467 + runtime_version: ["php", "--version"] + source: + kind: "archive" + url: "https://codeload.github.com/php/php-src/tar.gz/refs/tags/php-8.3.6" + revision: "php-8.3.6" + sha256: "af9ca6ea711391eaf74793beeebeb66e8bf7756297d1bc97a293166282a0ba77" + license: "PHP-3.01" + ci_only: true + modes: [dsn, connection_string] + expected: + discovered: true + required: [php-odbc.*] + - id: php-pdo + display_name: PHP PDO_ODBC tests + kind: framework + language: PHP + tier: core + dockerfile: bindings/Dockerfile + runtime_image: ubuntu:24.04@sha256:019e8eb29a85e74d64925745884f2ec79aa27e3feab36353d24656f4d6b89467 + runtime_version: ["php", "--version"] + source: + kind: "archive" + url: "https://codeload.github.com/php/php-src/tar.gz/refs/tags/php-8.3.6" + revision: "php-8.3.6" + sha256: "af9ca6ea711391eaf74793beeebeb66e8bf7756297d1bc97a293166282a0ba77" + license: "PHP-3.01" + ci_only: true + modes: [dsn, connection_string] + expected: + discovered: true + required: [php-pdo.*] + - id: ruby + display_name: Ruby ANSI and UTF-8 ODBC tests + kind: framework + language: Ruby + tier: core + dockerfile: bindings/Dockerfile + runtime_image: ubuntu:24.04@sha256:019e8eb29a85e74d64925745884f2ec79aa27e3feab36353d24656f4d6b89467 + runtime_version: ["ruby", "--version"] + source: + kind: "archive" + url: "https://rubygems.org/downloads/ruby-odbc-0.999993.gem" + revision: "0.999993" + sha256: "ebf2997bd1ac6e06c30248c0f055c2ec4e93b6885bf8610968363215525b649c" + license: "GPL-2.0-or-later OR Ruby" + ci_only: true + modes: [dsn, connection_string] + expected: + discovered: true + required: [ruby.*] + - id: lua + display_name: LuaSQL ODBC tests + kind: framework + language: Lua + tier: core + dockerfile: bindings/Dockerfile + runtime_image: ubuntu:24.04@sha256:019e8eb29a85e74d64925745884f2ec79aa27e3feab36353d24656f4d6b89467 + runtime_version: ["lua5.4", "-v"] + source: + kind: "archive" + url: "https://codeload.github.com/lunarmodules/luasql/tar.gz/491fea76b9d9ee613fcd7de6b8a1c902e3668d11" + revision: "491fea76b9d9ee613fcd7de6b8a1c902e3668d11" + sha256: "f777c75dec5effeb51c8206fc87c88d6a9c6eca59da148777b2815e825f14b27" + license: "MIT" + ci_only: true + modes: [dsn, connection_string] + expected: + discovered: true + required: [lua.*] + - id: r + display_name: R odbc and DBItest + kind: framework + language: R + tier: core + dockerfile: bindings/Dockerfile + runtime_image: ubuntu:24.04@sha256:019e8eb29a85e74d64925745884f2ec79aa27e3feab36353d24656f4d6b89467 + runtime_version: ["R", "--version"] + source: + kind: "archive" + url: "https://codeload.github.com/r-dbi/odbc/tar.gz/refs/tags/v1.4.2" + revision: "v1.4.2" + sha256: "333a6b91180304adb56fd947449abf9f3c8c9b1998457c61c8e665630d4d19d4" + license: "MIT" + ci_only: true + modes: [dsn, connection_string] + expected: + discovered: true + required: [r.*] diff --git a/odbc/tests/frameworks/repros/README.md b/odbc/tests/frameworks/repros/README.md new file mode 100644 index 00000000000..491fd7e9dcd --- /dev/null +++ b/odbc/tests/frameworks/repros/README.md @@ -0,0 +1,96 @@ +# Consumer defect reproductions + +Use the matrix's locked consumer sources without implementation patches. +These programs also run against independent ODBC drivers. References and exact +case/diagnostic matches are in `../registry.yaml`. + +Install control drivers with `apt-get install libsqliteodbc odbc-postgresql`. +Provide a disposable PostgreSQL database in `PG_ODBC`, for example +`Driver=PostgreSQL Unicode;Server=localhost;Port=5432;Database=postgres;Uid=odbc;Pwd=odbc`. + +## Qt 6.4.2 + +```sh +c++ qt-null.cpp -o qt-null $(pkg-config --cflags --libs Qt6Core Qt6Sql) +./qt-null 'Driver=SQLite3;Database=:memory:' +``` + +Observed: `value valid=0 null=1 type=invalid queryNull=1`. +The NULL should retain the QString type. QODBC's `qGetStringData()` returns +an invalid QVariant after receiving SQL_NULL_DATA. + +```sh +c++ qt-tinyint.cpp -o qt-tinyint $(pkg-config --cflags --libs Qt6Core Qt6Sql) -lodbc +./qt-tinyint +./qt-tinyint 'Driver=YDB;Server=localhost:2136;Database=/local;AuthMode=Anonymous' +``` + +Both drivers advertise signed SQL_TINYINT and return `-128` through SQL_C_SLONG. +QODBC nevertheless exposes UInt. SQLite wraps its unsigned read to `4294967168`; +YDB correctly rejects it with `22003`, leaving Qt with an invalid value. +The separate SQLite Boolean-metadata case expects Bool; QODBC deliberately maps +SQL_BIT to Int/UInt. That convention is a binding limitation, not a driver defect. + +```sh +c++ qt-timestamp.cpp -o qt-timestamp $(pkg-config --cflags --libs Qt6Core Qt6Sql) -lodbc +./qt-timestamp +./qt-timestamp 'Driver=YDB;Server=localhost:2136;Database=/local;AuthMode=Anonymous' +``` + +Both SQLite ODBC and YDB reproduce a one-hour shift for the `UTC+01:00` input. +The raw timestamp is `2150-01-05 14:00:00.123`: QODBC copied wall-clock fields +without normalizing the offset before sending the timezone-free ODBC structure. + +## PHP PDO_ODBC 8.3.6 + +```sh +php pdo-lazy.php "$PG_ODBC" +``` + +Observed lengths: `600, -1, -1`; the last two accesses return NULL. +Each access should return the same 600-byte string. PDO_ODBC calls SQLGetData +again after exhausting the column, without caching it. +SQLite ODBC restarts this stream after SQL_NO_DATA and hides the defect; use PostgreSQL here. + +## LuaSQL 491fea76, Lua 5.4, 64-bit unixODBC + +Build the locked LuaSQL archive with `make odbc LUA_SYS_VER=5.4` and expose +`src/odbc.so` as `luasql/odbc.so` on LUA_CPATH. + +```sh +lua5.4 lua-fetch.lua 'Driver=SQLite3;Database=:memory:' +``` + +Expected: `b, c, nil`, then `4294967296` and `-4294967297`. +Observed: `c, userdata, nil`, then incorrect integers with varying upper bytes. +Fetching the final 40-column NULL row can corrupt the Lua stack and abort the process. +The [upstream fix](https://github.com/lunarmodules/luasql/pull/219) explains both defects. +The matrix isolates cases and preserves debugger output for crashes. +Only these undefined-behavior cases allow intermittent passes; unmatched diagnostics still fail. + +## R odbc 1.4.2, DBItest 1.8.0 + +Install the unmodified locked packages in R_LIBS_USER, then: + +```sh +Rscript r-contract.R "$PG_ODBC" postgres-results +Rscript r-contract.R 'Driver=SQLite3;Database=control.sqlite' sqlite-results list_objects_features +Rscript r-bind-types.R "$PG_ODBC" +``` + +`r-contract.R` runs DBItest without YDB fixtures and writes every original +case outcome to `r-results.json`. The metadata probe leaves one ordinary table +visible; an empty catalog hides the identifier component-name mismatch. + +Control runs reproduce the missing warnings/errors, invalid row-limit handling, +parameter-list validation, completion/affected-row state, POSIXlt error and missing +DBI reexports classified in the registry. The time round trips return seconds +instead of minutes. The focused binding probe returns `2.5` instead of `1.5` for +the same literal comparisons used by DBItest: factors become integer codes, +integer Dates lose their class, difftime units are ignored, and a timestamp +parameter does not match R's own quoted timestamp literal. + +These exceptions do not cover YDB driver failures. R's three generic DDL cases +are separately classified as unavailable YDB type syntax: an interoperable +application must use the native names returned by +[SQLGetTypeInfo](https://learn.microsoft.com/en-us/sql/odbc/reference/appendixes/sql-minimum-grammar). diff --git a/odbc/tests/frameworks/repros/lua-fetch.lua b/odbc/tests/frameworks/repros/lua-fetch.lua new file mode 100644 index 00000000000..353fa0cf916 --- /dev/null +++ b/odbc/tests/frameworks/repros/lua-fetch.lua @@ -0,0 +1,19 @@ +local env = assert(require("luasql.odbc").odbc()) +local conn = assert(env:connect(arg[1])) +local cur = assert(conn:execute([[SELECT + CAST('b' AS VARCHAR(10)), CAST('c' AS VARCHAR(10)), + CAST(NULL AS VARCHAR(10))]])) +print("strings:", cur:fetch()) +assert(cur:close()) +for _, value in ipairs {"4294967296", "-4294967297"} do + cur = assert(conn:execute("SELECT CAST(" .. value .. " AS BIGINT)")) + print(value .. ":", cur:fetch()) + assert(cur:close()) +end +local columns = {"CAST('x' AS VARCHAR(10))"} +for i=2,40 do columns[i] = "CAST(NULL AS VARCHAR(10))" end +cur = assert(conn:execute("SELECT " .. table.concat(columns, ","))) +print("wide NULL row:", cur:fetch()) +assert(cur:close()) +assert(conn:close()) +assert(env:close()) diff --git a/odbc/tests/frameworks/repros/pdo-lazy.php b/odbc/tests/frameworks/repros/pdo-lazy.php new file mode 100644 index 00000000000..98da15afd1c --- /dev/null +++ b/odbc/tests/frameworks/repros/pdo-lazy.php @@ -0,0 +1,5 @@ + PDO::ERRMODE_EXCEPTION]); +$s = $p->query("SELECT '" . str_repeat('x',600) . "' AS value"); +$r = $s->fetch(PDO::FETCH_LAZY); +for($i=0;$i<3;++$i){$v=$r->value;echo "read $i type=".gettype($v)." length=".(is_string($v)?strlen($v):-1)."\n";} diff --git a/odbc/tests/frameworks/repros/qt-null.cpp b/odbc/tests/frameworks/repros/qt-null.cpp new file mode 100644 index 00000000000..a203c79d308 --- /dev/null +++ b/odbc/tests/frameworks/repros/qt-null.cpp @@ -0,0 +1,25 @@ +#include +#include +#include +#include +#include +#include + +int main(int argc, char** argv) { + QCoreApplication app(argc, argv); + if (argc < 2) return 2; + auto db = QSqlDatabase::addDatabase("QODBC"); + db.setDatabaseName(argv[1]); + if (!db.open()) { + qCritical("%s", qPrintable(db.lastError().text())); + return 1; + } + QSqlQuery query(db); + if (!query.exec(argc > 2 ? argv[2] : "SELECT CAST(NULL AS VARCHAR(20)) AS value") || !query.next()) { + qCritical("%s", qPrintable(query.lastError().text())); + return 1; + } + const auto value = query.value(0); + std::printf("value valid=%d null=%d type=%s queryNull=%d\n", value.isValid(), value.isNull(), + value.typeName() ? value.typeName() : "invalid", query.isNull(0)); +} diff --git a/odbc/tests/frameworks/repros/qt-timestamp.cpp b/odbc/tests/frameworks/repros/qt-timestamp.cpp new file mode 100644 index 00000000000..4fd0be149f1 --- /dev/null +++ b/odbc/tests/frameworks/repros/qt-timestamp.cpp @@ -0,0 +1,52 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +int main(int argc, char **argv) { + QCoreApplication app(argc, argv); + const bool ydb = argc > 1; + const QString connection = ydb ? QString::fromLocal8Bit(argv[1]) + : QString("Driver={SQLite3};Database=/tmp/qt-timestamp-control.db"); + auto db = QSqlDatabase::addDatabase("QODBC"); + db.setDatabaseName(connection); + if (!db.open()) { qCritical() << db.lastError(); return 1; } + QSqlQuery q(db); + q.exec("DROP TABLE IF EXISTS timestamp_control"); + if (!q.exec(ydb ? "CREATE TABLE timestamp_control (id Int32, v Timestamp64, PRIMARY KEY (id))" + : "CREATE TABLE timestamp_control (id INTEGER PRIMARY KEY, v TIMESTAMP)")) { + qCritical() << q.lastError(); return 2; + } + const QDateTime expected(QDate(2150, 1, 5), QTime(14, 0, 0, 123), Qt::OffsetFromUTC, 3600); + q.prepare("INSERT INTO timestamp_control (id, v) VALUES (?, ?)"); + q.addBindValue(1); q.addBindValue(expected); + if (!q.exec()) { qCritical() << q.lastError(); return 3; } + if (!q.exec("SELECT v FROM timestamp_control") || !q.next()) { qCritical() << q.lastError(); return 4; } + const QDateTime actual = q.value(0).toDateTime(); + qInfo() << "expected" << expected.toString(Qt::ISODateWithMs) << expected.toMSecsSinceEpoch(); + qInfo() << "actual" << actual.toString(Qt::ISODateWithMs) << actual.toMSecsSinceEpoch() + << "delta ms" << expected.msecsTo(actual) << "equal" << (expected == actual); + SQLHENV env = SQL_NULL_HENV; SQLHDBC dbc = SQL_NULL_HDBC; SQLHSTMT stmt = SQL_NULL_HSTMT; + SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env); + SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, reinterpret_cast(SQL_OV_ODBC3), 0); + SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc); + auto cs = connection.toUtf8(); + if (!SQL_SUCCEEDED(SQLDriverConnectA(dbc, nullptr, reinterpret_cast(cs.data()), SQL_NTS, + nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT))) return 5; + SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt); + SQLExecDirectA(stmt, reinterpret_cast(const_cast("SELECT v FROM timestamp_control")), SQL_NTS); + SQLFetch(stmt); SQL_TIMESTAMP_STRUCT value = {}; SQLLEN length = 0; + auto status = SQLGetData(stmt, 1, SQL_C_TYPE_TIMESTAMP, &value, sizeof(value), &length); + qInfo() << "raw timestamp" << status << value.year << value.month << value.day + << value.hour << value.minute << value.second << value.fraction; + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); + q.exec("DROP TABLE timestamp_control"); +} diff --git a/odbc/tests/frameworks/repros/qt-tinyint.cpp b/odbc/tests/frameworks/repros/qt-tinyint.cpp new file mode 100644 index 00000000000..343f72e7aa1 --- /dev/null +++ b/odbc/tests/frameworks/repros/qt-tinyint.cpp @@ -0,0 +1,63 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +int main(int argc, char **argv) { + QCoreApplication app(argc, argv); + const bool ydb = argc > 1; + const QString connection = ydb ? QString::fromLocal8Bit(argv[1]) + : QString("Driver={SQLite3};Database=/tmp/qt-tinyint-control.db"); + auto db = QSqlDatabase::addDatabase("QODBC"); + db.setDatabaseName(connection); + if (!db.open()) { qCritical() << db.lastError(); return 1; } + QSqlQuery q(db); + q.exec("DROP TABLE IF EXISTS tinyint_control"); + if (!q.exec(ydb ? "CREATE TABLE tinyint_control (v Int8, PRIMARY KEY (v))" : "CREATE TABLE tinyint_control (v TINYINT)")) return 2; + if (!q.exec(ydb ? "INSERT INTO tinyint_control (v) VALUES (CAST(-128 AS Int8))" : "INSERT INTO tinyint_control VALUES (-128)")) return 3; + if (!q.exec("SELECT v FROM tinyint_control") || !q.next()) return 4; + qInfo() << "QODBC metadata" << q.record().field(0).metaType().name() + << "value" << q.value(0) << "as signed char" << int(q.value(0).value()) + << "as signed wide" << q.value(0).toLongLong(); + SQLHENV env = SQL_NULL_HENV; + SQLHDBC dbc = SQL_NULL_HDBC; + SQLHSTMT stmt = SQL_NULL_HSTMT; + SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env); + SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, reinterpret_cast(SQL_OV_ODBC3), 0); + SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc); + auto cs = connection.toUtf8(); + if (!SQL_SUCCEEDED(SQLDriverConnectA(dbc, nullptr, reinterpret_cast(cs.data()), SQL_NTS, + nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT))) return 5; + SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt); + SQLExecDirectA(stmt, reinterpret_cast(const_cast("SELECT v FROM tinyint_control")), SQL_NTS); + SQLSMALLINT type = 0; + SQLLEN unsignedFlag = -1, length = 0; + SQLCHAR columnName[128] = {}; SQLSMALLINT nameLength = 0, decimalDigits = 0, nullable = 0; SQLULEN columnSize = 0; + SQLDescribeColA(stmt, 1, columnName, sizeof(columnName), &nameLength, &type, &columnSize, &decimalDigits, &nullable); + SQLColAttributeA(stmt, 1, SQL_DESC_UNSIGNED, nullptr, 0, nullptr, &unsignedFlag); + SQLFetch(stmt); + SQLINTEGER signedValue = 0; SQLUINTEGER unsignedValue = 0; + auto signedStatus = SQLGetData(stmt, 1, SQL_C_SLONG, &signedValue, sizeof(signedValue), &length); + SQLCloseCursor(stmt); + SQLExecDirectA(stmt, reinterpret_cast(const_cast("SELECT v FROM tinyint_control")), SQL_NTS); + SQLFetch(stmt); + auto unsignedStatus = SQLGetData(stmt, 1, SQL_C_ULONG, &unsignedValue, sizeof(unsignedValue), &length); + qInfo() << "raw metadata SQL type" << type << "unsigned" << unsignedFlag + << "SQL_C_SLONG" << signedStatus << signedValue + << "SQL_C_ULONG" << unsignedStatus << unsignedValue; + if (!SQL_SUCCEEDED(unsignedStatus)) { + SQLCHAR state[6] = {}; SQLCHAR message[1024] = {}; + SQLGetDiagRecA(SQL_HANDLE_STMT, stmt, 1, state, nullptr, message, sizeof(message), nullptr); + qInfo() << "unsigned read diagnostic" << reinterpret_cast(state) << reinterpret_cast(message); + } + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); + q.exec("DROP TABLE tinyint_control"); +} diff --git a/odbc/tests/frameworks/repros/r-bind-types.R b/odbc/tests/frameworks/repros/r-bind-types.R new file mode 100644 index 00000000000..9da5bad0c67 --- /dev/null +++ b/odbc/tests/frameworks/repros/r-bind-types.R @@ -0,0 +1,21 @@ +library(DBI) +library(odbc) +con <- dbConnect(odbc(), .connection_string=commandArgs(TRUE)[[1]]) +cases <- list( + factor=list(factor("label"), "VARCHAR(20)", "label"), + date_integer=list(structure(18618L, class="Date"), "DATE", "2020-12-22"), + timestamp=list(as.POSIXct("2023-12-17 02:40:49", tz="UTC"), "TIMESTAMP", "2023-12-17 02:40:49"), + time_hours=list(structure(1, class="difftime", units="hours"), "TIME", "01:00:00"), + time_minutes=list(structure(1, class="difftime", units="mins"), "TIME", "00:01:00")) +for (name in names(cases)) { + x <- cases[[name]] + value <- tryCatch(dbGetQuery(con, paste0("SELECT CAST(? AS ",x[[2]],") AS value"), params=list(x[[1]])), + error=function(e) conditionMessage(e)) + literal <- dbQuoteLiteral(con, x[[1]]) + comparison <- tryCatch(dbGetQuery(con, paste0("SELECT CASE WHEN ? = ", literal, + " THEN 1.5 ELSE 2.5 END AS value"), params=list(x[[1]])), + error=function(e) conditionMessage(e)) + cat("comparison",name,"expected 1.5 returned",paste(capture.output(print(comparison)),collapse=" "),"\n") + cat(name, "expected", x[[3]], "returned", paste(capture.output(print(value)),collapse=" "), "\n") +} +dbDisconnect(con) diff --git a/odbc/tests/frameworks/repros/r-contract.R b/odbc/tests/frameworks/repros/r-contract.R new file mode 100644 index 00000000000..54bb3ec0064 --- /dev/null +++ b/odbc/tests/frameworks/repros/r-contract.R @@ -0,0 +1,41 @@ +library(DBI) +library(odbc) +library(DBItest) +library(testthat) +native <- commandArgs(TRUE)[[2]] +dir.create(native, recursive=TRUE, showWarnings=FALSE) +# Arrow requires a separate binding API; stress uses ordinary DBI connections. +categories <- c("getting_started", "driver", "connection", "result", "sql", "meta", "transaction", "compliance", "stress") +specs <- unlist(lapply(categories, function(name) get(paste0("spec_", name), asNamespace("DBItest"))), recursive=FALSE) +specs <- specs[!vapply(specs,is.null,logical(1))] +names(specs) <- vctrs::vec_names2(specs, repair="unique", quiet=TRUE) +specs <- specs[!grepl("arrow|stream_bind",names(specs))] +context <- DBItest::make_context(odbc::odbc(), + list(.connection_string=commandArgs(TRUE)[[1]]), name="SQLite", default_skip=NULL, + tweaks=DBItest::tweaks(dbitest_version="1.8.0", placeholder_pattern="?")) +selected <- commandArgs(TRUE)[-(1:2)] +if (length(selected)) specs <- specs[names(specs) %in% selected] +# Keep a real table visible: an empty catalog hides the identifier round-trip defect. +con <- dbConnect(odbc::odbc(), .connection_string=commandArgs(TRUE)[[1]]) +dbExecute(con, "DROP TABLE IF EXISTS odbc_control_metadata") +dbExecute(con, "CREATE TABLE odbc_control_metadata (a INTEGER)") +dbDisconnect(con) +results <- list() +for (name in names(specs)) { + collector <- testthat::ListReporter$new() + testthat::with_reporter(collector, { + DBItest:::run_tests(context, specs[name], skip=NULL, run_only=NULL, test_suite="YDB") + }) + cases <- collector$get_results() + problems <- unlist(lapply(cases,function(case) lapply(Filter(function(result) + !inherits(result,"expectation_success"), case$results),function(result) + list(message=conditionMessage(result)))),recursive=FALSE) + failed <- any(vapply(unlist(lapply(cases,`[[`,"results"),recursive=FALSE),function(result) + inherits(result,c("expectation_failure","expectation_error","expectation_warning")),logical(1))) + results[[length(results)+1L]] <- list(name=name, + status=if(!length(cases)) "broken" else if(failed) "failed" else if(length(problems)) "skipped" else "passed", + message=if(!length(cases)) "DBItest produced no result" else + paste(vapply(problems,`[[`,"", "message"),collapse="\n"), problems=problems) + jsonlite::write_json(results,file.path(native,"r-results.json"),auto_unbox=TRUE,pretty=TRUE) +} + diff --git a/odbc/tests/frameworks/ruby/report.rb b/odbc/tests/frameworks/ruby/report.rb new file mode 100644 index 00000000000..3790f2c330a --- /dev/null +++ b/odbc/tests/frameworks/ruby/report.rb @@ -0,0 +1,26 @@ +require 'json' +variant = ARGV.shift +require variant +connection = ARGV.shift +results = [] +$dsn, $uid, $pwd = connection, nil, nil +Dir.glob('[0-9]*.rb').sort.each do |path| + begin + load path + results << {name: path, status: 'passed'} + rescue Exception => error + results << {name: path, status: 'failed', message: "#{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"} + break + end +end +File.write(File.join(ENV.fetch('ODBC_NATIVE_RESULTS_DIR'), + variant + '.json'), JSON.generate(results)) +begin + if $c && $c.connected? + $c.drop_all + $c.do('DROP TABLE IF EXISTS test') + $c.disconnect + end +rescue => error + warn error.message +end diff --git a/odbc/tests/frameworks/ruby/run-tests b/odbc/tests/frameworks/ruby/run-tests new file mode 100755 index 00000000000..4313bb2f81c --- /dev/null +++ b/odbc/tests/frameworks/ruby/run-tests @@ -0,0 +1,21 @@ +#!/usr/bin/env python3 +import sys +sys.path.insert(0, '/harness/bindings') +from adapter import run + +def main(s): + names = [p.name for p in sorted((s.source / 'test').glob('[0-9]*.rb'))] + s.plan([variant + '.' + name for variant in ('odbc', 'odbc_utf8') for name in names]) + for variant, directory in [('odbc', 'ext'), ('odbc_utf8', 'ext/utf8')]: + ext = s.source / directory + s.command(['ruby', 'extconf.rb', '--with-odbc-dir=/usr'], variant+'-configure', cwd=ext) + s.command(['make', '-j2'], variant+'-build', cwd=ext) + s.command(['ruby', '-I', ext, s.adapter / 'report.rb', variant, s.connection], variant, + cwd=s.source / 'test', check=False) + import json + results = json.loads((s.native / (variant + '.json')).read_text()) + for test in results: + s.add(variant + '.' + test['name'], test['status'], test.get('message', ''), + attachments=[s.native / (variant + '.log')]) + +raise SystemExit(run(main)) diff --git a/odbc/tests/frameworks/ruby/upstream.lock b/odbc/tests/frameworks/ruby/upstream.lock new file mode 100644 index 00000000000..67d5b6e6311 --- /dev/null +++ b/odbc/tests/frameworks/ruby/upstream.lock @@ -0,0 +1,6 @@ +kind: archive +url: https://rubygems.org/downloads/ruby-odbc-0.999993.gem +revision: '0.999993' +sha256: ebf2997bd1ac6e06c30248c0f055c2ec4e93b6885bf8610968363215525b649c +license: GPL-2.0-or-later OR Ruby +ci_only: true diff --git a/odbc/tests/frameworks/ruby/ydb.patch b/odbc/tests/frameworks/ruby/ydb.patch new file mode 100644 index 00000000000..30968594493 --- /dev/null +++ b/odbc/tests/frameworks/ruby/ydb.patch @@ -0,0 +1,21 @@ +--- a/test/10create_table.rb ++++ b/test/10create_table.rb +@@ -1 +1 @@ +-$c.run("create table test (id int not null, str varchar(32) not null)") ++$c.run("CREATE TABLE test (fixture_key Int32, id int not null, str Utf8 not null, PRIMARY KEY (fixture_key))") +--- a/test/20insert.rb ++++ b/test/20insert.rb +@@ -1,5 +1,5 @@ +-$q = $c.run("insert into test (id, str) values (1, 'foo')") +-$q.run("insert into test (id, str) values (2, 'bar')") ++$q = $c.run("insert into test (fixture_key, id, str) values (1, 1, 'foo')") ++$q.run("insert into test (fixture_key, id, str) values (2, 2, 'bar')") + +-$p = $c.proc("insert into test (id, str) values (?, ?)") {} ++$p = $c.proc("insert into test (fixture_key, id, str) SELECT id AS fixture_key, id, str FROM (SELECT Unwrap(CAST(? AS Int32)) AS id, ? AS str)") {} + $p.call(3, "FOO") +--- a/test/00connect.rb ++++ b/test/00connect.rb +@@ -1 +1 @@ +-$c = ODBC.connect($dsn, $uid, $pwd) ++$c = (ENV['ODBC_TEST_MODE'] == 'dsn' ? ODBC.connect($dsn, $uid, $pwd) : ODBC::Database.new.drvconnect($dsn)) diff --git a/odbc/tests/integration/CMakeLists.txt b/odbc/tests/integration/CMakeLists.txt new file mode 100644 index 00000000000..be74f21140b --- /dev/null +++ b/odbc/tests/integration/CMakeLists.txt @@ -0,0 +1,62 @@ +add_odbc_test(NAME odbc-basic_it + SOURCES + basic_it.cpp +) + +add_odbc_test(NAME odbc-environment_api_it + SOURCES + environment_api_it.cpp +) + +add_odbc_test(NAME odbc-connection_api_it + SOURCES + connection_api_it.cpp +) + +add_odbc_test(NAME odbc-authentication_it + SOURCES + authentication_it.cpp + LINK_LIBRARIES + tests-iam-mocks + client-oauth2-ut-helpers + cpp-testing-unittest +) + +add_odbc_test(NAME odbc-statement_api_it + SOURCES + statement_api_it.cpp +) + +add_odbc_test(NAME odbc-transaction_api_it + SOURCES + transaction_api_it.cpp +) + +add_odbc_test(NAME odbc-error_handling_it + SOURCES + error_handling_it.cpp +) + +add_odbc_test(NAME odbc-metadata_api_it + SOURCES + metadata_api_it.cpp +) + +add_odbc_test(NAME odbc-core_api_it + SOURCES + core_api_it.cpp +) + +add_odbc_test(NAME odbc-descriptor_api_it + SOURCES + descriptor_api_it.cpp +) + +# Link the driver directly: Driver Manager locks must not mask driver races. +add_ydb_test(NAME odbc-concurrency_it GTEST + TIMEOUT 30 + SOURCES concurrency_it.cpp + INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../src ${ODBC_INCLUDE_DIRS} + LINK_LIBRARIES ydb-odbc + LABELS integration +) diff --git a/odbc/tests/integration/authentication_it.cpp b/odbc/tests/integration/authentication_it.cpp new file mode 100644 index 00000000000..6050fa0acaa --- /dev/null +++ b/odbc/tests/integration/authentication_it.cpp @@ -0,0 +1,251 @@ +#include "test_utils.h" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include + +using namespace NYdb::NTest; + +namespace { + +constexpr std::string_view RootToken = "root@builtin"; + +class TScopedEnvironmentVariable { +public: + TScopedEnvironmentVariable(std::string_view name, std::string_view value) + : Name_(name) + { + if (const char* oldValue = std::getenv(Name_.c_str())) { + OldValue_ = oldValue; + } + setenv(Name_.c_str(), std::string(value).c_str(), 1); + } + + ~TScopedEnvironmentVariable() { + if (OldValue_) { + setenv(Name_.c_str(), OldValue_->c_str(), 1); + } else { + unsetenv(Name_.c_str()); + } + } + +private: + std::string Name_; + std::optional OldValue_; +}; + +class OdbcAuthentication : public ::testing::Test { +protected: + void SetUp() override { + const char* endpoint = std::getenv("YDB_ENDPOINT"); + const char* database = std::getenv("YDB_DATABASE"); + if (!endpoint || !database) { + GTEST_SKIP() << "Authentication integration tests require the IAM-enabled YDB fixture"; + } + Endpoint_ = endpoint; + Database_ = database; + AllocEnv(&Env_); + } + + void TearDown() override { + Disconnect(); + if (Env_ != SQL_NULL_HENV) { + SQLFreeHandle(SQL_HANDLE_ENV, Env_); + } + } + + void Connect(std::string_view authenticationAttributes) { + Disconnect(); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, Env_, &Dbc_), SQL_SUCCESS); + std::string connectionString = "Driver=" ODBC_DRIVER_PATH ";Endpoint=" + Endpoint_ + + ";Database=" + Database_ + ";" + std::string(authenticationAttributes); + const SQLRETURN rc = SQLDriverConnect( + Dbc_, nullptr, reinterpret_cast(connectionString.data()), SQL_NTS, + nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT); + CHECK_ODBC_OK(rc, Dbc_, SQL_HANDLE_DBC); + } + + void Disconnect() { + if (Dbc_ != SQL_NULL_HDBC) { + SQLDisconnect(Dbc_); + SQLFreeHandle(SQL_HANDLE_DBC, Dbc_); + Dbc_ = SQL_NULL_HDBC; + } + } + + void Execute(std::string_view query) { + SQLHSTMT statement = SQL_NULL_HSTMT; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, Dbc_, &statement), SQL_SUCCESS); + std::string queryString(query); + const SQLRETURN rc = SQLExecDirect( + statement, reinterpret_cast(queryString.data()), SQL_NTS); + CHECK_ODBC_OK(rc, statement, SQL_HANDLE_STMT); + SQLFreeHandle(SQL_HANDLE_STMT, statement); + } + + void SelectOne() { + Execute("SELECT 1"); + } + + void ExpectSelectOneAuthFailure() { + SQLHSTMT statement = SQL_NULL_HSTMT; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, Dbc_, &statement), SQL_SUCCESS); + SQLCHAR query[] = "SELECT 1"; + const SQLRETURN rc = SQLExecDirect(statement, query, SQL_NTS); + EXPECT_EQ(rc, SQL_ERROR); + if (rc == SQL_ERROR) { + const std::string error = GetOdbcError(statement, SQL_HANDLE_STMT); + EXPECT_TRUE(SqlStatePrefix(error, "28000")) << error; + } + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_STMT, statement), SQL_SUCCESS); + } + + SQLHENV Env_ = SQL_NULL_HENV; + SQLHDBC Dbc_ = SQL_NULL_HDBC; + std::string Endpoint_; + std::string Database_; +}; + +} // namespace + +TEST_F(OdbcAuthentication, TokenAndAccessTokenAlias) { + ASSERT_NO_FATAL_FAILURE(Connect("AuthMode=Token;Token=root@builtin;")); + ASSERT_NO_FATAL_FAILURE(SelectOne()); + + ASSERT_NO_FATAL_FAILURE(Connect("AccessToken=root@builtin;")); + ASSERT_NO_FATAL_FAILURE(SelectOne()); +} + +TEST_F(OdbcAuthentication, Anonymous) { + ASSERT_NO_FATAL_FAILURE(Connect("AuthMode=Anonymous;")); + ASSERT_NO_FATAL_FAILURE(ExpectSelectOneAuthFailure()); +} + +TEST_F(OdbcAuthentication, StaticUserAndPasswordAliases) { + const char* user = std::getenv("YDB_ODBC_STATIC_USER"); + const char* password = std::getenv("YDB_ODBC_STATIC_PASSWORD"); + if (!user || !password) { + GTEST_SKIP() << "Static authentication requires credentials provisioned by the IAM fixture"; + } + + ASSERT_NO_FATAL_FAILURE(Connect( + "AuthMode=Static;UID=" + std::string(user) + ";PWD=" + std::string(password) + ";")); + ASSERT_NO_FATAL_FAILURE(SelectOne()); +} + +TEST_F(OdbcAuthentication, TemporalBindingsWithWriteOnlyPermissions) { + ASSERT_NO_FATAL_FAILURE(Connect("AuthMode=Token;Token=root@builtin;")); + ASSERT_NO_FATAL_FAILURE(Execute("DROP TABLE IF EXISTS odbc_temporal_write_only")); + ASSERT_NO_FATAL_FAILURE(Execute( + "CREATE TABLE odbc_temporal_write_only (id Int32 NOT NULL, d Date, ts Timestamp, PRIMARY KEY (id))")); + Y_DEFER { + ASSERT_NO_FATAL_FAILURE(Connect("AuthMode=Token;Token=root@builtin;")); + ASSERT_NO_FATAL_FAILURE(Execute("DROP TABLE odbc_temporal_write_only")); + ASSERT_NO_FATAL_FAILURE(Execute( + "REVOKE CONNECT ON `" + Database_ + "` FROM `odbc_temporal_writer@builtin`")); + }; + ASSERT_NO_FATAL_FAILURE(Execute( + "GRANT CONNECT ON `" + Database_ + "` TO `odbc_temporal_writer@builtin`")); + ASSERT_NO_FATAL_FAILURE(Execute( + "GRANT DESCRIBE SCHEMA, UPDATE ROW ON `" + Database_ + + "/odbc_temporal_write_only` TO `odbc_temporal_writer@builtin`")); + ASSERT_NO_FATAL_FAILURE(Connect("AuthMode=Token;Token=odbc_temporal_writer@builtin;")); + ASSERT_NO_FATAL_FAILURE(Execute( + "INSERT INTO odbc_temporal_write_only (id, d, ts) VALUES " + "(1, Date(\"2024-06-15\"), Timestamp(\"2024-06-15T14:30:20.123456Z\"))")); + + SQLHSTMT statement = SQL_NULL_HSTMT; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, Dbc_, &statement), SQL_SUCCESS); + Y_DEFER { + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_STMT, statement), SQL_SUCCESS); + }; + SQLCHAR select[] = "SELECT d, ts FROM odbc_temporal_write_only"; + ASSERT_EQ(SQLExecDirect(statement, select, SQL_NTS), SQL_ERROR); + const std::string error = GetOdbcError(statement, SQL_HANDLE_STMT); + EXPECT_TRUE(SqlStatePrefix(error, "28000") || error.find("AccessDenied") != std::string::npos) << error; + + SQLCHAR insert[] = "INSERT INTO odbc_temporal_write_only (id, d, ts) VALUES (2, ?, ?)"; + CHECK_ODBC_OK(SQLPrepare(statement, insert, SQL_NTS), statement, SQL_HANDLE_STMT); + SQL_DATE_STRUCT date{2024, 6, 15}; + SQL_TIMESTAMP_STRUCT timestamp{2024, 6, 15, 14, 30, 20, 123456000}; + SQLLEN dateLength = sizeof(date), timestampLength = sizeof(timestamp); + CHECK_ODBC_OK(SQLBindParameter(statement, 1, SQL_PARAM_INPUT, SQL_C_TYPE_DATE, SQL_TYPE_DATE, + 10, 0, &date, sizeof(date), &dateLength), statement, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(statement, 2, SQL_PARAM_INPUT, SQL_C_TYPE_TIMESTAMP, SQL_TYPE_TIMESTAMP, + 26, 6, ×tamp, sizeof(timestamp), ×tampLength), statement, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(statement), statement, SQL_HANDLE_STMT); +} + +TEST_F(OdbcAuthentication, MetadataService) { + TMetadataServer server; + server.SetResponse(HTTP_OK, MakeTokenResponse(std::string(RootToken), 3600)); + + ASSERT_NO_FATAL_FAILURE(Connect("AuthMode=Metadata;MetadataHost=127.0.0.1;MetadataPort=" + + std::to_string(server.Port) + ";")); + ASSERT_NO_FATAL_FAILURE(SelectOne()); + + EXPECT_GE(server.GetRequestCount(), 1); + AssertMetadataRequestShape(server); +} + +TEST_F(OdbcAuthentication, ServiceAccountFileAndAlias) { + TIamTokenServiceStub stub; + stub.SetResponseToken(std::string(RootToken)); + TIamGrpcServer server(&stub); + ASSERT_TRUE(server.Start()); + + TTempDir tempDirectory; + const TString keyPath = tempDirectory.Path() / "service-account.json"; + TFileOutput(keyPath).Write(MakeJwtKeyFileContent()); + + ASSERT_NO_FATAL_FAILURE(Connect("AuthMode=ServiceAccount;SaFile=" + std::string(keyPath) + + ";IamEndpoint=grpc://" + server.Endpoint() + ";")); + ASSERT_NO_FATAL_FAILURE(SelectOne()); + + EXPECT_GE(stub.GetRequestCount(), 1); + ASSERT_TRUE(stub.HasLastRequest()); + AssertIamJwt(stub.GetLastRequest().jwt()); +} + +TEST_F(OdbcAuthentication, OAuth2TokenExchangeFile) { + TTestTokenExchangeServer server; + server.Check.ExpectedInputParams.emplace("grant_type", "urn:ietf:params:oauth:grant-type:token-exchange"); + server.Check.ExpectedInputParams.emplace("requested_token_type", "urn:ietf:params:oauth:token-type:access_token"); + server.Check.ExpectedInputParams.emplace("subject_token", "odbc-subject-token"); + server.Check.ExpectedInputParams.emplace("subject_token_type", "urn:ietf:params:oauth:token-type:access_token"); + server.Check.Response = + R"({"access_token":"root@builtin","token_type":"bearer","expires_in":3600})"; + + TTempDir tempDirectory; + const TString configPath = tempDirectory.Path() / "oauth2.json"; + TFileOutput(configPath).Write( + R"({"subject-credentials":{"type":"Fixed","token":"odbc-subject-token","token-type":"urn:ietf:params:oauth:token-type:access_token"}})"); + + ASSERT_NO_FATAL_FAILURE(Connect("AuthMode=OAuth2;OAuth2KeyFile=" + std::string(configPath) + + ";IamEndpoint=" + server.GetEndpoint() + ";")); + // The local IAM fixture accepts builtin tokens, not OAuth "Bearer" credentials. + ASSERT_NO_FATAL_FAILURE(ExpectSelectOneAuthFailure()); + server.CheckExpectations(); +} + +TEST_F(OdbcAuthentication, EnvironmentAccessToken) { + TScopedEnvironmentVariable serviceAccount("YDB_SERVICE_ACCOUNT_KEY_FILE_CREDENTIALS", ""); + TScopedEnvironmentVariable anonymous("YDB_ANONYMOUS_CREDENTIALS", "0"); + TScopedEnvironmentVariable metadata("YDB_METADATA_CREDENTIALS", "0"); + TScopedEnvironmentVariable oauth2("YDB_OAUTH2_KEY_FILE", ""); + TScopedEnvironmentVariable token("YDB_ACCESS_TOKEN_CREDENTIALS", RootToken); + ASSERT_NO_FATAL_FAILURE(Connect("AuthMode=Environment;")); + ASSERT_NO_FATAL_FAILURE(SelectOne()); +} diff --git a/odbc/tests/integration/basic_it.cpp b/odbc/tests/integration/basic_it.cpp new file mode 100644 index 00000000000..69423d962b9 --- /dev/null +++ b/odbc/tests/integration/basic_it.cpp @@ -0,0 +1,126 @@ +#include "test_utils.h" + +TEST(OdbcBasic, SimpleQuery) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), SQL_SUCCESS); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + CHECK_ODBC_OK(SQLDriverConnect(dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_COMPLETE), dbc, SQL_HANDLE_DBC); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + // Simple query + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1 AS z, 'abc'u AS a", SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + SQLINTEGER ival = 0; + char sval[16] = {0}; + SQLLEN ival_ind = 0, sval_ind = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &ival, 0, &ival_ind), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 2, SQL_C_CHAR, sval, sizeof(sval), &sval_ind), SQL_SUCCESS); + ASSERT_EQ(ival, 1); + ASSERT_STREQ(sval, "abc"); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(OdbcBasic, ParameterizedQuery) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), SQL_SUCCESS); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + CHECK_ODBC_OK(SQLDriverConnect(dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_COMPLETE), dbc, SQL_HANDLE_DBC); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLCHAR query[] = R"( + DECLARE $p1 AS Int32?; + SELECT $p1 + 10 AS res; + )"; + + // Parameterized query + CHECK_ODBC_OK(SQLPrepare(stmt, query, SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLINTEGER param = 5; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, ¶m, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + SQLINTEGER res = 0; + SQLLEN res_ind = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &res, 0, &res_ind), SQL_SUCCESS); + ASSERT_EQ(res, 15); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(OdbcBasic, ColumnBinding) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), SQL_SUCCESS); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + CHECK_ODBC_OK(SQLDriverConnect(dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_COMPLETE), dbc, SQL_HANDLE_DBC); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLCHAR query_ddl[] = R"( + DROP TABLE IF EXISTS test_bind; + CREATE TABLE test_bind (id Int32, name Text, PRIMARY KEY (id)); + )"; + + SQLCHAR query[] = R"( + UPSERT INTO test_bind (id, name) VALUES (1, 'foo'), (2, 'bar'); + SELECT id, name FROM test_bind ORDER BY id; + )"; + + CHECK_ODBC_OK(SQLExecDirect(stmt, query_ddl, SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, query, SQL_NTS), stmt, SQL_HANDLE_STMT); + + SQLINTEGER id = 0; + char name[16] = {0}; + SQLLEN id_ind = 0, name_ind = 0; + ASSERT_EQ(SQLBindCol(stmt, 1, SQL_C_LONG, &id, 0, &id_ind), SQL_SUCCESS); + ASSERT_EQ(SQLBindCol(stmt, 2, SQL_C_CHAR, name, sizeof(name), &name_ind), SQL_SUCCESS); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(id, 1); + ASSERT_STREQ(name, "foo"); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(id, 2); + ASSERT_STREQ(name, "bar"); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(OdbcBasic, SQLConnect) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + CHECK_ODBC_OK(SQLConnect(dbc, (SQLCHAR*)"YDB", SQL_NTS, (SQLCHAR*)"", SQL_NTS, (SQLCHAR*)"", SQL_NTS), + dbc, SQL_HANDLE_DBC); + + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1", SQL_NTS), stmt, SQL_HANDLE_STMT); + + SQLINTEGER val; + SQLLEN ind; + SQLBindCol(stmt, 1, SQL_C_SLONG, &val, 0, &ind); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(val, 1); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} diff --git a/odbc/tests/integration/concurrency_it.cpp b/odbc/tests/integration/concurrency_it.cpp new file mode 100644 index 00000000000..8bd5c9c6878 --- /dev/null +++ b/odbc/tests/integration/concurrency_it.cpp @@ -0,0 +1,614 @@ +#include "connection.h" +#include "environment.h" +#include "descriptor.h" +#include "statement.h" + +#include + +#include + +#include +#include +#include +#include +#include +#include + +using namespace std::chrono_literals; +using namespace NYdb::NOdbc; + +namespace { + +class TConnectionHandles { +public: + SQLHENV Env = SQL_NULL_HENV; + SQLHDBC Dbc = SQL_NULL_HDBC; + + TConnectionHandles() { + EXPECT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &Env), SQL_SUCCESS); + EXPECT_EQ(SQLSetEnvAttr(Env, SQL_ATTR_ODBC_VERSION, + reinterpret_cast(SQL_OV_ODBC3), 0), SQL_SUCCESS); + EXPECT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, Env, &Dbc), SQL_SUCCESS); + EXPECT_EQ(SQLDriverConnect(Dbc, nullptr, + reinterpret_cast(const_cast("Server=localhost:2136;Database=/local;")), + SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT), SQL_SUCCESS); + } + + ~TConnectionHandles() { + SQLDisconnect(Dbc); + SQLFreeHandle(SQL_HANDLE_DBC, Dbc); + SQLFreeHandle(SQL_HANDLE_ENV, Env); + } +}; + +class TStatementHandle { +public: + SQLHSTMT Handle = SQL_NULL_HSTMT; + + explicit TStatementHandle(SQLHDBC dbc) { + EXPECT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &Handle), SQL_SUCCESS); + EXPECT_EQ(SQLSetStmtAttr(Handle, SQL_ATTR_QUERY_TIMEOUT, + reinterpret_cast(10), 0), SQL_SUCCESS); + } + + explicit TStatementHandle(std::unique_ptr statement) { + auto& connection = statement->GetConnection(); + { + auto lifecycle = connection.LockShared(); + auto operation = connection.LockOperation(); + connection.AddChild(statement.get()); + Handle = static_cast(statement.release()); + } + EXPECT_EQ(SQLSetStmtAttr(Handle, SQL_ATTR_QUERY_TIMEOUT, + reinterpret_cast(10), 0), SQL_SUCCESS); + } + + ~TStatementHandle() { + if (Handle) { + SQLFreeHandle(SQL_HANDLE_STMT, Handle); + } + } +}; + +SQLRETURN Execute(SQLHSTMT stmt, const char* query = "SELECT 42 AS value") { + return SQLExecDirect(stmt, reinterpret_cast(const_cast(query)), SQL_NTS); +} + +std::string SqlState(SQLHANDLE handle, SQLSMALLINT type = SQL_HANDLE_STMT) { + SQLCHAR state[6] = {}; + SQLGetDiagRec(type, handle, 1, state, nullptr, nullptr, 0, nullptr); + return reinterpret_cast(state); +} + +void CancelActiveExecution(SQLHSTMT stmt, std::future& execution) { + auto cancellation = std::async(std::launch::async, [&] { + auto owner = CheckedHandle(stmt); + EXPECT_TRUE(owner->IsExecuting()); + EXPECT_EQ(execution.wait_for(0s), std::future_status::timeout); + const auto result = SQLCancel(stmt); + return result; + }); + EXPECT_EQ(cancellation.wait_for(1s), std::future_status::ready); + EXPECT_EQ(cancellation.get(), SQL_SUCCESS); +} + +template +bool WaitUntil(Predicate predicate) { + const auto deadline = std::chrono::steady_clock::now() + 5s; + do { + if (predicate()) { + return true; + } + std::this_thread::yield(); + } while (std::chrono::steady_clock::now() < deadline); + return false; +} + +template +void CancelWhileWaitingForDescriptor(SQLHSTMT handle, SQLINTEGER attribute, Call call) { + SQLHDESC descriptor = SQL_NULL_HDESC; + ASSERT_EQ(SQLGetStmtAttr(handle, attribute, &descriptor, sizeof(descriptor), nullptr), SQL_SUCCESS); + auto* statement = CheckedHandle(handle); + // Destroy the descriptor lock before the futures on every exit path. + std::future execution, cancellation; + auto operation = CheckedHandle(descriptor)->LockOperation(); + execution = std::async(std::launch::async, call); + EXPECT_TRUE(WaitUntil([&] { return statement->IsExecuting(); })); + EXPECT_EQ(execution.wait_for(0s), std::future_status::timeout); + cancellation = std::async(std::launch::async, [&] { return SQLCancel(handle); }); + const auto ready = cancellation.wait_for(1s); + EXPECT_EQ(ready, std::future_status::ready); + if (ready == std::future_status::ready) { + EXPECT_TRUE(statement->IsCancelRequested()); + } + operation.unlock(); + EXPECT_EQ(cancellation.get(), SQL_SUCCESS); + const auto result = execution.get(); + if (result == SQL_ERROR) { + EXPECT_EQ(SqlState(handle), "HY008"); + } else { + EXPECT_EQ(result, SQL_SUCCESS) << SqlState(handle); + } + EXPECT_EQ(SQLFetch(handle), SQL_NO_DATA); +} + +class TPausedStatement : public TStatement { +public: + using TStatement::TStatement; + + void PauseNextExecution() { + State_ = EState::Armed; + } + + bool WaitUntilPaused() { + return WaitUntil([&] { return State_ == EState::Paused; }); + } + + void Release() { + State_ = EState::Idle; + } + +protected: + NYdb::NQuery::TExecuteQueryResult ExecuteQuery( + NYdb::NQuery::TSession& session, const NYdb::TParams& params, SQLULEN paramSet) override + { + auto result = TStatement::ExecuteQuery(session, params, paramSet); + auto expected = EState::Armed; + if (State_.compare_exchange_strong(expected, EState::Paused)) { + EXPECT_TRUE(result.IsSuccess()) << result.GetIssues().ToString(); + // Keep the ODBC call active before processing the real query result. + if (!WaitUntil([&] { return State_ == EState::Idle; })) { + throw TOdbcException("HY000", 0, "Timed out waiting to release the test query result"); + } + } + return result; + } + +private: + enum class EState { Idle, Armed, Paused }; + std::atomic State_ = EState::Idle; +}; + +void RunConcurrentQueries(SQLHDBC first, SQLHDBC second) { + TStatementHandle a(first), b(second); + std::barrier start(2); + const auto work = [&](SQLHSTMT stmt) { + start.arrive_and_wait(); + for (int i = 0; i < 30; ++i) { + EXPECT_EQ(Execute(stmt), SQL_SUCCESS) << SqlState(stmt); + EXPECT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER value = 0; + EXPECT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &value, sizeof(value), nullptr), SQL_SUCCESS); + EXPECT_EQ(value, 42); + } + }; + std::jthread worker(work, a.Handle); + work(b.Handle); +} + +TEST(Concurrency, IndependentConnections) { + TConnectionHandles a, b; + RunConcurrentQueries(a.Dbc, b.Dbc); +} + +TEST(Concurrency, AutocommitStatementsDoNotUseTransactionLock) { + TConnectionHandles connection; + auto owner = CheckedHandle(connection.Dbc); + auto transaction = owner->LockTransaction(); + auto queries = std::async(std::launch::async, [&] { + RunConcurrentQueries(connection.Dbc, connection.Dbc); + }); + EXPECT_EQ(queries.wait_for(2s), std::future_status::ready); + transaction.unlock(); + queries.get(); +} + +TEST(Concurrency, ParameterArraysReleaseCompletedSessions) { + TConnectionHandles connection; + auto owner = CheckedHandle(connection.Dbc); + const auto count = owner->GetClient()->GetActiveSessionsLimit(); + TStatementHandle setup(connection.Dbc); + ASSERT_EQ(Execute(setup.Handle, "DROP TABLE IF EXISTS odbc_concurrency_params"), SQL_SUCCESS); + ASSERT_EQ(Execute(setup.Handle, + "CREATE TABLE odbc_concurrency_params (id Int32, PRIMARY KEY(id))"), SQL_SUCCESS); + std::vector> statements; + std::vector> parameters(count, {1, 2}); + for (int i = 0; i < count; ++i) { + auto stmt = std::make_unique(connection.Dbc); + parameters[i] = {2 * i, 2 * i + 1}; + ASSERT_EQ(SQLPrepare(stmt->Handle, reinterpret_cast(const_cast( + "UPSERT INTO odbc_concurrency_params (id) VALUES (?)")), + SQL_NTS), SQL_SUCCESS); + ASSERT_EQ(SQLSetStmtAttr(stmt->Handle, SQL_ATTR_PARAMSET_SIZE, + reinterpret_cast(2), 0), SQL_SUCCESS); + ASSERT_EQ(SQLBindParameter(stmt->Handle, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, parameters[i].data(), sizeof(SQLINTEGER), nullptr), SQL_SUCCESS); + statements.push_back(std::move(stmt)); + } + std::barrier start(count); + { + std::vector workers; + for (const auto& stmt : statements) { + workers.emplace_back([&, handle = stmt->Handle] { + start.arrive_and_wait(); + EXPECT_EQ(SQLExecute(handle), SQL_SUCCESS) << SqlState(handle); + }); + } + } + EXPECT_TRUE(WaitUntil([&] { return owner->GetClient()->GetActiveSessionCount() == 0; })); + EXPECT_EQ(Execute(setup.Handle, "DROP TABLE odbc_concurrency_params"), SQL_SUCCESS); +} + +TEST(Concurrency, ExplicitTransactionStatements) { + TConnectionHandles connection; + TStatementHandle writer(connection.Dbc), reader(connection.Dbc); + ASSERT_EQ(Execute(writer.Handle, "DROP TABLE IF EXISTS odbc_concurrency_tx"), SQL_SUCCESS); + ASSERT_EQ(Execute(writer.Handle, + "CREATE TABLE odbc_concurrency_tx (id Int32, PRIMARY KEY(id))"), SQL_SUCCESS); + ASSERT_EQ(SQLSetConnectAttr(connection.Dbc, SQL_ATTR_AUTOCOMMIT, + reinterpret_cast(SQL_AUTOCOMMIT_OFF), 0), SQL_SUCCESS); + RunConcurrentQueries(connection.Dbc, connection.Dbc); + EXPECT_EQ(SQLEndTran(SQL_HANDLE_DBC, connection.Dbc, SQL_COMMIT), SQL_SUCCESS); + RunConcurrentQueries(connection.Dbc, connection.Dbc); + ASSERT_EQ(Execute(writer.Handle, "UPSERT INTO odbc_concurrency_tx (id) VALUES (42)"), SQL_SUCCESS); + auto read = std::async(std::launch::async, [&] { + return Execute(reader.Handle, "SELECT id FROM odbc_concurrency_tx WHERE id = 42"); + }); + ASSERT_EQ(read.get(), SQL_SUCCESS); + EXPECT_EQ(SQLFetch(reader.Handle), SQL_SUCCESS); + EXPECT_EQ(SQLEndTran(SQL_HANDLE_ENV, connection.Env, SQL_ROLLBACK), SQL_SUCCESS); + ASSERT_EQ(Execute(reader.Handle, "SELECT id FROM odbc_concurrency_tx WHERE id = 42"), SQL_SUCCESS); + EXPECT_EQ(SQLFetch(reader.Handle), SQL_NO_DATA); + EXPECT_EQ(SQLEndTran(SQL_HANDLE_DBC, connection.Dbc, SQL_COMMIT), SQL_SUCCESS); + ASSERT_EQ(SQLSetConnectAttr(connection.Dbc, SQL_ATTR_AUTOCOMMIT, + reinterpret_cast(SQL_AUTOCOMMIT_ON), 0), SQL_SUCCESS); + auto owner = CheckedHandle(connection.Dbc); + EXPECT_TRUE(WaitUntil([&] { return owner->GetClient()->GetActiveSessionCount() == 0; })); + EXPECT_EQ(Execute(writer.Handle, "DROP TABLE odbc_concurrency_tx"), SQL_SUCCESS); +} + +TEST(Concurrency, AutocommitProgressAndActiveCancel) { + TConnectionHandles connection; + auto owned = std::make_unique(CheckedHandle(connection.Dbc)); + auto* paused = owned.get(); + TStatementHandle slow(std::move(owned)), fast(connection.Dbc); + ASSERT_EQ(SQLPrepare(slow.Handle, + reinterpret_cast(const_cast("SELECT 42 AS value")), SQL_NTS), SQL_SUCCESS); + SQLSMALLINT count = 0; + ASSERT_EQ(SQLNumResultCols(slow.Handle, &count), SQL_SUCCESS); + ASSERT_EQ(count, 1); + SQLHDESC descriptor = SQL_NULL_HDESC; + ASSERT_EQ(SQLGetStmtAttr(slow.Handle, SQL_ATTR_IMP_ROW_DESC, + &descriptor, sizeof(descriptor), nullptr), SQL_SUCCESS); + paused->PauseNextExecution(); + auto execution = std::async(std::launch::async, [&] { return SQLExecute(slow.Handle); }); + Y_DEFER { paused->Release(); }; + ASSERT_TRUE(paused->WaitUntilPaused()); + EXPECT_EQ(SQLSetDescField(descriptor, 0, SQL_DESC_COUNT, nullptr, 0), SQL_SUCCESS); + EXPECT_EQ(Execute(fast.Handle), SQL_SUCCESS); + EXPECT_EQ(execution.wait_for(0s), std::future_status::timeout); + EXPECT_EQ(SQLEndTran(SQL_HANDLE_DBC, connection.Dbc, SQL_COMMIT), SQL_SUCCESS); + CancelActiveExecution(slow.Handle, execution); + paused->Release(); + EXPECT_EQ(execution.wait_for(5s), std::future_status::ready); + EXPECT_EQ(execution.get(), SQL_SUCCESS) << SqlState(slow.Handle); + EXPECT_EQ(SQLFetch(slow.Handle), SQL_NO_DATA); + EXPECT_EQ(SQLGetDescField(descriptor, 0, SQL_DESC_COUNT, &count, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(count, 1); + EXPECT_EQ(SQLFetch(fast.Handle), SQL_SUCCESS); + for (int i = 0; i < 20; ++i) { + EXPECT_EQ(SQLCancel(slow.Handle), SQL_SUCCESS); + EXPECT_EQ(Execute(fast.Handle), SQL_SUCCESS); + EXPECT_EQ(Execute(slow.Handle), SQL_SUCCESS); + } +} + +TEST(Concurrency, CancelWhileSnapshottingParameters) { + TConnectionHandles connection; + for (bool atExec : {false, true}) { + SCOPED_TRACE(atExec ? "data at execution" : "query execution"); + TStatementHandle statement(connection.Dbc); + ASSERT_EQ(SQLPrepare(statement.Handle, + reinterpret_cast(const_cast(atExec ? "SELECT ?" : "SELECT 42 AS value")), SQL_NTS), SQL_SUCCESS); + SQLINTEGER token = 0; + SQLLEN indicator = SQL_DATA_AT_EXEC; + if (atExec) { + ASSERT_EQ(SQLBindParameter(statement.Handle, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, &token, sizeof(token), &indicator), SQL_SUCCESS); + } + CancelWhileWaitingForDescriptor(statement.Handle, SQL_ATTR_APP_PARAM_DESC, [&] { + return SQLExecute(statement.Handle); + }); + EXPECT_FALSE(CheckedHandle(statement.Handle)->NeedsData()); + EXPECT_EQ(SQLExecute(statement.Handle), atExec ? SQL_NEED_DATA : SQL_SUCCESS); + EXPECT_EQ(SQLCancel(statement.Handle), SQL_SUCCESS); + } +} + +TEST(Concurrency, CancelWhileResettingMetadata) { + TConnectionHandles connection; + TStatementHandle setup(connection.Dbc), statement(connection.Dbc); + ASSERT_EQ(Execute(setup.Handle, "DROP TABLE IF EXISTS odbc_concurrency_cancel_metadata"), SQL_SUCCESS); + ASSERT_EQ(Execute(setup.Handle, + "CREATE TABLE odbc_concurrency_cancel_metadata (id Int32, PRIMARY KEY(id))"), SQL_SUCCESS); + for (auto metadata : {SQLTables, SQLColumns}) { + SCOPED_TRACE(metadata == SQLTables ? "SQLTables" : "SQLColumns"); + CancelWhileWaitingForDescriptor(statement.Handle, SQL_ATTR_IMP_ROW_DESC, [&] { + return metadata(statement.Handle, nullptr, 0, nullptr, 0, + reinterpret_cast(const_cast("odbc_concurrency_cancel_metadata")), + SQL_NTS, nullptr, 0); + }); + } + EXPECT_EQ(Execute(setup.Handle, "DROP TABLE odbc_concurrency_cancel_metadata"), SQL_SUCCESS); +} + +TEST(Concurrency, LocalCancelPreservesTransactionSession) { + TConnectionHandles connection; + TStatementHandle statement(connection.Dbc), other(connection.Dbc); + ASSERT_EQ(SQLSetConnectAttr(connection.Dbc, SQL_ATTR_AUTOCOMMIT, + reinterpret_cast(SQL_AUTOCOMMIT_OFF), 0), SQL_SUCCESS); + ASSERT_EQ(Execute(statement.Handle), SQL_SUCCESS); + auto owner = CheckedHandle(connection.Dbc); + const auto sessionId = owner->GetTx()->GetSession().GetId(); + const auto transactionId = owner->GetTx()->GetId(); + EXPECT_EQ(SQLCancel(statement.Handle), SQL_SUCCESS); + EXPECT_EQ(owner->GetTx()->GetSession().GetId(), sessionId); + ASSERT_TRUE(owner->GetTx().has_value()); + EXPECT_EQ(owner->GetTx()->GetId(), transactionId); + EXPECT_EQ(Execute(other.Handle), SQL_SUCCESS); + EXPECT_EQ(Execute(statement.Handle), SQL_SUCCESS); + EXPECT_EQ(SQLEndTran(SQL_HANDLE_DBC, connection.Dbc, SQL_COMMIT), SQL_SUCCESS); +} + +TEST(Concurrency, FailedTransactionCompletionReleasesSession) { + TConnectionHandles connection; + TStatementHandle statement(connection.Dbc); + auto* owner = CheckedHandle(connection.Dbc); + ASSERT_EQ(SQLSetConnectAttr(connection.Dbc, SQL_ATTR_AUTOCOMMIT, + reinterpret_cast(SQL_AUTOCOMMIT_OFF), 0), SQL_SUCCESS); + for (bool deleteSession : {false, true}) { + for (auto completion : {SQL_COMMIT, SQL_ROLLBACK}) { + SCOPED_TRACE(::testing::Message() << "deleteSession=" << deleteSession << " completion=" << completion); + ASSERT_EQ(Execute(statement.Handle), SQL_SUCCESS); + const auto sessionId = owner->GetTx()->GetSession().GetId(); + if (deleteSession) { + ASSERT_TRUE(owner->GetClient()->DeleteSession(sessionId).ExtractValueSync().IsSuccess()); + if (completion == SQL_COMMIT) { + ASSERT_EQ(Execute(statement.Handle), SQL_ERROR); + EXPECT_EQ(SqlState(statement.Handle), "08003"); + } + } else { + auto tx = *owner->GetTx(); + ASSERT_TRUE(tx.Rollback().ExtractValueSync().IsSuccess()); + } + EXPECT_EQ(SQLEndTran(SQL_HANDLE_DBC, connection.Dbc, completion), + completion == SQL_COMMIT ? SQL_ERROR : SQL_SUCCESS); + if (completion == SQL_COMMIT) { + EXPECT_EQ(SqlState(connection.Dbc, SQL_HANDLE_DBC), "25S01"); + } + ASSERT_FALSE(owner->GetTx()); + EXPECT_TRUE(WaitUntil([&] { return owner->GetClient()->GetActiveSessionCount() == 0; })); + EXPECT_EQ(SQLFetch(statement.Handle), SQL_NO_DATA); + ASSERT_EQ(Execute(statement.Handle), SQL_SUCCESS) << SqlState(statement.Handle); + EXPECT_EQ(SQLEndTran(SQL_HANDLE_DBC, connection.Dbc, SQL_ROLLBACK), SQL_SUCCESS); + } + } + for (auto status : {NYdb::EStatus::OVERLOADED, NYdb::EStatus::UNDETERMINED}) { + ASSERT_EQ(Execute(statement.Handle), SQL_SUCCESS); + auto tx = *owner->GetTx(); + tx.AddPrecommitCallback([status] { + return NThreading::MakeFuture(NYdb::TStatus(status, NYdb::NIssue::TIssues())); + }); + EXPECT_EQ(SQLEndTran(SQL_HANDLE_DBC, connection.Dbc, SQL_COMMIT), SQL_ERROR); + EXPECT_EQ(SqlState(connection.Dbc, SQL_HANDLE_DBC), + status == NYdb::EStatus::UNDETERMINED ? "40003" : "HY000"); + ASSERT_TRUE(owner->GetTx()); + EXPECT_EQ(owner->GetTx()->GetId(), tx.GetId()); + EXPECT_EQ(SQLFetch(statement.Handle), SQL_SUCCESS); + EXPECT_EQ(SQLEndTran(SQL_HANDLE_DBC, connection.Dbc, SQL_ROLLBACK), SQL_SUCCESS); + } +} + +TEST(Concurrency, ActiveLocalCancelPreservesTransactionSession) { + TConnectionHandles connection; + auto owner = CheckedHandle(connection.Dbc); + auto owned = std::make_unique(owner); + auto* paused = owned.get(); + TStatementHandle statement(std::move(owned)); + ASSERT_EQ(SQLSetConnectAttr(connection.Dbc, SQL_ATTR_AUTOCOMMIT, + reinterpret_cast(SQL_AUTOCOMMIT_OFF), 0), SQL_SUCCESS); + ASSERT_EQ(Execute(statement.Handle), SQL_SUCCESS); + const auto sessionId = owner->GetTx()->GetSession().GetId(); + const auto transactionId = owner->GetTx()->GetId(); + paused->PauseNextExecution(); + auto execution = std::async(std::launch::async, [&] { + return Execute(statement.Handle); + }); + Y_DEFER { paused->Release(); }; + ASSERT_TRUE(paused->WaitUntilPaused()); + CancelActiveExecution(statement.Handle, execution); + paused->Release(); + EXPECT_EQ(execution.wait_for(5s), std::future_status::ready); + EXPECT_EQ(execution.get(), SQL_SUCCESS) << SqlState(statement.Handle); + EXPECT_EQ(SQLFetch(statement.Handle), SQL_NO_DATA); + EXPECT_EQ(owner->GetTx()->GetSession().GetId(), sessionId); + ASSERT_TRUE(owner->GetTx().has_value()); + EXPECT_EQ(owner->GetTx()->GetId(), transactionId); + EXPECT_EQ(Execute(statement.Handle), SQL_SUCCESS); + EXPECT_EQ(SQLEndTran(SQL_HANDLE_DBC, connection.Dbc, SQL_ROLLBACK), SQL_SUCCESS); +} + +TEST(Concurrency, SameHandleAndCrossThreadHandoff) { + TConnectionHandles connection; + TStatementHandle statement(connection.Dbc); + std::barrier start(2); + const auto work = [&] { + start.arrive_and_wait(); + for (int i = 0; i < 30; ++i) { + EXPECT_EQ(Execute(statement.Handle), SQL_SUCCESS); + SQLULEN value = 0; + EXPECT_EQ(SQLGetStmtAttr(statement.Handle, SQL_ATTR_CURSOR_TYPE, + &value, sizeof(value), nullptr), SQL_SUCCESS); + } + }; + { + std::jthread worker(work); + work(); + } + EXPECT_EQ(SQLFetch(statement.Handle), SQL_SUCCESS); + { + std::jthread nextOwner([&] { + SQLINTEGER value = 0; + EXPECT_EQ(SQLGetData(statement.Handle, 1, SQL_C_LONG, + &value, sizeof(value), nullptr), SQL_SUCCESS); + EXPECT_EQ(value, 42); + }); + } + auto owner = CheckedHandle(statement.Handle); + auto operation = owner->LockOperation(); + owner->AddError("HYT00", 0, "Execution timed out"); + auto cancel = std::async(std::launch::async, [&] { return SQLCancel(statement.Handle); }); + const auto ready = cancel.wait_for(1s); + operation.unlock(); + EXPECT_EQ(ready, std::future_status::ready); + EXPECT_EQ(cancel.get(), SQL_ERROR); + EXPECT_EQ(SqlState(statement.Handle), "HYT00"); +} + +TEST(Concurrency, LocalCancelDoesNotRetainAutocommitSessions) { + TConnectionHandles connection; + TStatementHandle statement(connection.Dbc); + auto owner = CheckedHandle(connection.Dbc); + for (int i = 0; i < 60; ++i) { + ASSERT_EQ(Execute(statement.Handle), SQL_SUCCESS); + EXPECT_EQ(SQLCancel(statement.Handle), SQL_SUCCESS); + EXPECT_TRUE(WaitUntil([&] { return owner->GetClient()->GetActiveSessionCount() == 0; })); + } +} + +TEST(Concurrency, ParentFreeWaitsForChildPublication) { + SQLHENV env = SQL_NULL_HENV; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + auto* parent = CheckedHandle(env); + auto connection = std::make_unique(parent); + auto* child = connection.get(); + auto publication = parent->LockOperation(); + EXPECT_TRUE(parent->GetChildren().empty()); + auto freeing = std::async(std::launch::async, [&] { return SQLFreeHandle(SQL_HANDLE_ENV, env); }); + const auto ready = freeing.wait_for(50ms); + parent->AddChild(child); + SQLHDBC dbc = static_cast(connection.release()); + publication.unlock(); + EXPECT_EQ(ready, std::future_status::timeout); + EXPECT_EQ(freeing.get(), SQL_ERROR); + EXPECT_EQ(SqlState(env, SQL_HANDLE_ENV), "HY010"); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_DBC, dbc), SQL_SUCCESS); + { + auto operation = parent->LockOperation(); + EXPECT_TRUE(parent->GetChildren().empty()); + } + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_ENV, env), SQL_SUCCESS); +} + +TEST(Concurrency, CancelQueuedTransactionDoesNotWaitOrAbortOtherStatements) { + TConnectionHandles connection; + TStatementHandle statement(connection.Dbc); + ASSERT_EQ(SQLSetConnectAttr(connection.Dbc, SQL_ATTR_AUTOCOMMIT, + reinterpret_cast(SQL_AUTOCOMMIT_OFF), 0), SQL_SUCCESS); + auto owner = CheckedHandle(connection.Dbc); + ASSERT_EQ(Execute(statement.Handle), SQL_SUCCESS); + const auto sessionId = owner->GetTx()->GetSession().GetId(); + const auto transactionId = owner->GetTx()->GetId(); + auto stmt = CheckedHandle(statement.Handle); + auto transaction = owner->LockTransaction(); + auto execution = std::async(std::launch::async, [&] { return Execute(statement.Handle); }); + const bool started = WaitUntil([&] { return stmt->IsExecuting(); }); + EXPECT_TRUE(started); + auto cancel = std::async(std::launch::async, [&] { return SQLCancel(statement.Handle); }); + const auto ready = cancel.wait_for(1s); + EXPECT_EQ(ready, std::future_status::ready); + if (ready == std::future_status::ready) { + EXPECT_TRUE(stmt->IsExecuting()); + EXPECT_TRUE(stmt->IsCancelRequested()); + EXPECT_EQ(SQLCancel(statement.Handle), SQL_SUCCESS); + } + transaction.unlock(); + EXPECT_EQ(cancel.get(), SQL_SUCCESS); + EXPECT_EQ(execution.get(), SQL_ERROR); + EXPECT_EQ(SqlState(statement.Handle), "HY008"); + EXPECT_EQ(owner->GetTx()->GetSession().GetId(), sessionId); + ASSERT_TRUE(owner->GetTx().has_value()); + EXPECT_EQ(owner->GetTx()->GetId(), transactionId); + TStatementHandle other(connection.Dbc); + EXPECT_EQ(Execute(other.Handle), SQL_SUCCESS); + EXPECT_EQ(Execute(statement.Handle), SQL_SUCCESS); + EXPECT_EQ(SQLEndTran(SQL_HANDLE_DBC, connection.Dbc, SQL_ROLLBACK), SQL_SUCCESS); +} + +TEST(Concurrency, DescriptorCopyMutationAndFree) { + TConnectionHandles connection, otherConnection; + TStatementHandle a(connection.Dbc), b(connection.Dbc); + SQLHDESC first = SQL_NULL_HDESC, second = SQL_NULL_HDESC; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DESC, connection.Dbc, &first), SQL_SUCCESS); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DESC, otherConnection.Dbc, &second), SQL_SUCCESS); + ASSERT_EQ(SQLSetStmtAttr(a.Handle, SQL_ATTR_APP_ROW_DESC, first, 0), SQL_SUCCESS); + ASSERT_EQ(SQLSetStmtAttr(b.Handle, SQL_ATTR_APP_ROW_DESC, first, 0), SQL_SUCCESS); + SQLINTEGER firstValue = 0, secondValue = 0; + ASSERT_EQ(SQLBindCol(a.Handle, 1, SQL_C_LONG, &firstValue, sizeof(firstValue), nullptr), SQL_SUCCESS); + ASSERT_EQ(SQLCopyDesc(first, first), SQL_SUCCESS); + SQLSMALLINT count = 0; + ASSERT_EQ(SQLGetDescField(first, 0, SQL_DESC_COUNT, &count, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(count, 1); + SQLPOINTER data = nullptr; + ASSERT_EQ(SQLGetDescField(first, 1, SQL_DESC_DATA_PTR, &data, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(data, &firstValue); + ASSERT_EQ(SQLCopyDesc(first, second), SQL_SUCCESS); + ASSERT_EQ(SQLSetDescField(second, 1, SQL_DESC_DATA_PTR, &secondValue, 0), SQL_SUCCESS); + ASSERT_EQ(Execute(a.Handle), SQL_SUCCESS); + ASSERT_EQ(Execute(b.Handle), SQL_SUCCESS); + std::barrier start(5); + { + auto attributes = [&](SQLHDBC dbc) { + start.arrive_and_wait(); + for (int i = 0; i < 100; ++i) { + EXPECT_EQ(SQLSetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, + reinterpret_cast(SQL_AUTOCOMMIT_ON), 0), SQL_SUCCESS); + } + }; + std::jthread firstAttributes(attributes, connection.Dbc); + std::jthread secondAttributes(attributes, otherConnection.Dbc); + const auto copy = [&](SQLHDESC source, SQLHDESC target) { + start.arrive_and_wait(); + for (int i = 0; i < 100; ++i) { + EXPECT_EQ(SQLCopyDesc(source, target), SQL_SUCCESS); + } + }; + std::jthread forward(copy, first, second); + std::jthread reverse(copy, second, first); + start.arrive_and_wait(); + EXPECT_EQ(SQLFetch(a.Handle), SQL_SUCCESS); + } + EXPECT_TRUE(firstValue == 42 || secondValue == 42); + firstValue = secondValue = 0; + EXPECT_EQ(SQLFetch(b.Handle), SQL_SUCCESS); + EXPECT_TRUE(firstValue == 42 || secondValue == 42); + ASSERT_EQ(Execute(a.Handle), SQL_SUCCESS); + std::barrier freeing(2); + auto fetch = std::async(std::launch::async, [&] { + freeing.arrive_and_wait(); + return SQLFetch(a.Handle); + }); + freeing.arrive_and_wait(); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_DESC, first), SQL_SUCCESS); + EXPECT_EQ(fetch.get(), SQL_SUCCESS); + SQLHDESC restored = SQL_NULL_HDESC; + EXPECT_EQ(SQLGetStmtAttr(a.Handle, SQL_ATTR_APP_ROW_DESC, + &restored, sizeof(restored), nullptr), SQL_SUCCESS); + EXPECT_NE(restored, first); + EXPECT_EQ(SQLGetStmtAttr(b.Handle, SQL_ATTR_APP_ROW_DESC, + &restored, sizeof(restored), nullptr), SQL_SUCCESS); + EXPECT_NE(restored, first); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_DESC, second), SQL_SUCCESS); +} + +} // namespace diff --git a/odbc/tests/integration/connection_api_it.cpp b/odbc/tests/integration/connection_api_it.cpp new file mode 100644 index 00000000000..843f8637ce2 --- /dev/null +++ b/odbc/tests/integration/connection_api_it.cpp @@ -0,0 +1,370 @@ +#include "test_utils.h" + +TEST(ConnectionApi, AllocFreeEnvHandle) { + SQLHENV env; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + ASSERT_EQ(SQLFreeHandle(SQL_HANDLE_ENV, env), SQL_SUCCESS); +} + +TEST(ConnectionApi, AllocFreeDbcHandle) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + ASSERT_EQ(SQLFreeHandle(SQL_HANDLE_DBC, dbc), SQL_SUCCESS); + + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, AllocFreeHandleInvalid) { + SQLHENV env; + SQLRETURN rc = SQLAllocHandle(999, SQL_NULL_HANDLE, &env); + ASSERT_TRUE(rc == SQL_ERROR || rc == SQL_INVALID_HANDLE); +} + +TEST(ConnectionApi, SQLConnectWithDSN) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLConnect(dbc, (SQLCHAR*)"YDB", SQL_NTS, (SQLCHAR*)"", SQL_NTS, (SQLCHAR*)"", SQL_NTS), + dbc, SQL_HANDLE_DBC); + + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, SQLDriverConnectComplete) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + SQLCHAR outStr[1024] = {}; + SQLSMALLINT outLen = -1; + SQLRETURN rc = SQLDriverConnect(dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, + outStr, sizeof(outStr), &outLen, SQL_DRIVER_COMPLETE); + ASSERT_EQ(rc, SQL_SUCCESS) << GetOdbcError(dbc, SQL_HANDLE_DBC); + EXPECT_STREQ(reinterpret_cast(outStr), kConnStr); + EXPECT_EQ(outLen, static_cast(std::strlen(kConnStr))); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, SQLDriverConnectReportsOutputLengthWithoutBuffer) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + SQLSMALLINT outLen = -1; + const SQLRETURN rc = SQLDriverConnect( + dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, + nullptr, 0, &outLen, SQL_DRIVER_NOPROMPT); + ASSERT_EQ(rc, SQL_SUCCESS) << GetOdbcError(dbc, SQL_HANDLE_DBC); + EXPECT_EQ(outLen, static_cast(std::strlen(kConnStr))); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, SQLDriverConnectNoPrompt) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + + SQLRETURN rc = SQLDriverConnect(dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, + nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT); + CHECK_ODBC_OK(rc, dbc, SQL_HANDLE_DBC); + + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, SQLDriverConnectInvalidConnString) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + + SQLRETURN rc = SQLDriverConnect(dbc, nullptr, (SQLCHAR*)"InvalidParam=test", SQL_NTS, + nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT); + ASSERT_EQ(rc, SQL_ERROR); + + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, SQLDriverConnectIgnoresUnrecognizedAttributes) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + + SQLCHAR connectionString[] = + "Driver=" ODBC_DRIVER_PATH + ";Endpoint=localhost:2136;Database=/local;APP=PowerBI;WSID=desktop;Timeout=30;"; + const SQLRETURN rc = SQLDriverConnect( + dbc, nullptr, connectionString, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT); + ASSERT_EQ(rc, SQL_SUCCESS_WITH_INFO) << GetOdbcError(dbc, SQL_HANDLE_DBC); + SQLCHAR sqlState[6] = {}; + SQLCHAR message[256] = {}; + SQLINTEGER nativeError = 0; + SQLSMALLINT textLength = 0; + const SQLRETURN diagRc = SQLGetDiagRec( + SQL_HANDLE_DBC, dbc, 1, sqlState, &nativeError, + message, sizeof(message), &textLength); + if (diagRc == SQL_SUCCESS || diagRc == SQL_SUCCESS_WITH_INFO) { + EXPECT_STREQ(reinterpret_cast(sqlState), "01S00"); + } else { +#ifdef ODBC_TEST_IODBC + // iODBC preserves SQL_SUCCESS_WITH_INFO but drops the driver's diagnostic record. + EXPECT_EQ(diagRc, SQL_NO_DATA); +#else + FAIL() << "SQLGetDiagRec failed with return code " << diagRc; +#endif + } + + SQLHSTMT stmt; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, reinterpret_cast(const_cast("SELECT 1")), SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, SQLDriverConnectValidatesAuthenticationSettings) { + SQLHENV env; + AllocEnv(&env); + + const struct { + const char* ConnectionString; + const char* SqlState; + } cases[] = { + {"Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;AuthMode=None;", "28000"}, + {"Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;Token=;", "28000"}, + {"Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;Token=a;UID=b;PWD=c;", "28000"}, + {"Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;AuthMode=Static;UID=;PWD=;", "28000"}, + {"Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;AuthMode=Static;UID=b;", "28000"}, + {"Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;AuthMode=Metadata;MetadataPort=70000;", "HY024"}, + {"Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;AuthMode=ServiceAccount;SaFile=/missing/sa.json;", "08001"}, + {"Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;AuthMode=OAuth2;OAuth2KeyFile=/missing/oauth2.json;", "08001"}, + {"Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;ClientCertificate=client.pem;", "08001"}, + {"Driver=" ODBC_DRIVER_PATH ";Endpoint=grpc://localhost:2136;Database=/local;CaFile=ca.pem;", "HY024"}, + {"Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;RootCertificate=/missing/ca.pem;", "08001"}, + }; + + for (const auto& testCase : cases) { + SQLHDBC dbc; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + const SQLRETURN rc = SQLDriverConnect( + dbc, nullptr, reinterpret_cast(const_cast(testCase.ConnectionString)), SQL_NTS, + nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT); + ASSERT_EQ(rc, SQL_ERROR) << testCase.ConnectionString; + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(dbc, SQL_HANDLE_DBC), testCase.SqlState)) + << testCase.ConnectionString << ": " << GetOdbcError(dbc, SQL_HANDLE_DBC); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + } + + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, SQLDriverConnectSupportsAliasesAndDsnOverlay) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + + SQLCHAR connectionString[] = + "DSN=YDB;Endpoint=grpc://127.0.0.1:2136;AuthMode=Token;AccessToken=ignored-by-anonymous-server;"; + CHECK_ODBC_OK(SQLDriverConnect( + dbc, nullptr, connectionString, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT), + dbc, SQL_HANDLE_DBC); + + SQLHSTMT stmt; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1", SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, SQLDriverConnectKeepsAnonymousDsnWithBlankCredentials) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + + SQLCHAR connectionString[] = "DSN=YDB;UID=;PWD=;"; + CHECK_ODBC_OK(SQLDriverConnect( + dbc, nullptr, connectionString, SQL_NTS, + nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT), + dbc, SQL_HANDLE_DBC); + + SQLHSTMT stmt; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1", SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, SQLConnectMissingDSN) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + + SQLRETURN rc = SQLConnect(dbc, (SQLCHAR*)"NONEXISTENT_DSN", SQL_NTS, (SQLCHAR*)"", SQL_NTS, (SQLCHAR*)"", SQL_NTS); + ASSERT_EQ(rc, SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(dbc, SQL_HANDLE_DBC), "IM002")); + + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, EnvAttrOdbcVersion) { + SQLHENV env; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), SQL_SUCCESS); + ASSERT_NE(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, nullptr, 0), SQL_SUCCESS); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, EnvAttrOutputNts) { + SQLHENV env; + AllocEnv(&env); + ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_OUTPUT_NTS, (void*)SQL_TRUE, 0), SQL_SUCCESS); + ASSERT_NE(SQLSetEnvAttr(env, SQL_ATTR_OUTPUT_NTS, (void*)SQL_FALSE, 0), SQL_SUCCESS); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, ConnAttrAccessMode) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + SQLUINTEGER mode; + ASSERT_EQ(SQLGetConnectAttr(dbc, SQL_ATTR_ACCESS_MODE, &mode, sizeof(mode), nullptr), SQL_SUCCESS); + ASSERT_EQ(mode, SQL_MODE_READ_WRITE); + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_ACCESS_MODE, (SQLPOINTER)SQL_MODE_READ_ONLY, 0), + dbc, SQL_HANDLE_DBC); + ASSERT_EQ(SQLGetConnectAttr(dbc, SQL_ATTR_ACCESS_MODE, &mode, sizeof(mode), nullptr), SQL_SUCCESS); + ASSERT_EQ(mode, SQL_MODE_READ_ONLY); + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_ACCESS_MODE, (SQLPOINTER)SQL_MODE_READ_WRITE, 0), + dbc, SQL_HANDLE_DBC); + ASSERT_EQ(SQLSetConnectAttr(dbc, SQL_ATTR_ACCESS_MODE, (SQLPOINTER)9999, 0), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(dbc, SQL_HANDLE_DBC), "HY024")); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, ConnAttrCurrentCatalog) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + char catalog[256]; + SQLINTEGER len; + ASSERT_EQ(SQLGetConnectAttr(dbc, SQL_ATTR_CURRENT_CATALOG, catalog, sizeof(catalog), &len), SQL_SUCCESS); + ASSERT_STREQ(catalog, "/local"); + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER)"/local/test", SQL_NTS), + dbc, SQL_HANDLE_DBC); + ASSERT_EQ(SQLGetConnectAttr(dbc, SQL_ATTR_CURRENT_CATALOG, catalog, sizeof(catalog), &len), SQL_SUCCESS); + ASSERT_STREQ(catalog, "/local/test"); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, LegacyLoginTimeoutBeforeConnect) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + + constexpr SQLULEN timeout = 15; + ASSERT_EQ(SQLSetConnectOption(dbc, SQL_LOGIN_TIMEOUT, timeout), SQL_SUCCESS); + + SQLCHAR outStr[1024] = {}; + SQLSMALLINT outLen = 0; + const SQLRETURN connectRc = SQLDriverConnect( + dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, + outStr, sizeof(outStr), &outLen, SQL_DRIVER_NOPROMPT); + ASSERT_EQ(connectRc, SQL_SUCCESS) << GetOdbcError(dbc, SQL_HANDLE_DBC); + + SQLUINTEGER actualTimeout = 0; + ASSERT_EQ(SQLGetConnectOption(dbc, SQL_LOGIN_TIMEOUT, &actualTimeout), SQL_SUCCESS) + << GetOdbcError(dbc, SQL_HANDLE_DBC); + EXPECT_EQ(actualTimeout, timeout); + + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ConnectionApi, ConnAttrCurrentCatalogAffectsQueries) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS `/local/cat_a/probe`", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"CREATE TABLE `/local/cat_a/probe` (id Int32, value Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"UPSERT INTO `/local/cat_a/probe` (id, value) VALUES (1, 100)", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS `/local/cat_b/probe`", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"CREATE TABLE `/local/cat_b/probe` (id Int32, value Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"UPSERT INTO `/local/cat_b/probe` (id, value) VALUES (1, 200)", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*) + "--!ansi_lexer\nSELECT a.\"value\" FROM `/local/cat_a/probe` a,`/local/cat_a/probe` b WHERE a.id = b.id", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER value; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &value, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(value, 100); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER)"/local/cat_a", SQL_NTS), + dbc, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"--!ansi_lexer\nSELECT a.\"value\" FROM probe a, probe b WHERE a.id = b.id AND a.id = 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &value, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(value, 100); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER)"/local/cat_b", SQL_NTS), + dbc, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, (SQLPOINTER)SQL_NOSCAN_ON, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"--!ansi_lexer\nSELECT a.\"value\" FROM probe a, probe b WHERE a.id = b.id AND a.id = 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &value, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(value, 200); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} diff --git a/odbc/tests/integration/core_api_it.cpp b/odbc/tests/integration/core_api_it.cpp new file mode 100644 index 00000000000..b4613fd79b3 --- /dev/null +++ b/odbc/tests/integration/core_api_it.cpp @@ -0,0 +1,939 @@ +#include "test_utils.h" + +#include +#include + +#ifndef SQL_ODBC_INTERFACE_CONFORMANCE +#define SQL_ODBC_INTERFACE_CONFORMANCE 169 +#endif + +#ifndef ODBC_TEST_IODBC +// unixODBC's cursor library allocates its SQLGetData requery through SQLAllocStmt. +TEST(CoreApi, CursorLibraryFetchesUnboundColumn) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + ASSERT_EQ(SQLSetConnectAttr(dbc, SQL_ATTR_ODBC_CURSORS, + (SQLPOINTER)SQL_CUR_USE_ODBC, 0), SQL_SUCCESS); + CHECK_ODBC_OK(SQLDriverConnect(dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, + nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT), dbc, SQL_HANDLE_DBC); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + ASSERT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, + (SQLPOINTER)SQL_CURSOR_STATIC, 0), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS odbc_cursor_library", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"CREATE TABLE odbc_cursor_library " + "(id Int32, payload Utf8, PRIMARY KEY (id))", SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"INSERT INTO odbc_cursor_library " + "(id, payload) VALUES (1, 'unbound value')", SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT id, payload FROM odbc_cursor_library", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLINTEGER id = 0; + SQLLEN length = 0; + SQLULEN rows = 0; + SQLUSMALLINT status = SQL_ROW_NOROW; + ASSERT_EQ(SQLBindCol(stmt, 1, SQL_C_LONG, &id, sizeof(id), &length), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExtendedFetch(stmt, SQL_FETCH_NEXT, 0, &rows, &status), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rows, 1u); + EXPECT_EQ(id, 1); + char payload[32] = {}; + CHECK_ODBC_OK(SQLGetData(stmt, 2, SQL_C_CHAR, payload, sizeof(payload), &length), stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(payload, "unbound value"); + SQLFreeStmt(stmt, SQL_CLOSE); + SQLFreeStmt(stmt, SQL_UNBIND); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE odbc_cursor_library", SQL_NTS), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_STMT, stmt), SQL_SUCCESS); + EXPECT_EQ(SQLDisconnect(dbc), SQL_SUCCESS); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_DBC, dbc), SQL_SUCCESS); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_ENV, env), SQL_SUCCESS); +} +#endif + +TEST(CoreApi, SQLGetTypeInfoAll) { + struct TExpectedType { + SQLSMALLINT DataType; + const char* TypeName; + }; + constexpr std::array expected{{ + {SQL_BIT, "Bool"}, + {SQL_TINYINT, "Int8"}, + {SQL_BIGINT, "Int64"}, + {SQL_VARBINARY, "String"}, + {SQL_CHAR, "Utf8"}, + {SQL_DECIMAL, "Decimal"}, + {SQL_INTEGER, "Int32"}, + {SQL_SMALLINT, "Int16"}, + {SQL_REAL, "Float"}, + {SQL_DOUBLE, "Double"}, + {SQL_VARCHAR, "Utf8"}, + {SQL_TYPE_DATE, "Date"}, + {SQL_TYPE_TIME, "Datetime"}, + {SQL_TYPE_TIMESTAMP, "Timestamp"}, + }}; + + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLGetTypeInfo(stmt, SQL_ALL_TYPES), stmt, SQL_HANDLE_STMT); + + char typeName[64] = {}; + SQLSMALLINT dataType = 0; + SQLLEN typeNameIndicator = 0; + SQLLEN dataTypeIndicator = 0; + CHECK_ODBC_OK(SQLBindCol(stmt, 1, SQL_C_CHAR, typeName, sizeof(typeName), + &typeNameIndicator), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindCol(stmt, 2, SQL_C_SSHORT, &dataType, 0, &dataTypeIndicator), + stmt, SQL_HANDLE_STMT); + + std::array seen{}; + size_t rowCount = 0; + SQLSMALLINT previousDataType = expected.front().DataType; + SQLRETURN fetchResult; + while ((fetchResult = SQLFetch(stmt)) == SQL_SUCCESS) { + ++rowCount; + EXPECT_GE(dataType, previousDataType); + previousDataType = dataType; + bool matched = false; + for (size_t index = 0; index < expected.size(); ++index) { + if (dataType == expected[index].DataType + && std::strcmp(typeName, expected[index].TypeName) == 0) { + EXPECT_FALSE(seen[index]) << "duplicate type row " << typeName; + seen[index] = true; + matched = true; + break; + } + } + EXPECT_TRUE(matched) << "unexpected advertised type " << typeName + << " (" << dataType << ")"; + } + EXPECT_EQ(fetchResult, SQL_NO_DATA); + EXPECT_EQ(rowCount, expected.size()); + for (size_t index = 0; index < expected.size(); ++index) { + EXPECT_TRUE(seen[index]) << "missing " << expected[index].TypeName + << " for SQL type " << expected[index].DataType; + } + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLGetTypeInfoSchema) { + struct TExpectedColumn { + const char* Name; + SQLSMALLINT Type; + SQLSMALLINT Nullable; + }; + constexpr std::array expected{{ + {"TYPE_NAME", SQL_VARCHAR, SQL_NO_NULLS}, + {"DATA_TYPE", SQL_SMALLINT, SQL_NO_NULLS}, + {"COLUMN_SIZE", SQL_INTEGER, SQL_NULLABLE}, + {"LITERAL_PREFIX", SQL_VARCHAR, SQL_NULLABLE}, + {"LITERAL_SUFFIX", SQL_VARCHAR, SQL_NULLABLE}, + {"CREATE_PARAMS", SQL_VARCHAR, SQL_NULLABLE}, + {"NULLABLE", SQL_SMALLINT, SQL_NO_NULLS}, + {"CASE_SENSITIVE", SQL_SMALLINT, SQL_NO_NULLS}, + {"SEARCHABLE", SQL_SMALLINT, SQL_NO_NULLS}, + {"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, SQL_NULLABLE}, + {"FIXED_PREC_SCALE", SQL_SMALLINT, SQL_NO_NULLS}, + {"AUTO_UNIQUE_VALUE", SQL_SMALLINT, SQL_NULLABLE}, + {"LOCAL_TYPE_NAME", SQL_VARCHAR, SQL_NULLABLE}, + {"MINIMUM_SCALE", SQL_SMALLINT, SQL_NULLABLE}, + {"MAXIMUM_SCALE", SQL_SMALLINT, SQL_NULLABLE}, + {"SQL_DATA_TYPE", SQL_SMALLINT, SQL_NO_NULLS}, + {"SQL_DATETIME_SUB", SQL_SMALLINT, SQL_NULLABLE}, + {"NUM_PREC_RADIX", SQL_INTEGER, SQL_NULLABLE}, + {"INTERVAL_PRECISION", SQL_SMALLINT, SQL_NULLABLE}, + }}; + + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLGetTypeInfo(stmt, SQL_ALL_TYPES), stmt, SQL_HANDLE_STMT); + + SQLSMALLINT columnCount = 0; + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(columnCount, static_cast(expected.size())); + for (size_t index = 0; index < expected.size(); ++index) { + const SQLUSMALLINT column = static_cast(index + 1); + SCOPED_TRACE(column); + char name[64] = {}; + SQLSMALLINT nameLength = 0; + SQLSMALLINT type = 0; + SQLULEN size = 0; + SQLSMALLINT scale = 0; + SQLSMALLINT nullable = 0; + CHECK_ODBC_OK(SQLDescribeCol( + stmt, column, reinterpret_cast(name), sizeof(name), + &nameLength, &type, &size, &scale, &nullable), + stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(name, expected[index].Name); + EXPECT_EQ(nameLength, static_cast(std::strlen(expected[index].Name))); + EXPECT_EQ(type, expected[index].Type); + EXPECT_EQ(nullable, expected[index].Nullable); + if (type == SQL_SMALLINT || type == SQL_INTEGER) { + EXPECT_EQ(size, type == SQL_SMALLINT ? 5 : 10); + } + } + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLGetTypeInfoFilter) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLGetTypeInfo(stmt, SQL_INTEGER), stmt, SQL_HANDLE_STMT); + std::array values; + std::array indicators{}; + for (SQLUSMALLINT index = 0; index < values.size(); ++index) { + SQLLEN displaySize = 0; + CHECK_ODBC_OK(SQLColAttribute(stmt, index + 2, SQL_DESC_DISPLAY_SIZE, + nullptr, 0, nullptr, &displaySize), stmt, SQL_HANDLE_STMT); + values[index].resize(displaySize + 1); + CHECK_ODBC_OK(SQLBindCol(stmt, index + 2, SQL_C_CHAR, values[index].data(), + values[index].size(), &indicators[index]), stmt, SQL_HANDLE_STMT); + } + int rowCount = 0; + while (SQLFetch(stmt) == SQL_SUCCESS) { + EXPECT_STREQ(values[0].c_str(), "4"); + EXPECT_STREQ(values[1].c_str(), "10"); + EXPECT_EQ(indicators[0], 1); + EXPECT_EQ(indicators[1], 2); + ++rowCount; + } + ASSERT_GT(rowCount, 0); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLGetTypeInfoTimestampAlias) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLGetTypeInfo(stmt, SQL_TIMESTAMP), stmt, SQL_HANDLE_STMT); + SQLINTEGER columnSize = 0; + SQLLEN indicator = 0; + SQLBindCol(stmt, 3, SQL_C_LONG, &columnSize, 0, &indicator); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + EXPECT_EQ(columnSize, 26); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLNumParamsQuestionMarks) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT ? + ?", SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLSMALLINT paramCount = 0; + CHECK_ODBC_OK(SQLNumParams(stmt, ¶mCount), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(paramCount, 2); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLNumParamsDollarParams) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT $p1", SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLSMALLINT paramCount = 0; + CHECK_ODBC_OK(SQLNumParams(stmt, ¶mCount), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(paramCount, 1); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLColAttributeName) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1 AS col", SQL_NTS), stmt, SQL_HANDLE_STMT); + char name[64] = {}; + SQLSMALLINT nameLen = 0; + CHECK_ODBC_OK(SQLColAttribute(stmt, 1, SQL_DESC_NAME, name, sizeof(name), &nameLen, nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(name, "col"); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLColAttributeType) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1 AS col", SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLLEN dataType = 0; + CHECK_ODBC_OK(SQLColAttribute(stmt, 1, SQL_DESC_TYPE, nullptr, 0, nullptr, &dataType), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(dataType, SQL_INTEGER); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLNativeSqlPassthrough) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + char out[64] = {}; + SQLINTEGER outLen = 0; + CHECK_ODBC_OK(SQLNativeSql(dbc, (SQLCHAR*)"SELECT 1", SQL_NTS, (SQLCHAR*)out, sizeof(out), &outLen), + dbc, SQL_HANDLE_DBC); + EXPECT_STREQ(out, "SELECT 1"); + EXPECT_EQ(outLen, 8); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLNativeSqlTranslatesOdbcSyntax) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + std::string input = + "SELECT {fn CONVERT(?, SQL_SMALLINT)} AS \"value{fn ABS(1)}\", " + "'{fn ABS(2)}' /* {fn ABS(3)} */, {d '2024-01-02'}, {t '10:11:12'}, " + "{ts '2024-01-02 13:14:15.123456'}"; + const std::string expected = + "SELECT CAST(? AS Int16) AS \"value{fn ABS(1)}\", " + "'{fn ABS(2)}' /* {fn ABS(3)} */, CAST('2024-01-02's AS Date), " + "CAST('1970-01-01T10:11:12Z's AS Datetime), " + "CAST('2024-01-02T13:14:15.123456Z's AS Timestamp)"; + char out[512] = {}; + SQLINTEGER outLen = 0; + CHECK_ODBC_OK(SQLNativeSql( + dbc, reinterpret_cast(input.data()), SQL_NTS, + reinterpret_cast(out), sizeof(out), &outLen), + dbc, SQL_HANDLE_DBC); + EXPECT_STREQ(out, expected.c_str()); + EXPECT_EQ(outLen, static_cast(expected.size())); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLNativeSqlPreservesLargeExplicitLength) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + std::string input(40000, 'x'); + std::string output(input.size() + 1, '\0'); + SQLINTEGER outLen = -1; + CHECK_ODBC_OK(SQLNativeSql( + dbc, reinterpret_cast(input.data()), static_cast(input.size()), + reinterpret_cast(output.data()), static_cast(output.size()), &outLen), + dbc, SQL_HANDLE_DBC); + EXPECT_EQ(outLen, static_cast(input.size())); + output.resize(static_cast(outLen)); + EXPECT_EQ(output, input); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLSetGetCursorName) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt, other; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &other), SQL_SUCCESS); + SQLCHAR generated[19] = {}, otherName[19] = {}; + SQLSMALLINT generatedLength = 0; + CHECK_ODBC_OK(SQLGetCursorName(stmt, generated, sizeof(generated), &generatedLength), stmt, SQL_HANDLE_STMT); + EXPECT_LE(generatedLength, 18); + EXPECT_EQ(std::strncmp(reinterpret_cast(generated), "SQL_CUR", 7), 0); + CHECK_ODBC_OK(SQLGetCursorName(other, otherName, sizeof(otherName), nullptr), other, SQL_HANDLE_STMT); + EXPECT_STRNE(reinterpret_cast(generated), reinterpret_cast(otherName)); + SQLCHAR name[64] = {}; + SQLSMALLINT nameLen = 0; + CHECK_ODBC_OK(SQLGetCursorName(stmt, name, sizeof(name), &nameLen), stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(reinterpret_cast(name), reinterpret_cast(generated)); + CHECK_ODBC_OK(SQLSetCursorName(stmt, (SQLCHAR*)"mycursor", SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLGetCursorName(stmt, name, sizeof(name), &nameLen), stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(reinterpret_cast(name), "mycursor"); + SQLFreeHandle(SQL_HANDLE_STMT, other); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLStatisticsSchemaForMissingTable) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLStatistics(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)"missing_statistics_table", SQL_NTS, + SQL_INDEX_ALL, SQL_QUICK), + stmt, SQL_HANDLE_STMT); + SQLCHAR columnName[32] = {}; + SQLSMALLINT nameLength = 0; + SQLSMALLINT dataType = 0; + SQLULEN columnSize = 0; + SQLSMALLINT decimalDigits = 0; + SQLSMALLINT nullable = 0; + CHECK_ODBC_OK(SQLDescribeCol(stmt, 4, columnName, sizeof(columnName), &nameLength, + &dataType, &columnSize, &decimalDigits, &nullable), + stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(reinterpret_cast(columnName), "NON_UNIQUE"); + EXPECT_EQ(dataType, SQL_SMALLINT); + EXPECT_EQ(nullable, SQL_NULLABLE); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLSpecialColumnsPrimaryKey) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_special_columns_pk", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_special_columns_pk (id Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + const char* table = "/local/test_special_columns_pk"; + CHECK_ODBC_OK(SQLSpecialColumns(stmt, SQL_BEST_ROWID, nullptr, 0, nullptr, 0, + (SQLCHAR*)table, SQL_NTS, SQL_SCOPE_SESSION, SQL_NULLABLE), + stmt, SQL_HANDLE_STMT); + char columnName[64] = {}; + SQLLEN indicator = 0; + SQLBindCol(stmt, 2, SQL_C_CHAR, columnName, sizeof(columnName), &indicator); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + EXPECT_STREQ(columnName, "id"); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLGetInfoInterfaceConformance) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + SQLUINTEGER conformance = 0; + SQLSMALLINT outLen = 0; + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_ODBC_INTERFACE_CONFORMANCE, &conformance, 0, &outLen), + dbc, SQL_HANDLE_DBC); + EXPECT_EQ(conformance, SQL_OIC_CORE); + char userName[8] = {'x'}; + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_USER_NAME, userName, sizeof(userName), &outLen), + dbc, SQL_HANDLE_DBC); + EXPECT_STREQ(userName, ""); + EXPECT_EQ(outLen, 0); + char databaseName[64] = {}; + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_DATABASE_NAME, databaseName, sizeof(databaseName), &outLen), + dbc, SQL_HANDLE_DBC); + EXPECT_STREQ(databaseName, "/local"); + EXPECT_EQ(outLen, 6); + char serverName[64] = {}; + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_SERVER_NAME, serverName, sizeof(serverName), &outLen), + dbc, SQL_HANDLE_DBC); + EXPECT_STREQ(serverName, "localhost:2136"); + EXPECT_EQ(outLen, 14); + char dbmsVersion[64] = {}; + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_DBMS_VER, dbmsVersion, sizeof(dbmsVersion), &outLen), + dbc, SQL_HANDLE_DBC); + EXPECT_GT(outLen, 0); + EXPECT_NE(dbmsVersion[0], '\0'); + char driverVersion[64] = {}; + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_DRIVER_VER, driverVersion, sizeof(driverVersion), &outLen), + dbc, SQL_HANDLE_DBC); + EXPECT_STREQ(driverVersion, ODBC_DRIVER_VERSION); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLGetInfoScalarWidths) { + struct TU16Info { + SQLUSMALLINT InfoType; + SQLUSMALLINT Expected; + }; + struct TU32Info { + SQLUSMALLINT InfoType; + SQLUINTEGER Expected; + }; + constexpr std::array u16Info{{ + {SQL_MAX_DRIVER_CONNECTIONS, 0}, + {SQL_MAX_CONCURRENT_ACTIVITIES, 0}, + {SQL_MAX_COLUMNS_IN_GROUP_BY, 0}, + {SQL_MAX_COLUMNS_IN_ORDER_BY, 0}, + {SQL_MAX_COLUMNS_IN_INDEX, 20}, + {SQL_MAX_COLUMNS_IN_SELECT, 0}, + {SQL_MAX_COLUMNS_IN_TABLE, 200}, + {SQL_MAX_TABLES_IN_SELECT, 0}, + {SQL_CATALOG_LOCATION, SQL_CL_START}, + {SQL_GROUP_BY, SQL_GB_GROUP_BY_CONTAINS_SELECT}, + {SQL_NON_NULLABLE_COLUMNS, SQL_NNC_NON_NULL}, + }}; + constexpr std::array u32Info{{ + {SQL_ALTER_TABLE, 0}, + {SQL_CATALOG_USAGE, 0}, + {SQL_DYNAMIC_CURSOR_ATTRIBUTES1, 0}, + {SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2, SQL_CA2_READ_ONLY_CONCURRENCY}, + }}; + constexpr SQLUSMALLINT u16Canary = 0xA55A; + constexpr SQLUINTEGER u32Canary = 0xA55AA55A; + + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + + for (const auto& info : u16Info) { + SCOPED_TRACE(info.InfoType); + std::array guarded{0xFFFF, u16Canary}; + SQLSMALLINT outLength = -1; + CHECK_ODBC_OK(SQLGetInfo(dbc, info.InfoType, guarded.data(), sizeof(guarded[0]), &outLength), + dbc, SQL_HANDLE_DBC); + EXPECT_EQ(guarded[0], info.Expected); + EXPECT_EQ(guarded[1], u16Canary); + EXPECT_EQ(outLength, static_cast(sizeof(SQLUSMALLINT))); + } + + for (const auto& info : u32Info) { + SCOPED_TRACE(info.InfoType); + std::array guarded{0xFFFFFFFF, u32Canary}; + SQLSMALLINT outLength = -1; + CHECK_ODBC_OK(SQLGetInfo(dbc, info.InfoType, guarded.data(), sizeof(guarded[0]), &outLength), + dbc, SQL_HANDLE_DBC); + EXPECT_EQ(guarded[0], info.Expected); + EXPECT_EQ(guarded[1], u32Canary); + EXPECT_EQ(outLength, static_cast(sizeof(SQLUINTEGER))); + } + + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLSetGetStmtAttrCursorCapabilities) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLULEN value = static_cast(-1); + CHECK_ODBC_OK(SQLGetStmtAttr( + stmt, SQL_ATTR_CURSOR_SENSITIVITY, &value, sizeof(value), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, SQL_UNSPECIFIED); + CHECK_ODBC_OK(SQLGetStmtAttr( + stmt, SQL_ATTR_USE_BOOKMARKS, &value, sizeof(value), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, SQL_UB_OFF); + + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_SENSITIVITY, + (SQLPOINTER)SQL_INSENSITIVE, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, &value, sizeof(value), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, SQL_CURSOR_STATIC); + CHECK_ODBC_OK(SQLGetStmtAttr( + stmt, SQL_ATTR_CURSOR_SENSITIVITY, &value, sizeof(value), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, SQL_INSENSITIVE); + + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, + (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY, 0), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_SENSITIVITY, + (SQLPOINTER)SQL_SENSITIVE, 0), + SQL_SUCCESS_WITH_INFO); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "01S02")); + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, &value, sizeof(value), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, SQL_CURSOR_STATIC); + CHECK_ODBC_OK(SQLGetStmtAttr( + stmt, SQL_ATTR_CURSOR_SENSITIVITY, &value, sizeof(value), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, SQL_INSENSITIVE); + + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, + (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY, 0), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_USE_BOOKMARKS, (SQLPOINTER)SQL_UB_ON, 0), + SQL_SUCCESS_WITH_INFO); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "01S02")); + CHECK_ODBC_OK(SQLGetStmtAttr( + stmt, SQL_ATTR_USE_BOOKMARKS, &value, sizeof(value), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, SQL_UB_OFF); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLForeignKeysEmpty) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLForeignKeys(stmt, nullptr, 0, nullptr, 0, (SQLCHAR*)"%", SQL_NTS, + nullptr, 0, nullptr, 0, (SQLCHAR*)"%", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLSMALLINT colCount = 0; + CHECK_ODBC_OK(SQLNumResultCols(stmt, &colCount), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(colCount, 14); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLColumnPrivilegesEmpty) { + struct TExpectedColumn { + const char* Name; + SQLSMALLINT Type; + SQLSMALLINT Nullable; + }; + constexpr std::array expected{{ + {"TABLE_CAT", SQL_VARCHAR, SQL_NULLABLE}, + {"TABLE_SCHEM", SQL_VARCHAR, SQL_NULLABLE}, + {"TABLE_NAME", SQL_VARCHAR, SQL_NO_NULLS}, + {"COLUMN_NAME", SQL_VARCHAR, SQL_NO_NULLS}, + {"GRANTOR", SQL_VARCHAR, SQL_NULLABLE}, + {"GRANTEE", SQL_VARCHAR, SQL_NO_NULLS}, + {"PRIVILEGE", SQL_VARCHAR, SQL_NO_NULLS}, + {"IS_GRANTABLE", SQL_VARCHAR, SQL_NULLABLE}, + }}; + + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLUSMALLINT supported = SQL_FALSE; + CHECK_ODBC_OK(SQLGetFunctions(dbc, SQL_API_SQLCOLUMNPRIVILEGES, &supported), + dbc, SQL_HANDLE_DBC); + EXPECT_EQ(supported, SQL_TRUE); + + CHECK_ODBC_OK(SQLColumnPrivileges(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)"does_not_exist", SQL_NTS, + (SQLCHAR*)"%", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLSMALLINT columnCount = 0; + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(columnCount, static_cast(expected.size())); + for (size_t index = 0; index < expected.size(); ++index) { + char name[32] = {}; + SQLSMALLINT nameLength = 0; + SQLSMALLINT type = 0; + SQLULEN size = 0; + SQLSMALLINT scale = 0; + SQLSMALLINT nullable = 0; + CHECK_ODBC_OK(SQLDescribeCol( + stmt, static_cast(index + 1), + reinterpret_cast(name), sizeof(name), &nameLength, + &type, &size, &scale, &nullable), + stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(name, expected[index].Name); + EXPECT_EQ(type, expected[index].Type); + EXPECT_EQ(nullable, expected[index].Nullable); + } + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLPrimaryKeys) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_primary_keys", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_primary_keys (id Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + const char* table = "/local/test_primary_keys"; + CHECK_ODBC_OK(SQLPrimaryKeys(stmt, nullptr, 0, nullptr, 0, (SQLCHAR*)table, SQL_NTS), + stmt, SQL_HANDLE_STMT); + char columnName[64] = {}; + SQLLEN indicator = 0; + SQLBindCol(stmt, 4, SQL_C_CHAR, columnName, sizeof(columnName), &indicator); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + EXPECT_STREQ(columnName, "id"); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLDescribeParamUnknown) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT ?", SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLSMALLINT dataType = -1, decimalDigits = -1, nullable = -1; + SQLULEN paramSize = 123; + EXPECT_EQ(SQLDescribeParam(stmt, 1, &dataType, ¶mSize, &decimalDigits, &nullable), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "HYC00")); + EXPECT_EQ(dataType, -1); + EXPECT_EQ(paramSize, 123); + EXPECT_EQ(decimalDigits, -1); + EXPECT_EQ(nullable, -1); + SQLINTEGER value = 42; + EXPECT_EQ(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_UNKNOWN_TYPE, + 0, 0, &value, 0, nullptr), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "HY004")); + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, &value, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER actual = 0; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_LONG, &actual, sizeof(actual), nullptr), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(actual, value); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLDescribeParamBound) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT ?", SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLINTEGER value = 42; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, &value, 0, nullptr), + stmt, SQL_HANDLE_STMT); + SQLSMALLINT dataType = 0; + SQLULEN paramSize = 0; + SQLSMALLINT decimalDigits = 0; + SQLSMALLINT nullable = 0; + CHECK_ODBC_OK(SQLDescribeParam(stmt, 1, &dataType, ¶mSize, &decimalDigits, &nullable), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(dataType, SQL_INTEGER); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLParamDataPutData) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_at_exec", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_at_exec (id Int32, val Text, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"UPSERT INTO test_at_exec (id, val) VALUES (1, ? || ?)", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLLEN atExec = SQL_DATA_AT_EXEC; + SQLPOINTER parameterToken = &atExec; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 32, 0, + parameterToken, 0, &atExec), stmt, SQL_HANDLE_STMT); + SQLINTEGER secondToken = 0; + CHECK_ODBC_OK(SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 32, 0, + &secondToken, 0, &atExec), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLExecute(stmt), SQL_NEED_DATA); + SQLPOINTER token = nullptr; + ASSERT_EQ(SQLParamData(stmt, &token), SQL_NEED_DATA); + EXPECT_EQ(token, parameterToken); + const char part1[] = "hel"; + CHECK_ODBC_OK(SQLPutData(stmt, (SQLPOINTER)part1, sizeof(part1) - 1), stmt, SQL_HANDLE_STMT); + const char part2[] = "lo"; + CHECK_ODBC_OK(SQLPutData(stmt, (SQLPOINTER)part2, sizeof(part2) - 1), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLPutData(stmt, (SQLPOINTER)"", 0), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLParamData(stmt, &token), SQL_NEED_DATA); + EXPECT_EQ(token, &secondToken); + CHECK_ODBC_OK(SQLPutData(stmt, (SQLPOINTER)" wor", 4), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLPutData(stmt, (SQLPOINTER)"ld", 2), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLParamData(stmt, &token), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLExecute(stmt), SQL_NEED_DATA); + CHECK_ODBC_OK(SQLCancel(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLFreeStmt(stmt, SQL_RESET_PARAMS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT val FROM test_at_exec WHERE id = 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + char actual[16] = {}; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_CHAR, actual, sizeof(actual), nullptr), stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(actual, "hello world"); + CHECK_ODBC_OK(SQLFreeStmt(stmt, SQL_CLOSE), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT ?", SQL_NTS), stmt, SQL_HANDLE_STMT); + atExec = 0; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_INTEGER, + 10, 0, parameterToken, 0, &atExec), stmt, SQL_HANDLE_STMT); + atExec = SQL_DATA_AT_EXEC; + for (const auto& text : {std::string("bad"), std::string("4\0x", 3), std::string("42")}) { + ASSERT_EQ(SQLExecute(stmt), SQL_NEED_DATA); + ASSERT_EQ(SQLParamData(stmt, &token), SQL_NEED_DATA); + CHECK_ODBC_OK(SQLPutData(stmt, (SQLPOINTER)text.data(), text.size()), stmt, SQL_HANDLE_STMT); + const auto rc = SQLParamData(stmt, &token); + EXPECT_EQ(rc, text == "42" ? SQL_SUCCESS : SQL_ERROR); + if (rc == SQL_ERROR) EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "22018")); + } + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER number = 0; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_LONG, &number, sizeof(number), nullptr), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(number, 42); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLCancel) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT * FROM AS_TABLE(ListMap(ListFromRange(1u, 1000000u), ($x)->(AsStruct($x AS v))))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLCancel(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1", SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLFreeStmtDrop) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + ASSERT_EQ(SQLFreeStmt(stmt, SQL_DROP), SQL_SUCCESS); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLParamDataPutDataNts) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT first; + SQLHSTMT second; + SQLHDESC sharedApd; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &first), SQL_SUCCESS); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &second), SQL_SUCCESS); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DESC, dbc, &sharedApd), SQL_SUCCESS); + CHECK_ODBC_OK(SQLPrepare(first, (SQLCHAR*)"SELECT ?", SQL_NTS), first, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLPrepare(second, (SQLCHAR*)"SELECT ?", SQL_NTS), second, SQL_HANDLE_STMT); + SQLLEN atExec = SQL_DATA_AT_EXEC; + SQLINTEGER tokenMarker = 0; + CHECK_ODBC_OK(SQLBindParameter(second, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 32, 0, + &tokenMarker, 0, &atExec), second, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(first, SQL_ATTR_APP_PARAM_DESC, sharedApd, 0), first, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(first, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 32, 0, + &tokenMarker, 0, &atExec), first, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(second, SQL_ATTR_APP_PARAM_DESC, sharedApd, 0), second, SQL_HANDLE_STMT); + + SQLPOINTER token = nullptr; + ASSERT_EQ(SQLExecute(first), SQL_NEED_DATA); + ASSERT_EQ(SQLParamData(first, &token), SQL_NEED_DATA); + CHECK_ODBC_OK(SQLPutData(first, (SQLPOINTER)"first", SQL_NTS), first, SQL_HANDLE_STMT); + ASSERT_EQ(SQLExecute(second), SQL_NEED_DATA); + ASSERT_EQ(SQLParamData(second, &token), SQL_NEED_DATA); + ASSERT_EQ(SQLPutData(second, (SQLPOINTER)"", 0), SQL_SUCCESS); + const SQLRETURN secondRc = SQLParamData(second, &token); + CHECK_ODBC_OK(secondRc, second, SQL_HANDLE_STMT); + const SQLRETURN firstRc = SQLParamData(first, &token); + CHECK_ODBC_OK(firstRc, first, SQL_HANDLE_STMT); + + SQLHSTMT statements[] = {first, second}; + const char* expected[] = {"first", ""}; + for (size_t i = 0; i < 2; ++i) { + ASSERT_EQ(SQLFetch(statements[i]), SQL_SUCCESS); + char actual[8] = {}; + CHECK_ODBC_OK(SQLGetData(statements[i], 1, SQL_C_CHAR, actual, sizeof(actual), nullptr), + statements[i], SQL_HANDLE_STMT); + EXPECT_STREQ(actual, expected[i]); + } + SQLLEN nullInput = SQL_NULL_DATA; + CHECK_ODBC_OK(SQLFreeStmt(first, SQL_CLOSE), first, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetDescField(sharedApd, 1, SQL_DESC_INDICATOR_PTR, &nullInput, 0), sharedApd, SQL_HANDLE_DESC); + CHECK_ODBC_OK(SQLExecute(first), first, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(first), SQL_SUCCESS); + char value = 0; + SQLLEN length = 0; + CHECK_ODBC_OK(SQLGetData(first, 1, SQL_C_CHAR, &value, sizeof(value), &length), first, SQL_HANDLE_STMT); + EXPECT_EQ(length, SQL_NULL_DATA); + for (auto statement : statements) SQLFreeHandle(SQL_HANDLE_STMT, statement); + SQLFreeHandle(SQL_HANDLE_DESC, sharedApd); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(CoreApi, SQLCancelIdle) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLCancel(stmt), stmt, SQL_HANDLE_STMT); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} diff --git a/odbc/tests/integration/descriptor_api_it.cpp b/odbc/tests/integration/descriptor_api_it.cpp new file mode 100644 index 00000000000..a11217007cd --- /dev/null +++ b/odbc/tests/integration/descriptor_api_it.cpp @@ -0,0 +1,152 @@ +#include "test_utils.h" + +#include + +TEST(DescriptorApi, ImplicitImpRowDesc) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*) + "SELECT CAST(1 AS Int8), CAST(1 AS Uint8), CAST(1 AS Int16), CAST(1 AS Uint16), " + "CAST(1 AS Int32), CAST(1 AS Uint32), CAST(1 AS Int64), CAST(1 AS Uint64)", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLHDESC ird = SQL_NULL_HDESC; + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_IMP_ROW_DESC, &ird, sizeof(ird), nullptr), + stmt, SQL_HANDLE_STMT); + ASSERT_NE(ird, nullptr); + const std::array displaySizes = {4, 3, 6, 5, 11, 10, 20, 20}; + for (SQLUSMALLINT column = 1; column <= displaySizes.size(); ++column) { + SQLLEN displaySize = 0, columnDisplaySize = 0; + CHECK_ODBC_OK(SQLGetDescField(ird, column, SQL_DESC_DISPLAY_SIZE, + &displaySize, 0, nullptr), ird, SQL_HANDLE_DESC); + CHECK_ODBC_OK(SQLColAttribute(stmt, column, SQL_DESC_DISPLAY_SIZE, nullptr, 0, + nullptr, &columnDisplaySize), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(displaySize, displaySizes[column - 1]); + EXPECT_EQ(displaySize, columnDisplaySize); + SQLSMALLINT isUnsigned = SQL_FALSE; + SQLLEN columnIsUnsigned = SQL_FALSE; + CHECK_ODBC_OK(SQLGetDescField(ird, column, SQL_DESC_UNSIGNED, + &isUnsigned, 0, nullptr), ird, SQL_HANDLE_DESC); + CHECK_ODBC_OK(SQLColAttribute(stmt, column, SQL_DESC_UNSIGNED, nullptr, 0, + nullptr, &columnIsUnsigned), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(isUnsigned, column % 2 == 0 ? SQL_TRUE : SQL_FALSE); + EXPECT_EQ(isUnsigned, columnIsUnsigned); + } + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(DescriptorApi, ImpRowDescCount) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1 AS a, 2 AS b", SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLHDESC ird = SQL_NULL_HDESC; + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_IMP_ROW_DESC, &ird, sizeof(ird), nullptr), + stmt, SQL_HANDLE_STMT); + SQLSMALLINT descCount = 0; + CHECK_ODBC_OK(SQLGetDescField(ird, 0, SQL_DESC_COUNT, &descCount, 0, nullptr), ird, SQL_HANDLE_DESC); + SQLSMALLINT numCols = 0; + CHECK_ODBC_OK(SQLNumResultCols(stmt, &numCols), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(descCount, numCols); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(DescriptorApi, AppRowDescBindCol) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 42 AS v", SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLINTEGER value = 0; + SQLLEN indicator = 0; + CHECK_ODBC_OK(SQLBindCol(stmt, 1, SQL_C_LONG, &value, 0, &indicator), stmt, SQL_HANDLE_STMT); + SQLHDESC ard = SQL_NULL_HDESC; + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_APP_ROW_DESC, &ard, sizeof(ard), nullptr), + stmt, SQL_HANDLE_STMT); + SQLSMALLINT type = 0; + SQLSMALLINT subType = 0; + SQLLEN length = 0; + CHECK_ODBC_OK(SQLGetDescRec(ard, 1, nullptr, 0, nullptr, &type, &subType, &length, nullptr, nullptr, nullptr), + ard, SQL_HANDLE_DESC); + EXPECT_EQ(type, SQL_C_LONG); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(DescriptorApi, ExplicitDescAllocCopy) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + SQLHDESC src = SQL_NULL_HDESC; + SQLHDESC dst = SQL_NULL_HDESC; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DESC, dbc, &src), SQL_SUCCESS); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DESC, dbc, &dst), SQL_SUCCESS); + SQLSMALLINT type = SQL_C_LONG; + SQLLEN length = sizeof(SQLINTEGER); + CHECK_ODBC_OK(SQLSetDescRec(src, 1, type, SQL_INTEGER, length, 0, 0, nullptr, nullptr, nullptr), + src, SQL_HANDLE_DESC); + CHECK_ODBC_OK(SQLCopyDesc(src, dst), src, SQL_HANDLE_DESC); + SQLSMALLINT outType = 0; + SQLSMALLINT outSubType = 0; + SQLLEN outLen = 0; + CHECK_ODBC_OK(SQLGetDescRec(dst, 1, nullptr, 0, nullptr, &outType, &outSubType, &outLen, nullptr, nullptr, nullptr), + dst, SQL_HANDLE_DESC); + EXPECT_EQ(outType, SQL_C_LONG); + EXPECT_EQ(outLen, length); + SQLFreeHandle(SQL_HANDLE_DESC, src); + SQLFreeHandle(SQL_HANDLE_DESC, dst); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(DescriptorApi, FreeBoundDescriptorsRestoresOriginals) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLHDESC originalArd = SQL_NULL_HDESC, originalApd = SQL_NULL_HDESC; + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_APP_ROW_DESC, &originalArd, sizeof(originalArd), nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_APP_PARAM_DESC, &originalApd, sizeof(originalApd), nullptr), stmt, SQL_HANDLE_STMT); + SQLINTEGER value = 0, parameter = 37; + CHECK_ODBC_OK(SQLBindCol(stmt, 1, SQL_C_LONG, &value, sizeof(value), nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, ¶meter, sizeof(parameter), nullptr), stmt, SQL_HANDLE_STMT); + SQLHDESC descriptor = SQL_NULL_HDESC; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DESC, dbc, &descriptor), SQL_SUCCESS); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_APP_ROW_DESC, descriptor, 0), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_APP_PARAM_DESC, descriptor, 0), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFreeHandle(SQL_HANDLE_DESC, descriptor), SQL_SUCCESS); + SQLHDESC restored = SQL_NULL_HDESC; + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_APP_ROW_DESC, &restored, sizeof(restored), nullptr), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(restored, originalArd); + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_APP_PARAM_DESC, &restored, sizeof(restored), nullptr), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(restored, originalApd); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT ? AS value", SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + EXPECT_EQ(value, parameter); + SQLSMALLINT count = 0; + CHECK_ODBC_OK(SQLNumParams(stmt, &count), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(count, 1); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &count), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(count, 1); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_STMT, stmt), SQL_SUCCESS); + EXPECT_EQ(SQLDisconnect(dbc), SQL_SUCCESS); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_DBC, dbc), SQL_SUCCESS); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_ENV, env), SQL_SUCCESS); +} diff --git a/odbc/tests/integration/environment_api_it.cpp b/odbc/tests/integration/environment_api_it.cpp new file mode 100644 index 00000000000..86615c10c87 --- /dev/null +++ b/odbc/tests/integration/environment_api_it.cpp @@ -0,0 +1,227 @@ +#include "test_utils.h" + +TEST(EnvironmentApi, AllocFreeEnv) { + SQLHENV env; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + ASSERT_EQ(SQLFreeHandle(SQL_HANDLE_ENV, env), SQL_SUCCESS); +} + +TEST(EnvironmentApi, AllocEnvInvalidType) { + SQLHENV env; + SQLRETURN rc = SQLAllocHandle(999, SQL_NULL_HANDLE, &env); + ASSERT_TRUE(rc == SQL_ERROR || rc == SQL_INVALID_HANDLE); +} + +TEST(EnvironmentApi, FreeEnvWithLiveConnection) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_ENV, env), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(env, SQL_HANDLE_ENV), "HY010")); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_DBC, dbc), SQL_SUCCESS); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_ENV, env), SQL_SUCCESS); +} + +TEST(EnvironmentApi, SetOdbcVersion) { + SQLHENV env; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + + ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), SQL_SUCCESS); + + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(EnvironmentApi, SetOdbcVersionInvalid) { + SQLHENV env; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + ASSERT_NE(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, nullptr, 0), SQL_SUCCESS); + ASSERT_NE(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)9999, 0), SQL_SUCCESS); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(EnvironmentApi, GetOdbcVersion) { + SQLHENV env; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), SQL_SUCCESS); + + SQLINTEGER version; + ASSERT_EQ(SQLGetEnvAttr(env, SQL_ATTR_ODBC_VERSION, &version, sizeof(version), nullptr), SQL_SUCCESS); + ASSERT_EQ(version, SQL_OV_ODBC3); + + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(EnvironmentApi, SetOutputNtsTrue) { + SQLHENV env; + AllocEnv(&env); + + ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_OUTPUT_NTS, (void*)SQL_TRUE, 0), SQL_SUCCESS); + + SQLINTEGER outputNts; + ASSERT_EQ(SQLGetEnvAttr(env, SQL_ATTR_OUTPUT_NTS, &outputNts, sizeof(outputNts), nullptr), SQL_SUCCESS); + ASSERT_EQ(outputNts, SQL_TRUE); + + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(EnvironmentApi, SetOutputNtsFalse) { + SQLHENV env; + AllocEnv(&env); + ASSERT_NE(SQLSetEnvAttr(env, SQL_ATTR_OUTPUT_NTS, (void*)SQL_FALSE, 0), SQL_SUCCESS); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(EnvironmentApi, GetOutputNtsDefault) { + SQLHENV env; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), SQL_SUCCESS); + SQLINTEGER outputNts; + ASSERT_EQ(SQLGetEnvAttr(env, SQL_ATTR_OUTPUT_NTS, &outputNts, sizeof(outputNts), nullptr), SQL_SUCCESS); + ASSERT_EQ(outputNts, SQL_TRUE); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(EnvironmentApi, SetInvalidEnvAttr) { + SQLHENV env; + AllocEnv(&env); + ASSERT_EQ(SQLSetEnvAttr(env, 9999, (void*)1, 0), SQL_ERROR); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(EnvironmentApi, GetInvalidEnvAttr) { + SQLHENV env; + AllocEnv(&env); + char buffer[256]; + SQLINTEGER len; + ASSERT_EQ(SQLGetEnvAttr(env, 9999, buffer, sizeof(buffer), &len), SQL_ERROR); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(EnvironmentApi, MultipleConnectionsSequential) { + SQLHENV env; + AllocEnv(&env); + for (int i = 0; i < 3; ++i) { + SQLHDBC dbc; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + CHECK_ODBC_OK(SQLConnect(dbc, (SQLCHAR*)"YDB", SQL_NTS, nullptr, 0, nullptr, 0), dbc, SQL_HANDLE_DBC); + SQLHSTMT stmt; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + char query[32]; + snprintf(query, sizeof(query), "SELECT %d", i + 1); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)query, SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER value = 0; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_LONG, &value, sizeof(value), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, i + 1); + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + } + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +namespace { + +void StartManualTx(SQLHDBC dbc, SQLHSTMT* stmt) { + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, 0), dbc, SQL_HANDLE_DBC); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(*stmt, (SQLCHAR*)"SELECT 1", SQL_NTS), *stmt, SQL_HANDLE_STMT); +} + +} // namespace + +TEST(EnvironmentApi, EndTranCommitOnEnv) { + SQLHENV env; + SQLHDBC dbc1, dbc2; + SQLHSTMT stmt1, stmt2; + + AllocEnvAndConnect(&env, &dbc1); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc2), SQL_SUCCESS); + SQLRETURN rc = SQLDriverConnect( + dbc2, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_COMPLETE); + CHECK_ODBC_OK(rc, dbc2, SQL_HANDLE_DBC); + + StartManualTx(dbc1, &stmt1); + StartManualTx(dbc2, &stmt2); + + CHECK_ODBC_OK(SQLEndTran(SQL_HANDLE_ENV, env, SQL_COMMIT), env, SQL_HANDLE_ENV); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt1); + SQLFreeHandle(SQL_HANDLE_STMT, stmt2); + SQLDisconnect(dbc1); + SQLDisconnect(dbc2); + SQLFreeHandle(SQL_HANDLE_DBC, dbc1); + SQLFreeHandle(SQL_HANDLE_DBC, dbc2); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(EnvironmentApi, EndTranRollbackOnEnv) { + SQLHENV env; + SQLHDBC dbc1, dbc2; + SQLHSTMT stmt1, stmt2; + + AllocEnvAndConnect(&env, &dbc1); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc2), SQL_SUCCESS); + SQLRETURN rc = SQLDriverConnect( + dbc2, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_COMPLETE); + CHECK_ODBC_OK(rc, dbc2, SQL_HANDLE_DBC); + + StartManualTx(dbc1, &stmt1); + StartManualTx(dbc2, &stmt2); + + CHECK_ODBC_OK(SQLEndTran(SQL_HANDLE_ENV, env, SQL_ROLLBACK), env, SQL_HANDLE_ENV); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt1); + SQLFreeHandle(SQL_HANDLE_STMT, stmt2); + SQLDisconnect(dbc1); + SQLDisconnect(dbc2); + SQLFreeHandle(SQL_HANDLE_DBC, dbc1); + SQLFreeHandle(SQL_HANDLE_DBC, dbc2); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(EnvironmentApi, EndTranPartialFailureReturnsInfo) { + SQLHENV env; + SQLHDBC dbc1, dbc2; + SQLHSTMT stmt1, stmt2; + + AllocEnvAndConnect(&env, &dbc1); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc2), SQL_SUCCESS); + SQLRETURN rc = SQLDriverConnect( + dbc2, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_COMPLETE); + CHECK_ODBC_OK(rc, dbc2, SQL_HANDLE_DBC); + + StartManualTx(dbc1, &stmt1); + CHECK_ODBC_OK(SQLSetConnectAttr(dbc2, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, 0), dbc2, SQL_HANDLE_DBC); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc2, &stmt2), SQL_SUCCESS); + (void)SQLExecDirect(stmt2, (SQLCHAR*)"SELECT FROM", SQL_NTS); + + rc = SQLEndTran(SQL_HANDLE_ENV, env, SQL_COMMIT); + ASSERT_TRUE(rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) + << GetOdbcError(env, SQL_HANDLE_ENV); + + CHECK_ODBC_OK(SQLEndTran(SQL_HANDLE_DBC, dbc1, SQL_ROLLBACK), dbc1, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLEndTran(SQL_HANDLE_DBC, dbc2, SQL_ROLLBACK), dbc2, SQL_HANDLE_DBC); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_STMT, stmt1), SQL_SUCCESS); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_STMT, stmt2), SQL_SUCCESS); + EXPECT_EQ(SQLDisconnect(dbc1), SQL_SUCCESS); + EXPECT_EQ(SQLDisconnect(dbc2), SQL_SUCCESS); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_DBC, dbc1), SQL_SUCCESS); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_DBC, dbc2), SQL_SUCCESS); + EXPECT_EQ(SQLFreeHandle(SQL_HANDLE_ENV, env), SQL_SUCCESS); +} + +TEST(EnvironmentApi, GetDiagRecEnv) { + SQLHENV env; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS); + (void)SQLSetEnvAttr(env, 9999, (void*)1, 0); + SQLCHAR sqlState[6]; + SQLINTEGER nativeError; + SQLCHAR msg[256]; + SQLSMALLINT msgLen; + (void)SQLGetDiagRec(SQL_HANDLE_ENV, env, 1, sqlState, &nativeError, msg, sizeof(msg), &msgLen); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} diff --git a/odbc/tests/integration/error_handling_it.cpp b/odbc/tests/integration/error_handling_it.cpp new file mode 100644 index 00000000000..e2c31f2b874 --- /dev/null +++ b/odbc/tests/integration/error_handling_it.cpp @@ -0,0 +1,144 @@ +#include "test_utils.h" + +TEST(ErrorHandling, GetDiagRecAfterError) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + SQLRETURN rc = SQLConnect(dbc, (SQLCHAR*)"NONEXISTENT_DSN", SQL_NTS, + (SQLCHAR*)"", SQL_NTS, (SQLCHAR*)"", SQL_NTS); + ASSERT_EQ(rc, SQL_ERROR); + SQLCHAR sqlState[6]; + SQLINTEGER nativeError; + SQLCHAR msg[256]; + SQLSMALLINT msgLen; + SQLRETURN diagRc = SQLGetDiagRec(SQL_HANDLE_DBC, dbc, 1, sqlState, &nativeError, + msg, sizeof(msg), &msgLen); + ASSERT_TRUE(diagRc == SQL_SUCCESS || diagRc == SQL_SUCCESS_WITH_INFO); + const size_t copiedLen = std::strlen(reinterpret_cast(msg)); + ASSERT_EQ(msg[copiedLen], static_cast(0)); + if (diagRc == SQL_SUCCESS_WITH_INFO) { + ASSERT_GE(static_cast(msgLen), copiedLen); + } else { + ASSERT_EQ(static_cast(msgLen), copiedLen); + } + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ErrorHandling, GetDiagRecMultipleErrors) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLExecDirect(stmt, (SQLCHAR*)"INVALID SYNTAX HERE", SQL_NTS); + + SQLINTEGER numRecs; + SQLGetDiagField(SQL_HANDLE_STMT, stmt, 0, SQL_DIAG_NUMBER, &numRecs, 0, nullptr); + + for (SQLINTEGER i = 1; i <= numRecs; ++i) { + SQLCHAR sqlState[6]; + SQLINTEGER nativeError; + SQLCHAR msg[256]; + SQLSMALLINT msgLen; + SQLRETURN rc = SQLGetDiagRec(SQL_HANDLE_STMT, stmt, static_cast(i), sqlState, &nativeError, + msg, sizeof(msg), &msgLen); + ASSERT_TRUE(rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO); + } + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ErrorHandling, GetDiagFieldState) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"SELECT invalid_column FROM nonexistent_table", SQL_NTS); + SQLCHAR sqlState[6]; + SQLRETURN rc = SQLGetDiagField(SQL_HANDLE_STMT, stmt, 1, SQL_DIAG_SQLSTATE, + sqlState, sizeof(sqlState), nullptr); + ASSERT_TRUE(rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ErrorHandling, GetDiagFieldNativeError) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"SELECT * FROM nonexistent_table", SQL_NTS); + SQLINTEGER nativeError; + SQLRETURN rc = SQLGetDiagField(SQL_HANDLE_STMT, stmt, 1, SQL_DIAG_NATIVE, + &nativeError, sizeof(nativeError), nullptr); + ASSERT_TRUE(rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + + +TEST(ErrorHandling, SuccessWithInfo) { + SQLHENV env; + SQLHDBC dbc; + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + SQLCHAR outStr[10] = {}; + SQLSMALLINT outLen = -1; + SQLRETURN rc = SQLDriverConnect(dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, + outStr, sizeof(outStr), &outLen, SQL_DRIVER_NOPROMPT); + ASSERT_EQ(rc, SQL_SUCCESS_WITH_INFO); +#ifdef ODBC_TEST_IODBC + // iODBC 3.52 overwrites the driver's required output length with the + // length of the truncated buffer and does not expose the driver's 01004 + // diagnostic record. The return code and truncated contents are retained. + EXPECT_EQ(outLen, static_cast(sizeof(outStr) - 1)); +#else + EXPECT_EQ(outLen, static_cast(std::strlen(kConnStr))); +#endif + EXPECT_EQ(std::string(reinterpret_cast(outStr)), std::string(kConnStr, sizeof(outStr) - 1)); +#ifdef ODBC_TEST_IODBC + SQLCHAR sqlState[6] = {}; + SQLINTEGER nativeError = 0; + SQLCHAR message[256] = {}; + SQLSMALLINT messageLength = 0; + EXPECT_EQ(SQLGetDiagRec(SQL_HANDLE_DBC, dbc, 1, sqlState, &nativeError, + message, sizeof(message), &messageLength), + SQL_NO_DATA); +#else + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(dbc, SQL_HANDLE_DBC), "01004")); +#endif + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(ErrorHandling, ClearErrors) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"SELECT * FROM nonexistent_table", SQL_NTS); + SQLINTEGER numRecs1; + SQLGetDiagField(SQL_HANDLE_STMT, stmt, 0, SQL_DIAG_NUMBER, &numRecs1, 0, nullptr); + ASSERT_GT(numRecs1, 0); + SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1", SQL_NTS); + SQLINTEGER numRecs2; + SQLGetDiagField(SQL_HANDLE_STMT, stmt, 0, SQL_DIAG_NUMBER, &numRecs2, 0, nullptr); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} diff --git a/odbc/tests/integration/metadata_api_it.cpp b/odbc/tests/integration/metadata_api_it.cpp new file mode 100644 index 00000000000..a5958500d1a --- /dev/null +++ b/odbc/tests/integration/metadata_api_it.cpp @@ -0,0 +1,955 @@ +#include "test_utils.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef SQL_ATTR_METADATA_ID +#define SQL_ATTR_METADATA_ID 10029 +#endif + +namespace { + +struct TMetadataHandles { + SQLHENV Env = SQL_NULL_HENV; + SQLHDBC Dbc = SQL_NULL_HDBC; + SQLHSTMT Stmt = SQL_NULL_HSTMT; + + TMetadataHandles() { + AllocEnvAndConnect(&Env, &Dbc); + EXPECT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, Dbc, &Stmt), SQL_SUCCESS); + } + + ~TMetadataHandles() { + SQLFreeHandle(SQL_HANDLE_STMT, Stmt); + SQLDisconnect(Dbc); + SQLFreeHandle(SQL_HANDLE_DBC, Dbc); + SQLFreeHandle(SQL_HANDLE_ENV, Env); + } +}; + +void ExecuteAndClose(SQLHSTMT stmt, const char* sql) { + CHECK_ODBC_OK(SQLExecDirect( + stmt, reinterpret_cast(const_cast(sql)), SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFreeStmt(stmt, SQL_CLOSE), SQL_SUCCESS); +} + +std::optional ReadText(SQLHSTMT stmt, SQLUSMALLINT column) { + char value[512] = {}; + SQLLEN indicator = 0; + const SQLRETURN rc = SQLGetData( + stmt, column, SQL_C_CHAR, value, sizeof(value), &indicator); + if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { + ADD_FAILURE() << GetOdbcError(stmt, SQL_HANDLE_STMT); + return std::nullopt; + } + return indicator == SQL_NULL_DATA ? std::nullopt + : std::optional{value}; +} + +constexpr std::monostate AnyValue; +using TExpectedValue = std::variant; +using TExpectedCell = std::pair; + +void ExpectRow(SQLHSTMT stmt, std::initializer_list cells) { + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + for (const auto& [column, expected] : cells) { + const auto value = ReadText(stmt, column); + if (std::holds_alternative(expected)) { + EXPECT_FALSE(value) << "column " << column; + continue; + } + ASSERT_TRUE(value) << "column " << column; + if (const auto* text = std::get_if(&expected)) { + EXPECT_EQ(*value, *text) << "column " << column; + } else if (const auto* number = std::get_if(&expected)) { + EXPECT_EQ(*value, std::to_string(*number)) << "column " << column; + } + } +} + +void FinishResult(SQLHSTMT stmt) { + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + ASSERT_EQ(SQLFreeStmt(stmt, SQL_CLOSE), SQL_SUCCESS); +} + +void ExpectError(SQLRETURN result, SQLHSTMT stmt, std::string_view state) { + EXPECT_EQ(result, SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), state)); +} + +} // namespace + +TEST(MetadataApi, SQLTablesAll) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLTables(stmt, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0), + stmt, SQL_HANDLE_STMT); + int rowCount = 0; + while (SQLFetch(stmt) == SQL_SUCCESS) { + ++rowCount; + } + ASSERT_GT(rowCount, 0); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(MetadataApi, SQLTablesWithPattern) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_metadata_pattern_a", SQL_NTS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_metadata_pattern_b", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_metadata_pattern_a (id Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_metadata_pattern_b (id Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLTables(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)"test\\_metadata\\_pattern\\_%", SQL_NTS, nullptr, 0), + stmt, SQL_HANDLE_STMT); + int tableCount = 0; + while (SQLFetch(stmt) == SQL_SUCCESS) { + ++tableCount; + } + ASSERT_EQ(tableCount, 2); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(MetadataApi, SQLTablesExactMatch) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_exact_table", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_exact_table (id Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_METADATA_ID, (SQLPOINTER)(uintptr_t)SQL_TRUE, 0), + stmt, SQL_HANDLE_STMT); + const std::string exactPath = "/local/test_exact_table"; + SQLCHAR catalog[] = "local"; + SQLCHAR schema[] = ""; + CHECK_ODBC_OK(SQLTables(stmt, catalog, SQL_NTS, schema, 0, + (SQLCHAR*)exactPath.c_str(), SQL_NTS, nullptr, 0), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(MetadataApi, RelativeTableMetadataUsesCurrentCatalog) { + struct TExpectedColumn { + const char* Name; + const char* TypeName; + SQLSMALLINT Nullable; + const char* IsNullable; + }; + const TExpectedColumn expectedColumns[] = { + {"id", "Int32", SQL_NO_NULLS, "NO"}, + {"value", "Utf8", SQL_NULLABLE, "YES"}, + }; + + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_relative_metadata", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_relative_metadata (id Int32 NOT NULL, value Utf8, PRIMARY KEY (id))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + + const char* table = "test_relative_metadata"; + CHECK_ODBC_OK(SQLTables(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)table, SQL_NTS, (SQLCHAR*)"TABLE", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + char catalog[64] = {}; + char tableName[64] = {}; + SQLLEN indicator = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_CHAR, catalog, sizeof(catalog), &indicator), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 3, SQL_C_CHAR, tableName, sizeof(tableName), &indicator), SQL_SUCCESS); + EXPECT_STREQ(catalog, "local"); + EXPECT_STREQ(tableName, table); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLColumns(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)table, SQL_NTS, nullptr, 0), + stmt, SQL_HANDLE_STMT); + for (const auto& column : expectedColumns) { + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + char columnName[64] = {}; + char typeName[64] = {}; + char isNullable[8] = {}; + SQLSMALLINT nullable = -1; + CHECK_ODBC_OK(SQLGetData(stmt, 4, SQL_C_CHAR, columnName, + sizeof(columnName), &indicator), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_CHAR, catalog, + sizeof(catalog), &indicator), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLGetData(stmt, 6, SQL_C_CHAR, typeName, + sizeof(typeName), &indicator), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLGetData(stmt, 11, SQL_C_SSHORT, &nullable, 0, &indicator), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLGetData(stmt, 18, SQL_C_CHAR, isNullable, + sizeof(isNullable), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(columnName, column.Name); + EXPECT_STREQ(catalog, "local"); + EXPECT_STREQ(typeName, column.TypeName); + EXPECT_EQ(nullable, column.Nullable); + EXPECT_STREQ(isNullable, column.IsNullable); + } + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLPrimaryKeys(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)table, SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + char columnName[64] = {}; + ASSERT_EQ(SQLGetData(stmt, 4, SQL_C_CHAR, columnName, sizeof(columnName), &indicator), SQL_SUCCESS); + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_CHAR, catalog, sizeof(catalog), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(columnName, "id"); + EXPECT_STREQ(catalog, "local"); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + + SQLCHAR catalogWithoutSlash[] = "local"; + CHECK_ODBC_OK(SQLTables(stmt, catalogWithoutSlash, SQL_NTS, nullptr, 0, + (SQLCHAR*)table, SQL_NTS, + (SQLCHAR*)"TABLE", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_CHAR, catalog, sizeof(catalog), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(catalog, "local"); + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLPrimaryKeys(stmt, catalogWithoutSlash, SQL_NTS, nullptr, 0, + (SQLCHAR*)table, SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLGetData(stmt, 4, SQL_C_CHAR, columnName, + sizeof(columnName), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(columnName, "id"); + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(MetadataApi, SQLTablesLikePatternWithMetadataId) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_meta_table_1", SQL_NTS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_meta_table_2", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_meta_table_1 (id Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_meta_table_2 (id Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + SQLULEN metadataId = SQL_FALSE; + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_METADATA_ID, &metadataId, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(metadataId, SQL_FALSE); + const char* likePattern = "test_meta_table_%"; + CHECK_ODBC_OK(SQLTables(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)likePattern, SQL_NTS, (SQLCHAR*)"TABLE", SQL_NTS), + stmt, SQL_HANDLE_STMT); + int tableRows = 0; + while (SQLFetch(stmt) == SQL_SUCCESS) { + ++tableRows; + } + ASSERT_EQ(tableRows, 2); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_METADATA_ID, (SQLPOINTER)(uintptr_t)SQL_TRUE, 0), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_METADATA_ID, &metadataId, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(metadataId, SQL_TRUE); + SQLCHAR catalog[] = "local"; + SQLCHAR schema[] = ""; + CHECK_ODBC_OK(SQLTables(stmt, catalog, SQL_NTS, schema, 0, + (SQLCHAR*)likePattern, SQL_NTS, (SQLCHAR*)"TABLE", SQL_NTS), + stmt, SQL_HANDLE_STMT); + tableRows = 0; + while (SQLFetch(stmt) == SQL_SUCCESS) { + ++tableRows; + } + ASSERT_EQ(tableRows, 0); + SQLFreeStmt(stmt, SQL_CLOSE); + const std::string exactPath = "/local/test_meta_table_1"; + CHECK_ODBC_OK(SQLTables(stmt, catalog, SQL_NTS, schema, 0, + (SQLCHAR*)exactPath.c_str(), SQL_NTS, (SQLCHAR*)"TABLE", SQL_NTS), + stmt, SQL_HANDLE_STMT); + tableRows = 0; + while (SQLFetch(stmt) == SQL_SUCCESS) { + ++tableRows; + } + ASSERT_EQ(tableRows, 1); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_METADATA_ID, (SQLPOINTER)(uintptr_t)SQL_FALSE, 0), + stmt, SQL_HANDLE_STMT); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(MetadataApi, SQLColumnsAll) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_columns_all", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_columns_all (id Int32, name Text, value Int32, PRIMARY KEY (id))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLColumns(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)"/local/test_columns_all", SQL_NTS, nullptr, 0), + stmt, SQL_HANDLE_STMT); + int colCount = 0; + while (SQLFetch(stmt) == SQL_SUCCESS) { + ++colCount; + } + ASSERT_EQ(colCount, 3); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLColumns(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)".sys/partition_stats", SQL_NTS, nullptr, 0), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(MetadataApi, SQLColumnsWithPattern) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_columns_pattern", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_columns_pattern (id Int32, value_x Int32, value_y Int32, PRIMARY KEY (id))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + constexpr SQLUSMALLINT kColumnNameCol = 4; + char colName[256] = {}; + SQLLEN colInd = 0; + CHECK_ODBC_OK(SQLColumns(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)"/local/test_columns_pattern", SQL_NTS, + (SQLCHAR*)"val%", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, kColumnNameCol, SQL_C_CHAR, colName, sizeof(colName), &colInd), SQL_SUCCESS); + ASSERT_STREQ(colName, "value_x"); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, kColumnNameCol, SQL_C_CHAR, colName, sizeof(colName), &colInd), SQL_SUCCESS); + ASSERT_STREQ(colName, "value_y"); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(MetadataApi, SQLColumnsMetadataId) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_columns_metadata", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_columns_metadata (id Int32, value_x Int32, PRIMARY KEY (id))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + const std::string exactTable = "/local/test_columns_metadata"; + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_METADATA_ID, (SQLPOINTER)(uintptr_t)SQL_TRUE, 0), + stmt, SQL_HANDLE_STMT); + SQLCHAR catalog[] = "local"; + SQLCHAR schema[] = ""; + ASSERT_EQ(SQLColumns(stmt, catalog, SQL_NTS, schema, 0, + (SQLCHAR*)exactTable.c_str(), SQL_NTS, + (SQLCHAR*)"val%", SQL_NTS), + SQL_SUCCESS); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLColumns(stmt, catalog, SQL_NTS, schema, 0, + (SQLCHAR*)exactTable.c_str(), SQL_NTS, + (SQLCHAR*)"nonexistent_col%", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_METADATA_ID, (SQLPOINTER)(uintptr_t)SQL_FALSE, 0), + stmt, SQL_HANDLE_STMT); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(MetadataApi, SQLTablesFilterByType) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_type_filter", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_type_filter (id Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLTables(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)"/local/test_type_filter", SQL_NTS, + (SQLCHAR*)"VIEW", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLTables(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)"/local/test_type_filter", SQL_NTS, + (SQLCHAR*)"TABLE", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLTables(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)"/local/test_type_filter", SQL_NTS, + (SQLCHAR*)"", 0), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(MetadataApi, DdlWithComment) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_ddl_comment", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"/* ddl */ CREATE TABLE test_ddl_comment (id Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(MetadataApi, SQLTablesSpecialEnumerationsAndEmptyArguments) { + TMetadataHandles handles; + const SQLHSTMT stmt = handles.Stmt; + + SQLCHAR empty[] = ""; + SQLCHAR all[] = "%"; + CHECK_ODBC_OK(SQLTables( + stmt, all, SQL_NTS, + empty, 0, empty, 0, empty, 0), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{1, "local"}, {2, nullptr}, {3, nullptr}, {4, nullptr}, {5, nullptr}}); + FinishResult(stmt); + + CHECK_ODBC_OK(SQLTables( + stmt, empty, 0, all, SQL_NTS, + empty, 0, empty, 0), stmt, SQL_HANDLE_STMT); + FinishResult(stmt); + + CHECK_ODBC_OK(SQLTables( + stmt, empty, 0, empty, 0, empty, 0, + all, SQL_NTS), + stmt, SQL_HANDLE_STMT); + std::set tableTypes; + while (SQLFetch(stmt) == SQL_SUCCESS) { + EXPECT_FALSE(ReadText(stmt, 1)); + EXPECT_FALSE(ReadText(stmt, 2)); + EXPECT_FALSE(ReadText(stmt, 3)); + const auto tableType = ReadText(stmt, 4); + ASSERT_TRUE(tableType); + tableTypes.insert(*tableType); + EXPECT_FALSE(ReadText(stmt, 5)); + } + EXPECT_TRUE(tableTypes.contains("TABLE")); + EXPECT_TRUE(tableTypes.contains("VIEW")); + EXPECT_FALSE(tableTypes.contains("RESOURCE_POOL")); + EXPECT_FALSE(tableTypes.contains("EXTERNAL_DATA_SOURCE")); + ASSERT_EQ(SQLFreeStmt(stmt, SQL_CLOSE), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLTables( + stmt, empty, 0, nullptr, 0, nullptr, 0, nullptr, 0), + stmt, SQL_HANDLE_STMT); + FinishResult(stmt); + + CHECK_ODBC_OK(SQLTables( + stmt, nullptr, 0, nullptr, 0, empty, 0, nullptr, 0), + stmt, SQL_HANDLE_STMT); + FinishResult(stmt); + + CHECK_ODBC_OK(SQLSetStmtAttr( + stmt, SQL_ATTR_METADATA_ID, (SQLPOINTER)(uintptr_t)SQL_TRUE, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLTables( + stmt, all, SQL_NTS, empty, 0, empty, 0, empty, 0), stmt, SQL_HANDLE_STMT); + FinishResult(stmt); + CHECK_ODBC_OK(SQLTables( + stmt, empty, 0, empty, 0, empty, 0, all, SQL_NTS), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{4, AnyValue}}); + ASSERT_EQ(SQLFreeStmt(stmt, SQL_CLOSE), SQL_SUCCESS); +} + +TEST(MetadataApi, SQLColumnsFieldsAndCompositePrimaryKey) { + TMetadataHandles handles; + const SQLHSTMT stmt = handles.Stmt; + + ExecuteAndClose(stmt, "DROP TABLE IF EXISTS test_column_metadata_fields"); + ExecuteAndClose(stmt, + "CREATE TABLE test_column_metadata_fields (" + "pk_a Int32, pk_b Int64 NOT NULL, text_value Utf8, payload String, created Timestamp, " + "PRIMARY KEY (pk_b, pk_a))"); + ExecuteAndClose(stmt, + "INSERT INTO test_column_metadata_fields (pk_a, pk_b) VALUES (NULL, 1)"); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT pk_a FROM test_column_metadata_fields WHERE pk_b = 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{1, nullptr}}); + FinishResult(stmt); + + struct TExpectedColumn { + const char* Name; + SQLSMALLINT DataType; + SQLSMALLINT Nullable; + SQLSMALLINT SqlDataType; + TExpectedValue DateTimeSub; + TExpectedValue CharOctetLength; + }; + const std::array expectedColumns{ + TExpectedColumn{"pk_a", SQL_INTEGER, SQL_NULLABLE, SQL_INTEGER, nullptr, nullptr}, + TExpectedColumn{"pk_b", SQL_BIGINT, SQL_NO_NULLS, SQL_BIGINT, nullptr, nullptr}, + TExpectedColumn{"text_value", SQL_VARCHAR, SQL_NULLABLE, SQL_VARCHAR, nullptr, 0}, + TExpectedColumn{"payload", SQL_VARBINARY, SQL_NULLABLE, SQL_VARBINARY, nullptr, 0}, + TExpectedColumn{"created", SQL_TYPE_TIMESTAMP, SQL_NULLABLE, SQL_DATETIME, + SQL_CODE_TIMESTAMP, nullptr}, + }; + + SQLCHAR tableName[] = "test_column_metadata_fields"; + CHECK_ODBC_OK(SQLColumns( + stmt, nullptr, 0, nullptr, 0, tableName, SQL_NTS, nullptr, 0), + stmt, SQL_HANDLE_STMT); + for (size_t i = 0; i < expectedColumns.size(); ++i) { + const auto& expected = expectedColumns[i]; + ExpectRow(stmt, { + {1, "local"}, {2, nullptr}, {3, "test_column_metadata_fields"}, {4, expected.Name}, + {5, expected.DataType}, {8, AnyValue}, {11, expected.Nullable}, + {14, expected.SqlDataType}, {15, expected.DateTimeSub}, + {16, expected.CharOctetLength}, {17, static_cast(i + 1)}, + {18, expected.Nullable == SQL_NO_NULLS ? "NO" : "YES"}, + }); + } + FinishResult(stmt); + + SQLCHAR catalog[] = "local"; + SQLCHAR catalogPattern[] = "loca%"; + CHECK_ODBC_OK(SQLColumns( + stmt, catalog, SQL_NTS, nullptr, 0, tableName, SQL_NTS, + (SQLCHAR*)"pk_a", SQL_NTS), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{4, "pk_a"}}); + FinishResult(stmt); + CHECK_ODBC_OK(SQLColumns( + stmt, catalogPattern, SQL_NTS, nullptr, 0, tableName, SQL_NTS, + (SQLCHAR*)"pk_a", SQL_NTS), stmt, SQL_HANDLE_STMT); + FinishResult(stmt); + + CHECK_ODBC_OK(SQLPrimaryKeys( + stmt, nullptr, 0, nullptr, 0, tableName, SQL_NTS), stmt, SQL_HANDLE_STMT); + const std::array expectedKeys{"pk_b", "pk_a"}; + for (size_t i = 0; i < expectedKeys.size(); ++i) { + ExpectRow(stmt, { + {1, "local"}, {2, nullptr}, {3, "test_column_metadata_fields"}, + {4, expectedKeys[i]}, {5, static_cast(i + 1)}, {6, nullptr}, + }); + } + FinishResult(stmt); + + CHECK_ODBC_OK(SQLSpecialColumns( + stmt, SQL_BEST_ROWID, nullptr, 0, nullptr, 0, tableName, SQL_NTS, + SQL_SCOPE_SESSION, SQL_NULLABLE), stmt, SQL_HANDLE_STMT); + for (const auto* key : expectedKeys) { + ExpectRow(stmt, {{2, key}}); + } + FinishResult(stmt); + CHECK_ODBC_OK(SQLSpecialColumns( + stmt, SQL_BEST_ROWID, nullptr, 0, nullptr, 0, tableName, SQL_NTS, + SQL_SCOPE_SESSION, SQL_NO_NULLS), stmt, SQL_HANDLE_STMT); + FinishResult(stmt); +} + +TEST(MetadataApi, SQLGetTypeInfoDecimalParameters) { + TMetadataHandles handles; + const SQLHSTMT stmt = handles.Stmt; + + for (const auto type : {SQL_DECIMAL, SQL_NUMERIC}) { + CHECK_ODBC_OK(SQLGetTypeInfo(stmt, type), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + const auto name = ReadText(stmt, 1); + ASSERT_TRUE(name); + EXPECT_EQ(*name, "Decimal"); + EXPECT_EQ(ReadText(stmt, 3), "35"); + EXPECT_EQ(ReadText(stmt, 6), "precision,scale"); + EXPECT_EQ(ReadText(stmt, 14), "0"); + EXPECT_EQ(ReadText(stmt, 15), "35"); + FinishResult(stmt); + + ExecuteAndClose(stmt, "DROP TABLE IF EXISTS test_decimal_type_info"); + const std::string create = "CREATE TABLE test_decimal_type_info (" + "id Int32 NOT NULL, value " + *name + "(18, 5), PRIMARY KEY (id))"; + ExecuteAndClose(stmt, create.c_str()); + CHECK_ODBC_OK(SQLColumns(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)"test_decimal_type_info", SQL_NTS, (SQLCHAR*)"value", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{5, SQL_DECIMAL}, {7, 18}, {9, 5}}); + FinishResult(stmt); + ExecuteAndClose(stmt, "DROP TABLE test_decimal_type_info"); + } +} + +TEST(MetadataApi, SQLGetTypeInfoTemporalLiterals) { + TMetadataHandles handles; + const SQLHSTMT stmt = handles.Stmt; + struct TLiteralCase { + SQLSMALLINT Type; + const char* Value; + SQL_TIMESTAMP_STRUCT Expected; + }; + const std::array cases{ + TLiteralCase{SQL_TYPE_DATE, "2024-01-02", {2024, 1, 2, 0, 0, 0, 0}}, + TLiteralCase{SQL_TYPE_TIME, "10:11:12", {1970, 1, 1, 10, 11, 12, 0}}, + TLiteralCase{SQL_TYPE_TIMESTAMP, "2024-01-02 13:14:15.123456", + {2024, 1, 2, 13, 14, 15, 123456000}}, + }; + for (const auto& item : cases) { + SCOPED_TRACE(item.Type); + CHECK_ODBC_OK(SQLGetTypeInfo(stmt, item.Type), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + const auto name = ReadText(stmt, 1); + const auto prefix = ReadText(stmt, 4); + const auto suffix = ReadText(stmt, 5); + ASSERT_TRUE(name); + ASSERT_TRUE(prefix); + ASSERT_TRUE(suffix); + FinishResult(stmt); + + ExecuteAndClose(stmt, "DROP TABLE IF EXISTS test_temporal_type_info"); + const std::string create = "CREATE TABLE test_temporal_type_info (" + "id Int32 NOT NULL, value " + *name + ", PRIMARY KEY (id))"; + ExecuteAndClose(stmt, create.c_str()); + const std::string insert = "--!ansi_lexer\nPRAGMA UnicodeLiterals;\n" + "INSERT INTO test_temporal_type_info (id, value) VALUES (1, " + + *prefix + item.Value + *suffix + ")"; + ExecuteAndClose(stmt, insert.c_str()); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT value FROM test_temporal_type_info WHERE id = 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQL_TIMESTAMP_STRUCT actual{}; + SQLLEN indicator = 0; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_TYPE_TIMESTAMP, &actual, sizeof(actual), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(indicator, sizeof(actual)); + EXPECT_EQ(actual.year, item.Expected.year); + EXPECT_EQ(actual.month, item.Expected.month); + EXPECT_EQ(actual.day, item.Expected.day); + EXPECT_EQ(actual.hour, item.Expected.hour); + EXPECT_EQ(actual.minute, item.Expected.minute); + EXPECT_EQ(actual.second, item.Expected.second); + EXPECT_EQ(actual.fraction, item.Expected.fraction); + FinishResult(stmt); + ExecuteAndClose(stmt, "DROP TABLE test_temporal_type_info"); + } +} + +TEST(MetadataApi, MetadataUsesCurrentCatalogForSameNamedTables) { + TMetadataHandles handles; + const SQLHDBC dbc = handles.Dbc; + const SQLHSTMT stmt = handles.Stmt; + + ExecuteAndClose(stmt, "DROP TABLE IF EXISTS `/local/cat_a/catalog_metadata_same`"); + ExecuteAndClose(stmt, "DROP TABLE IF EXISTS `/local/cat_b/catalog_metadata_same`"); + ExecuteAndClose(stmt, + "CREATE TABLE `/local/cat_a/catalog_metadata_same` (" + "id Int32, a_value Utf8, PRIMARY KEY (id))"); + ExecuteAndClose(stmt, + "CREATE TABLE `/local/cat_b/catalog_metadata_same` (" + "tenant_id Int32, id Int32, b_value Int64, PRIMARY KEY (tenant_id, id))"); + + SQLCHAR relativeTable[] = "catalog_metadata_same"; + SQLCHAR catalogA[] = "local/cat_a"; + CHECK_ODBC_OK(SQLSetConnectAttr( + dbc, SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER)"/local/cat_a", SQL_NTS), + dbc, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLTables( + stmt, catalogA, SQL_NTS, nullptr, 0, relativeTable, SQL_NTS, + (SQLCHAR*)"TABLE", SQL_NTS), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{1, "local/cat_a"}, {3, "catalog_metadata_same"}}); + FinishResult(stmt); + + CHECK_ODBC_OK(SQLColumns( + stmt, nullptr, 0, nullptr, 0, relativeTable, SQL_NTS, nullptr, 0), + stmt, SQL_HANDLE_STMT); + std::vector columns; + while (SQLFetch(stmt) == SQL_SUCCESS) { + const auto name = ReadText(stmt, 4); + ASSERT_TRUE(name); + columns.push_back(*name); + } + EXPECT_EQ(columns, (std::vector{"id", "a_value"})); + ASSERT_EQ(SQLFreeStmt(stmt, SQL_CLOSE), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLSetConnectAttr( + dbc, SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER)"/local/cat_b", SQL_NTS), + dbc, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLPrimaryKeys( + stmt, nullptr, 0, nullptr, 0, relativeTable, SQL_NTS), + stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{1, "local/cat_b"}, {4, "tenant_id"}, {5, 1}}); + ExpectRow(stmt, {{4, "id"}, {5, 2}}); + FinishResult(stmt); + + CHECK_ODBC_OK(SQLSetConnectAttr( + dbc, SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER)"/local", SQL_NTS), + dbc, SQL_HANDLE_DBC); + SQLCHAR nestedTable[] = "cat_a/catalog_metadata_same"; + CHECK_ODBC_OK(SQLTables( + stmt, nullptr, 0, nullptr, 0, nestedTable, SQL_NTS, + (SQLCHAR*)"TABLE", SQL_NTS), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{3, "cat_a/catalog_metadata_same"}}); + FinishResult(stmt); + + SQLCHAR absoluteTable[] = "/local/cat_b/catalog_metadata_same"; + CHECK_ODBC_OK(SQLColumns( + stmt, nullptr, 0, nullptr, 0, absoluteTable, SQL_NTS, + (SQLCHAR*)"b_value", SQL_NTS), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{3, "cat_b/catalog_metadata_same"}, {4, "b_value"}}); + FinishResult(stmt); + + SQLCHAR allTables[] = "%"; + CHECK_ODBC_OK(SQLTables( + stmt, nullptr, 0, nullptr, 0, allTables, SQL_NTS, + (SQLCHAR*)"TABLE", SQL_NTS), stmt, SQL_HANDLE_STMT); + std::set names; + while (SQLFetch(stmt) == SQL_SUCCESS) { + const auto name = ReadText(stmt, 3); + ASSERT_TRUE(name); + names.insert(*name); + } + EXPECT_TRUE(names.contains("cat_a/catalog_metadata_same")); + EXPECT_TRUE(names.contains("cat_b/catalog_metadata_same")); + ASSERT_EQ(SQLFreeStmt(stmt, SQL_CLOSE), SQL_SUCCESS); + + SQLCHAR nestedPattern[] = "cat_a/catalog_metadata_%"; + CHECK_ODBC_OK(SQLTables( + stmt, nullptr, 0, nullptr, 0, nestedPattern, SQL_NTS, + (SQLCHAR*)"TABLE", SQL_NTS), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{3, "cat_a/catalog_metadata_same"}}); + FinishResult(stmt); +} + +TEST(MetadataApi, SQLStatisticsReportsIndexesAndHonorsOptions) { + TMetadataHandles handles; + const SQLHSTMT stmt = handles.Stmt; + + ExecuteAndClose(stmt, "DROP TABLE IF EXISTS test_statistics_metadata"); + ExecuteAndClose(stmt, + "CREATE TABLE test_statistics_metadata (" + "id Int32, city Utf8, created Timestamp, " + "INDEX idx_city_created GLOBAL SYNC ON (city, created), " + "PRIMARY KEY (id))"); + ExecuteAndClose(stmt, + "UPSERT INTO test_statistics_metadata (id, city) VALUES " + "(1, 'A'), (2, 'B')"); + + SQLCHAR tableName[] = "test_statistics_metadata"; + CHECK_ODBC_OK(SQLStatistics( + stmt, nullptr, 0, nullptr, 0, tableName, SQL_NTS, + SQL_INDEX_ALL, SQL_QUICK), stmt, SQL_HANDLE_STMT); + + ExpectRow(stmt, { + {3, "test_statistics_metadata"}, {4, nullptr}, {6, nullptr}, {7, SQL_TABLE_STAT}, + {8, nullptr}, {9, nullptr}, {10, nullptr}, {11, nullptr}, {12, nullptr}, {13, nullptr}, + }); + const std::array regularIndexColumns{"city", "created"}; + for (size_t i = 0; i < regularIndexColumns.size(); ++i) { + ExpectRow(stmt, { + {4, SQL_TRUE}, {6, "idx_city_created"}, {7, SQL_INDEX_OTHER}, + {8, static_cast(i + 1)}, {9, regularIndexColumns[i]}, + {11, nullptr}, {12, nullptr}, + }); + } + FinishResult(stmt); + + CHECK_ODBC_OK(SQLStatistics( + stmt, nullptr, 0, nullptr, 0, tableName, SQL_NTS, + SQL_INDEX_UNIQUE, SQL_ENSURE), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{7, SQL_TABLE_STAT}, {11, AnyValue}}); + FinishResult(stmt); +} + +TEST(MetadataApi, SQLStatisticsUniqueIndexWhenSupported) { + TMetadataHandles handles; + const SQLHSTMT stmt = handles.Stmt; + + ExecuteAndClose(stmt, "DROP TABLE IF EXISTS test_statistics_unique_metadata"); + const char* createTable = + "CREATE TABLE test_statistics_unique_metadata (" + "id Int32, email Utf8 NOT NULL, city Utf8, " + "INDEX idx_city GLOBAL SYNC ON (city), " + "INDEX idx_email GLOBAL UNIQUE SYNC ON (email), " + "PRIMARY KEY (id))"; + const SQLRETURN rc = SQLExecDirect( + stmt, reinterpret_cast(const_cast(createTable)), SQL_NTS); + if (rc == SQL_ERROR) { + const std::string error = GetOdbcError(stmt, SQL_HANDLE_STMT); + if (error.find("Unique constraint feature is disabled") != std::string::npos) { + GTEST_SKIP() << error; + } + } + CHECK_ODBC_OK(rc, stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFreeStmt(stmt, SQL_CLOSE), SQL_SUCCESS); + + SQLCHAR tableName[] = "test_statistics_unique_metadata"; + CHECK_ODBC_OK(SQLStatistics( + stmt, nullptr, 0, nullptr, 0, tableName, SQL_NTS, + SQL_INDEX_ALL, SQL_QUICK), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{7, SQL_TABLE_STAT}}); + ExpectRow(stmt, {{4, SQL_FALSE}, {6, "idx_email"}, {8, 1}, {9, "email"}}); + ExpectRow(stmt, {{4, SQL_TRUE}, {6, "idx_city"}, {8, 1}, {9, "city"}}); + FinishResult(stmt); + + CHECK_ODBC_OK(SQLStatistics( + stmt, nullptr, 0, nullptr, 0, tableName, SQL_NTS, + SQL_INDEX_UNIQUE, SQL_QUICK), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{7, SQL_TABLE_STAT}}); + ExpectRow(stmt, { + {4, SQL_FALSE}, {6, "idx_email"}, {7, SQL_INDEX_OTHER}, {8, 1}, {9, "email"}, + }); + FinishResult(stmt); +} + +TEST(MetadataApi, RequiredTableArgumentsAndStatisticsOptionsAreValidated) { + TMetadataHandles handles; + const SQLHSTMT stmt = handles.Stmt; + + ExpectError(SQLPrimaryKeys(stmt, nullptr, 0, nullptr, 0, nullptr, 0), stmt, "HY009"); + ExpectError(SQLStatistics( + stmt, nullptr, 0, nullptr, 0, nullptr, 0, SQL_INDEX_ALL, SQL_QUICK), stmt, "HY009"); + + SQLCHAR tableName[] = "not_used"; + ExpectError(SQLStatistics( + stmt, nullptr, 0, nullptr, 0, tableName, SQL_NTS, 99, SQL_QUICK), stmt, "HY100"); + ExpectError(SQLStatistics( + stmt, nullptr, 0, nullptr, 0, tableName, SQL_NTS, SQL_INDEX_ALL, 99), stmt, "HY101"); + + CHECK_ODBC_OK(SQLSetStmtAttr( + stmt, SQL_ATTR_METADATA_ID, (SQLPOINTER)(uintptr_t)SQL_TRUE, 0), + stmt, SQL_HANDLE_STMT); + ExpectError(SQLTables( + stmt, nullptr, 0, nullptr, 0, tableName, SQL_NTS, nullptr, 0), stmt, "HY009"); +} + +TEST(MetadataApi, SQLSpecialColumnsDistinguishesNullAndEmptyArguments) { + TMetadataHandles handles; + const SQLHSTMT stmt = handles.Stmt; + + ExecuteAndClose(stmt, "DROP TABLE IF EXISTS test_special_columns_metadata"); + ExecuteAndClose(stmt, + "CREATE TABLE test_special_columns_metadata (id Int32 NOT NULL, PRIMARY KEY (id))"); + + SQLCHAR tableName[] = "test_special_columns_metadata"; + SQLCHAR catalog[] = "local"; + SQLCHAR empty[] = ""; + ExpectError(SQLSpecialColumns( + stmt, SQL_BEST_ROWID, nullptr, 0, nullptr, 0, nullptr, 0, + SQL_SCOPE_SESSION, SQL_NULLABLE), stmt, "HY009"); + + CHECK_ODBC_OK(SQLSpecialColumns( + stmt, SQL_BEST_ROWID, empty, 0, nullptr, 0, tableName, SQL_NTS, + SQL_SCOPE_SESSION, SQL_NULLABLE), stmt, SQL_HANDLE_STMT); + FinishResult(stmt); + + CHECK_ODBC_OK(SQLSetStmtAttr( + stmt, SQL_ATTR_METADATA_ID, (SQLPOINTER)(uintptr_t)SQL_TRUE, 0), + stmt, SQL_HANDLE_STMT); + ExpectError(SQLSpecialColumns( + stmt, SQL_BEST_ROWID, nullptr, 0, empty, 0, tableName, SQL_NTS, + SQL_SCOPE_SESSION, SQL_NULLABLE), stmt, "HY009"); + ExpectError(SQLSpecialColumns( + stmt, SQL_BEST_ROWID, catalog, SQL_NTS, nullptr, 0, tableName, SQL_NTS, + SQL_SCOPE_SESSION, SQL_NULLABLE), stmt, "HY009"); + + CHECK_ODBC_OK(SQLSpecialColumns( + stmt, SQL_BEST_ROWID, catalog, SQL_NTS, empty, 0, tableName, SQL_NTS, + SQL_SCOPE_SESSION, SQL_NULLABLE), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{2, "id"}}); + FinishResult(stmt); + + CHECK_ODBC_OK(SQLSpecialColumns( + stmt, SQL_BEST_ROWID, catalog, SQL_NTS, empty, 0, tableName, SQL_NTS, + SQL_SCOPE_SESSION, SQL_NO_NULLS), stmt, SQL_HANDLE_STMT); + ExpectRow(stmt, {{2, "id"}}); + FinishResult(stmt); + ExpectError(SQLSpecialColumns( + stmt, SQL_BEST_ROWID, catalog, SQL_NTS, empty, 0, tableName, SQL_NTS, + SQL_SCOPE_SESSION, SQL_NULLABLE_UNKNOWN), stmt, "HY099"); +} diff --git a/odbc/tests/integration/statement_api_it.cpp b/odbc/tests/integration/statement_api_it.cpp new file mode 100644 index 00000000000..11ccc9c5de6 --- /dev/null +++ b/odbc/tests/integration/statement_api_it.cpp @@ -0,0 +1,2216 @@ +#include "test_utils.h" + +#include +#include +#include + +#ifndef SQL_ATTR_METADATA_ID +#define SQL_ATTR_METADATA_ID 10029 +#endif + +namespace { +bool HasLegacyRowCounts(SQLHDBC dbc) { + SQLCHAR version[64] = {}; + EXPECT_EQ(SQLGetInfo(dbc, SQL_DBMS_VER, version, sizeof(version), nullptr), SQL_SUCCESS) + << GetOdbcError(dbc, SQL_HANDLE_DBC); + // This release predates logical affected-row statistics. Keep exact counts + // for every other version so an unsupported new release fails visibly. + return std::strcmp(reinterpret_cast(version), "26.2.1.14") == 0; +} +} + +TEST(StatementApi, AllocFreeStmtHandle) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + ASSERT_EQ(SQLFreeHandle(SQL_HANDLE_STMT, stmt), SQL_SUCCESS); + + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, ParameterCountLimits) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + std::string query = "SELECT ?"; + for (int i = 1; i < std::numeric_limits::max(); ++i) query += ",?"; + ASSERT_EQ(SQLPrepare(stmt, (SQLCHAR*)query.c_str(), SQL_NTS), SQL_SUCCESS); + SQLSMALLINT count = 0; + ASSERT_EQ(SQLNumParams(stmt, &count), SQL_SUCCESS); + EXPECT_EQ(count, std::numeric_limits::max()); + for (const auto& invalid : {query + ",?", std::string("SELECT $p32768"), + std::string("SELECT $p65536"), std::string("SELECT $p999999999999999999999")}) { + EXPECT_EQ(SQLPrepare(stmt, (SQLCHAR*)invalid.c_str(), SQL_NTS), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "HY000")); + EXPECT_EQ(SQLNumParams(stmt, &count), SQL_ERROR); + EXPECT_EQ(SQLExecute(stmt), SQL_ERROR); + ASSERT_EQ(SQLPrepare(stmt, (SQLCHAR*)"SELECT ?", SQL_NTS), SQL_SUCCESS); + ASSERT_EQ(SQLNumParams(stmt, &count), SQL_SUCCESS); + EXPECT_EQ(count, 1); + } + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, ExecDirectSimple) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1 AS value", SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, ExecDirectNestedQueryRepeated) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + const SQLULEN noScanModes[] = {SQL_NOSCAN_OFF, SQL_NOSCAN_ON}; + for (SQLULEN noScan : noScanModes) { + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, + reinterpret_cast(noScan), 0), + stmt, SQL_HANDLE_STMT); + for (int pass = 0; pass < 3; ++pass) { + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"select * from (select 1);", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_NEXT, 1), SQL_SUCCESS); + SQLINTEGER value = 0; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_LONG, &value, sizeof(value), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, 1); + EXPECT_EQ(SQLFetchScroll(stmt, SQL_FETCH_NEXT, 1), SQL_NO_DATA); + CHECK_ODBC_OK(SQLCloseCursor(stmt), stmt, SQL_HANDLE_STMT); + } + } + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, ExecDirectMultipleColumns) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT 1 AS int_col, 'hello'u AS str_col, CAST(3.14 AS Double) AS float_col", + SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, MultipleResults) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLUSMALLINT supported = SQL_FALSE; + CHECK_ODBC_OK(SQLGetFunctions(dbc, SQL_API_SQLMORERESULTS, &supported), + dbc, SQL_HANDLE_DBC); + EXPECT_EQ(supported, SQL_TRUE); + SQLCHAR multipleResults[2] = {}; + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_MULT_RESULT_SETS, multipleResults, + sizeof(multipleResults), nullptr), dbc, SQL_HANDLE_DBC); + EXPECT_STREQ(reinterpret_cast(multipleResults), "Y"); + SQLUINTEGER batchSupport = 0; + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_BATCH_SUPPORT, &batchSupport, + sizeof(batchSupport), nullptr), dbc, SQL_HANDLE_DBC); + EXPECT_NE(batchSupport & SQL_BS_SELECT_EXPLICIT, 0U); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*) + "SELECT 1 AS value UNION ALL SELECT 2 AS value ORDER BY value; " + "SELECT 42 AS value, 'second'u AS label; " + "SELECT 99 AS value UNION ALL SELECT 100 AS value ORDER BY value", + SQL_NTS), stmt, SQL_HANDLE_STMT); + + SQLSMALLINT columns = 0; + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columns), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columns, 1); + SQLLEN rowCount = 0; + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, -1); + SQLINTEGER value = 0; + SQLLEN indicator = 0; + CHECK_ODBC_OK(SQLBindCol(stmt, 1, SQL_C_LONG, &value, sizeof(value), &indicator), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLFetch(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, 1); + + CHECK_ODBC_OK(SQLMoreResults(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columns), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columns, 2); + SQLCHAR columnName[32] = {}; + CHECK_ODBC_OK(SQLDescribeCol(stmt, 2, columnName, sizeof(columnName), nullptr, + nullptr, nullptr, nullptr, nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(reinterpret_cast(columnName), "label"); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, -1); + CHECK_ODBC_OK(SQLFetch(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, 42); // The column binding survives the result transition. + char label[16] = {}; + CHECK_ODBC_OK(SQLGetData(stmt, 2, SQL_C_CHAR, label, sizeof(label), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(label, "second"); + CHECK_ODBC_OK(SQLBindCol(stmt, 2, SQL_C_CHAR, label, sizeof(label), &indicator), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLMoreResults(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columns), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columns, 1); + EXPECT_EQ(SQLFetch(stmt), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "07009")); + CHECK_ODBC_OK(SQLBindCol(stmt, 2, SQL_C_CHAR, nullptr, 0, nullptr), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLFetch(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, 100); + EXPECT_EQ(SQLMoreResults(stmt), SQL_NO_DATA); + EXPECT_EQ(SQLMoreResults(stmt), SQL_NO_DATA); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 7 AS value", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLFetch(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, 7); + EXPECT_EQ(SQLMoreResults(stmt), SQL_NO_DATA); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 10; SELECT 20", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLCloseCursor(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLMoreResults(stmt), SQL_NO_DATA); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 30; SELECT 40", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLCancel(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLMoreResults(stmt), SQL_NO_DATA); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 50; SELECT 60", SQL_NTS), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLExecDirect(stmt, (SQLCHAR*)"INVALID SYNTAX HERE", SQL_NTS), SQL_ERROR); + EXPECT_EQ(SQLMoreResults(stmt), SQL_NO_DATA); + + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*) + "SELECT 1 AS first; SELECT 2 AS second, 3 AS third", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLMoreResults(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLCloseCursor(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columns), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columns, 1); // Prepared metadata remains that of the first result. + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columns), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columns, 1); + EXPECT_EQ(SQLMoreResults(stmt), SQL_SUCCESS); + EXPECT_EQ(SQLMoreResults(stmt), SQL_NO_DATA); + + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, + (SQLPOINTER)SQL_AUTOCOMMIT_OFF, 0), dbc, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1; SELECT 2; SELECT 3", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLMoreResults(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, + (SQLPOINTER)SQL_AUTOCOMMIT_ON, 0), dbc, SQL_HANDLE_DBC); + EXPECT_EQ(SQLMoreResults(stmt), SQL_NO_DATA); + + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, + (SQLPOINTER)SQL_CURSOR_STATIC, 0), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*) + "SELECT value FROM AS_TABLE(AsList(AsStruct(0 AS value))) WHERE value = 1; " + "SELECT CAST(NULL AS Utf8) AS value; SELECT CAST(2 AS Int32) AS value", + SQL_NTS), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + CHECK_ODBC_OK(SQLMoreResults(stmt), stmt, SQL_HANDLE_STMT); + SQLSMALLINT sqlType = 0; + SQLSMALLINT nullable = 0; + CHECK_ODBC_OK(SQLDescribeCol(stmt, 1, columnName, sizeof(columnName), nullptr, &sqlType, + nullptr, nullptr, &nullable), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(sqlType, SQL_VARCHAR); + EXPECT_EQ(nullable, SQL_NULLABLE); + CHECK_ODBC_OK(SQLFetch(stmt), stmt, SQL_HANDLE_STMT); + char nullText[8] = {}; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_CHAR, nullText, sizeof(nullText), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(indicator, SQL_NULL_DATA); + CHECK_ODBC_OK(SQLMoreResults(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLFetch(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, 2); + EXPECT_EQ(SQLMoreResults(stmt), SQL_NO_DATA); + + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT ?; SELECT 2", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLINTEGER param = 1; + SQLLEN paramLength = 0; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, ¶m, 0, ¶mLength), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + paramLength = SQL_DATA_AT_EXEC; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, ¶m, 0, ¶mLength), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLExecute(stmt), SQL_NEED_DATA); + EXPECT_EQ(SQLMoreResults(stmt), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "HY010")); + CHECK_ODBC_OK(SQLCancel(stmt), stmt, SQL_HANDLE_STMT); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, ExecDirectInvalidSyntax) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + ASSERT_EQ(SQLExecDirect(stmt, (SQLCHAR*)"INVALID SYNTAX HERE", SQL_NTS), SQL_ERROR); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, ExecDirectInvalidTable) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + ASSERT_EQ(SQLExecDirect(stmt, (SQLCHAR*)"SELECT * FROM nonexistent_table", SQL_NTS), SQL_ERROR); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, PrepareAndExecuteWithQuestionMarks) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT ? + ? AS result", SQL_NTS), stmt, SQL_HANDLE_STMT); + + SQLINTEGER p1 = 10, p2 = 20; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, &p1, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, &p2, 0, nullptr), stmt, SQL_HANDLE_STMT); + + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + SQLINTEGER result = 0; + SQLLEN resultInd = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &result, 0, &resultInd), SQL_SUCCESS); + ASSERT_EQ(result, 30); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, PrepareAndExecute) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT $p1 + $p2 AS result", SQL_NTS), stmt, SQL_HANDLE_STMT); + + SQLINTEGER p1 = 10, p2 = 20; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, &p1, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, &p2, 0, nullptr), stmt, SQL_HANDLE_STMT); + + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, PrepareAndExecuteReused) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT $p1", SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLINTEGER param; + SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, ¶m, 0, nullptr); + param = 100; + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER result; + SQLGetData(stmt, 1, SQL_C_LONG, &result, 0, nullptr); + ASSERT_EQ(result, 100); + SQLCloseCursor(stmt); + param = 200; + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLGetData(stmt, 1, SQL_C_LONG, &result, 0, nullptr); + ASSERT_EQ(result, 200); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, FetchSingleRow) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 42", SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, FetchMultipleRows) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT * FROM AS_TABLE(ListMap(ListFromRange(1, 4), ($x) -> (AsStruct($x AS a)))) ORDER BY a", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLINTEGER value; + SQLLEN ind; + SQLBindCol(stmt, 1, SQL_C_LONG, &value, 0, &ind); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(value, 1); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(value, 2); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(value, 3); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, BindColMultipleTypes) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 42 AS col1, 'test'u AS col2", SQL_NTS), + stmt, SQL_HANDLE_STMT); + + SQLINTEGER col1; + char col2[64]; + SQLLEN col1Ind, col2Ind; + + SQLBindCol(stmt, 1, SQL_C_LONG, &col1, 0, &col1Ind); + SQLBindCol(stmt, 2, SQL_C_CHAR, col2, sizeof(col2), &col2Ind); + + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(col1, 42); + ASSERT_STREQ(col2, "test"); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, BindColThenGetData) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 100", SQL_NTS), stmt, SQL_HANDLE_STMT); + + SQLINTEGER value; + SQLLEN ind; + SQLBindCol(stmt, 1, SQL_C_LONG, &value, 0, &ind); + + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(value, 100); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, GetDataWithoutBindCol) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 100", SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + SQLINTEGER value; + SQLLEN ind; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &value, 0, &ind), SQL_SUCCESS); + ASSERT_EQ(value, 100); + EXPECT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &value, 0, &ind), SQL_NO_DATA); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, GetDataMultipleColumns) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1, 'hello world'u", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + SQLINTEGER col1; + SQLLEN col1Ind; + SQLGetData(stmt, 1, SQL_C_LONG, &col1, 0, &col1Ind); + ASSERT_EQ(col1, 1); + + char col2[64]; + SQLLEN col2Ind; + SQLGetData(stmt, 2, SQL_C_CHAR, col2, sizeof(col2), &col2Ind); + ASSERT_STREQ(col2, "hello world"); + + // Switching columns restarts their streams; consecutive reads still advance. + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &col1, 0, &col1Ind), SQL_SUCCESS); + char chunk[6]; + ASSERT_EQ(SQLGetData(stmt, 2, SQL_C_CHAR, chunk, sizeof(chunk), &col2Ind), SQL_SUCCESS_WITH_INFO); + EXPECT_STREQ(chunk, "hello"); + EXPECT_EQ(col2Ind, 11); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "01004")); + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &col1, 0, &col1Ind), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 2, SQL_C_CHAR, chunk, sizeof(chunk), &col2Ind), SQL_SUCCESS_WITH_INFO); + EXPECT_STREQ(chunk, "hello"); + ASSERT_EQ(SQLGetData(stmt, 2, SQL_C_CHAR, col2, sizeof(col2), &col2Ind), SQL_SUCCESS); + EXPECT_STREQ(col2, " world"); + EXPECT_EQ(col2Ind, 6); + EXPECT_EQ(SQLGetData(stmt, 2, SQL_C_CHAR, col2, sizeof(col2), &col2Ind), SQL_NO_DATA); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, TemporalBindingsWithoutDescribeParam) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQL_DATE_STRUCT date{1960, 2, 29}; + SQL_TIMESTAMP_STRUCT timestamp{1960, 2, 29, 12, 0, 0, 123456000}; + SQLLEN dateLength = sizeof(date), timestampLength = sizeof(timestamp); + for (const std::string timestampType : {"Timestamp64", "Datetime64", "Timestamp"}) { + const bool wide = timestampType != "Timestamp"; + // YDB 26.2.1.14 caches stale metadata when one table is recreated with different types. + const std::string table = "temporal_binding_" + timestampType + "_test"; + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*) + ("DROP TABLE IF EXISTS " + table).c_str(), SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)("CREATE TABLE " + table + + "(d " + (wide ? "Date32" : "Date") + ", ts " + timestampType + ", PRIMARY KEY(d))").c_str(), SQL_NTS), + stmt, SQL_HANDLE_STMT); + date.year = timestamp.year = wide ? 1960 : 2024; + timestamp.fraction = timestampType == "Datetime64" ? 0 : 123456000; + const std::string insert = "INSERT INTO " + table + "(d,ts) VALUES(?,?)"; + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)insert.c_str(), SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TYPE_DATE, SQL_TYPE_DATE, + 10, 0, &date, sizeof(date), &dateLength), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_TYPE_TIMESTAMP, SQL_TYPE_TIMESTAMP, + 26, 6, ×tamp, sizeof(timestamp), ×tampLength), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*) + ("SELECT d,ts FROM " + table).c_str(), SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQL_DATE_STRUCT actualDate{}; + SQL_TIMESTAMP_STRUCT actualTimestamp{}; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_TYPE_DATE, &actualDate, sizeof(actualDate), nullptr), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLGetData(stmt, 2, SQL_C_TYPE_TIMESTAMP, &actualTimestamp, sizeof(actualTimestamp), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(actualDate.year, date.year); + EXPECT_EQ(actualDate.month, date.month); + EXPECT_EQ(actualDate.day, date.day); + EXPECT_EQ(actualTimestamp.year, timestamp.year); + EXPECT_EQ(actualTimestamp.fraction, timestamp.fraction); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLFreeStmt(stmt, SQL_RESET_PARAMS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)insert.c_str(), SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLSMALLINT type = SQL_UNKNOWN_TYPE, scale = -1; + CHECK_ODBC_OK(SQLDescribeParam(stmt, 2, &type, nullptr, &scale, nullptr), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(type, SQL_TYPE_TIMESTAMP); + EXPECT_EQ(scale, timestampType == "Datetime64" ? 0 : 6); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*) + ("DROP TABLE " + table).c_str(), SQL_NTS), stmt, SQL_HANDLE_STMT); + } + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, CloseCursor) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1", SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLCloseCursor(stmt), stmt, SQL_HANDLE_STMT); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, FreeStmtClose) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1", SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLFreeStmt(stmt, SQL_CLOSE), stmt, SQL_HANDLE_STMT); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, FreeStmtResetParams) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLINTEGER param = 42; + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT ?", SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(BindIntParam(stmt, 1, ¶m), stmt, SQL_HANDLE_STMT); + + CHECK_ODBC_OK(SQLFreeStmt(stmt, SQL_RESET_PARAMS), stmt, SQL_HANDLE_STMT); + for (SQLINTEGER attr : {SQL_ATTR_APP_PARAM_DESC, SQL_ATTR_IMP_PARAM_DESC}) { + SQLHDESC desc = SQL_NULL_HDESC; + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, attr, &desc, sizeof(desc), nullptr), stmt, SQL_HANDLE_STMT); + SQLSMALLINT count = -1; + CHECK_ODBC_OK(SQLGetDescField(desc, 0, SQL_DESC_COUNT, &count, 0, nullptr), desc, SQL_HANDLE_DESC); + EXPECT_EQ(count, 0); + } + CHECK_ODBC_OK(BindIntParam(stmt, 1, ¶m), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(FetchIntResult(stmt), param); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, NumResultCols) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1, 2, 3, 4, 5", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLSMALLINT numCols; + CHECK_ODBC_OK(SQLNumResultCols(stmt, &numCols), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(numCols, 5); + SQLFetch(stmt); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, PreparedResultMetadataBeforeExecute) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLExecDirect(stmt, + (SQLCHAR*)"DROP TABLE IF EXISTS result_metadata_before_execute_test", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"PRAGMA TablePathPrefix = \"/local\";\n" + "CREATE TABLE result_metadata_before_execute_test (" + "id Int64 NOT NULL, name Utf8, PRIMARY KEY (id))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"INSERT INTO result_metadata_before_execute_test (id, name) " + "VALUES (7, 'expected')", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + + // Inspecting a prepared data-modification statement must not execute it. + CHECK_ODBC_OK(SQLPrepare(stmt, + (SQLCHAR*)"UPSERT INTO result_metadata_before_execute_test (id, name) " + "VALUES (1, 'unexpected')", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLSMALLINT columnCount = -1; + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columnCount, 0); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT COUNT(*) FROM result_metadata_before_execute_test WHERE id = 1", + SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLBIGINT rowCount = -1; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_SBIGINT, &rowCount, sizeof(rowCount), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, 0); + SQLFreeStmt(stmt, SQL_CLOSE); + + // Metadata inspection must not run an earlier executable statement in a batch. + CHECK_ODBC_OK(SQLPrepare(stmt, + (SQLCHAR*)"DELETE FROM result_metadata_before_execute_test WHERE id = 7; " + "SELECT * FROM result_metadata_before_execute_test", + SQL_NTS), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLNumResultCols(stmt, &columnCount), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "HYC00")); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT COUNT(*) FROM result_metadata_before_execute_test WHERE id = 7", + SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_SBIGINT, &rowCount, sizeof(rowCount), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, 1); + SQLFreeStmt(stmt, SQL_CLOSE); + + // Applications commonly inspect a prepared zero-row query before execution. + CHECK_ODBC_OK(SQLPrepare(stmt, + (SQLCHAR*)"SELECT id AS z, name AS a FROM `result_metadata_before_execute_test` " + "WHERE ( 0 = 1 )", + SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(columnCount, 2); + + char columnName[32] = {}; + SQLSMALLINT nameLength = 0; + SQLSMALLINT dataType = SQL_UNKNOWN_TYPE; + SQLULEN columnSize = 0; + SQLSMALLINT decimalDigits = 0; + SQLSMALLINT nullable = SQL_NULLABLE_UNKNOWN; + CHECK_ODBC_OK(SQLDescribeCol( + stmt, 1, reinterpret_cast(columnName), sizeof(columnName), &nameLength, + &dataType, &columnSize, &decimalDigits, &nullable), stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(columnName, "z"); + EXPECT_EQ(dataType, SQL_BIGINT); + EXPECT_EQ(nullable, SQL_NO_NULLS); + CHECK_ODBC_OK(SQLDescribeCol( + stmt, 2, reinterpret_cast(columnName), sizeof(columnName), &nameLength, + &dataType, &columnSize, &decimalDigits, &nullable), stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(columnName, "a"); + EXPECT_EQ(dataType, SQL_VARCHAR); + EXPECT_EQ(nullable, SQL_NULLABLE); + + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + + // The same pre-execution metadata path must lead to real rows when the + // prepared physical-table query is executed. + CHECK_ODBC_OK(SQLPrepare(stmt, + (SQLCHAR*)"SELECT * FROM result_metadata_before_execute_test", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(columnCount, 2); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLBIGINT id = 0; + char name[32] = {}; + SQLLEN indicator = 0; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_SBIGINT, &id, sizeof(id), &indicator), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLGetData(stmt, 2, SQL_C_CHAR, name, sizeof(name), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(id, 7); + EXPECT_STREQ(name, "expected"); + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + + // A terminal semicolon must be removed only from the metadata wrapper; + // the original nested SELECT is still executed unchanged afterwards. + CHECK_ODBC_OK(SQLPrepare(stmt, + (SQLCHAR*)"select * from (select 1 as value);", SQL_NTS), + stmt, SQL_HANDLE_STMT); + // iODBC caches the implicit descriptor handle at statement allocation and + // answers SQLGetStmtAttr from that proxy without calling the driver again. + // Discover the lazy schema through SQLNumResultCols before inspecting the + // same driver's implementation descriptor through the proxy. + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(columnCount, 1); + SQLHDESC ird = SQL_NULL_HDESC; + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_IMP_ROW_DESC, &ird, 0, nullptr), + stmt, SQL_HANDLE_STMT); + SQLSMALLINT descriptorCount = 0; + CHECK_ODBC_OK(SQLGetDescField( + ird, 0, SQL_DESC_COUNT, &descriptorCount, 0, nullptr), ird, SQL_HANDLE_DESC); + EXPECT_EQ(descriptorCount, 1); + std::memset(columnName, 0, sizeof(columnName)); + CHECK_ODBC_OK(SQLDescribeCol( + stmt, 1, reinterpret_cast(columnName), sizeof(columnName), &nameLength, + &dataType, &columnSize, &decimalDigits, &nullable), stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(columnName, "value"); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER value = 0; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_LONG, &value, sizeof(value), nullptr), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, 1); + SQLFreeStmt(stmt, SQL_CLOSE); + + for (const char* query : { + "SELECT 1 AS value; -- trailing line comment", + "SELECT 1 AS value; /* trailing block comment */", + "PRAGMA TablePathPrefix = \"/local\"; SELECT 1 AS value; -- prologue", + "$rows = (SELECT 1 AS value); SELECT * FROM $rows;", + "SELECT 'can\\'t; stop' AS value; -- escaped quote"}) { + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)query, SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columnCount, 1); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLFreeStmt(stmt, SQL_CLOSE); + } + + // Metadata fallback must not consume application parameter values before + // execution. Parameterized SELECTs remain unsupported until YDB provides + // a compile-only result-schema API. + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT ? AS value", SQL_NTS), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLNumResultCols(stmt, &columnCount), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "HYC00")); + SQLINTEGER parameter = 1; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, ¶meter, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLCloseCursor(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columnCount, 1); + CHECK_ODBC_OK(SQLFreeStmt(stmt, SQL_RESET_PARAMS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columnCount, 1); + EXPECT_EQ(SQLBindParameter(stmt, 1, SQL_PARAM_OUTPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, ¶meter, 0, nullptr), SQL_ERROR); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columnCount, 1); + SQLUSMALLINT paramStatus = SQL_PARAM_UNUSED; + SQLULEN paramsProcessed = 0; + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_PARAM_STATUS_PTR, ¶mStatus, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, ¶msProcessed, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columnCount, 1); + SQLHDESC apd = SQL_NULL_HDESC; + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_APP_PARAM_DESC, &apd, 0, nullptr), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetDescField(apd, 1, SQL_DESC_CONCISE_TYPE, + (SQLPOINTER)SQL_C_ULONG, 0), apd, SQL_HANDLE_DESC); + EXPECT_EQ(SQLNumResultCols(stmt, &columnCount), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "HYC00")); + + SQLUINTEGER unsignedParameter = 1; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, + 0, 0, &unsignedParameter, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLCloseCursor(stmt), stmt, SQL_HANDLE_STMT); + SQLHDESC explicitApd = SQL_NULL_HDESC; + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DESC, dbc, &explicitApd), SQL_SUCCESS); + CHECK_ODBC_OK(SQLCopyDesc(apd, explicitApd), apd, SQL_HANDLE_DESC); + CHECK_ODBC_OK(SQLSetDescField(explicitApd, 1, SQL_DESC_CONCISE_TYPE, + (SQLPOINTER)SQL_C_LONG, 0), explicitApd, SQL_HANDLE_DESC); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_APP_PARAM_DESC, explicitApd, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLCloseCursor(stmt), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFreeHandle(SQL_HANDLE_DESC, explicitApd), SQL_SUCCESS); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columnCount, 1); + + // Executing a catalog function cancels an older prepared statement and + // its cached schema instead of allowing stale SQLExecute state to survive. + CHECK_ODBC_OK(SQLPrepare(stmt, + (SQLCHAR*)"SELECT * FROM result_metadata_before_execute_test", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(columnCount, 2); + CHECK_ODBC_OK(SQLTables(stmt, nullptr, 0, nullptr, 0, + (SQLCHAR*)"result_metadata_before_execute_test", SQL_NTS, + (SQLCHAR*)"TABLE", SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLFreeStmt(stmt, SQL_CLOSE); + EXPECT_EQ(SQLExecute(stmt), SQL_ERROR); + const std::string executeError = GetOdbcError(stmt, SQL_HANDLE_STMT); + EXPECT_TRUE(SqlStatePrefix(executeError, "HY007") || SqlStatePrefix(executeError, "HY010")) + << executeError; + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"DROP TABLE result_metadata_before_execute_test", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, PreparedResultMetadataTracksCurrentCatalog) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLExecDirect(stmt, + (SQLCHAR*)"DROP TABLE IF EXISTS `/local/cat_a/prepared_catalog_metadata`", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + SQLExecDirect(stmt, + (SQLCHAR*)"DROP TABLE IF EXISTS `/local/cat_b/prepared_catalog_metadata`", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE `/local/cat_a/prepared_catalog_metadata` (" + "id Int32 NOT NULL, a_value Utf8, PRIMARY KEY (id))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE `/local/cat_b/prepared_catalog_metadata` (" + "id Int32 NOT NULL, b_value Int64, extra Bool, PRIMARY KEY (id))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLSetConnectAttr( + dbc, SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER)"/local/cat_a", SQL_NTS), + dbc, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLPrepare(stmt, + (SQLCHAR*)"--!ansi_lexer\nSELECT a.* FROM prepared_catalog_metadata AS a, " + "prepared_catalog_metadata AS b WHERE a.\"id\" = b.\"id\"", SQL_NTS), + stmt, SQL_HANDLE_STMT); + + SQLSMALLINT columnCount = 0; + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(columnCount, 2); + char columnName[32] = {}; + SQLSMALLINT nameLength = 0; + SQLSMALLINT dataType = SQL_UNKNOWN_TYPE; + SQLULEN columnSize = 0; + SQLSMALLINT decimalDigits = 0; + SQLSMALLINT nullable = SQL_NULLABLE_UNKNOWN; + bool sawAValue = false; + for (SQLUSMALLINT column = 1; column <= columnCount; ++column) { + std::memset(columnName, 0, sizeof(columnName)); + CHECK_ODBC_OK(SQLDescribeCol( + stmt, column, reinterpret_cast(columnName), sizeof(columnName), &nameLength, + &dataType, &columnSize, &decimalDigits, &nullable), stmt, SQL_HANDLE_STMT); + if (std::strcmp(columnName, "a_value") == 0) { + sawAValue = true; + EXPECT_EQ(dataType, SQL_VARCHAR); + } + } + EXPECT_TRUE(sawAValue); + + CHECK_ODBC_OK(SQLSetConnectAttr( + dbc, SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER)"/local/cat_b", SQL_NTS), + dbc, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(columnCount, 3); + bool sawBValue = false; + for (SQLUSMALLINT column = 1; column <= columnCount; ++column) { + std::memset(columnName, 0, sizeof(columnName)); + CHECK_ODBC_OK(SQLDescribeCol( + stmt, column, reinterpret_cast(columnName), sizeof(columnName), &nameLength, + &dataType, &columnSize, &decimalDigits, &nullable), stmt, SQL_HANDLE_STMT); + if (std::strcmp(columnName, "b_value") == 0) { + sawBValue = true; + EXPECT_EQ(dataType, SQL_BIGINT); + } + } + EXPECT_TRUE(sawBValue); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLSetConnectAttr( + dbc, SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER)"/local", SQL_NTS), + dbc, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"DROP TABLE `/local/cat_a/prepared_catalog_metadata`", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"DROP TABLE `/local/cat_b/prepared_catalog_metadata`", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, RowCount) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + const bool legacyCounts = HasLegacyRowCounts(dbc); + + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS row_count_test", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE row_count_test (id Int32, value Int32, " + "INDEX by_value GLOBAL ON (value), PRIMARY KEY (id))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + + SQLLEN rowCount = -2; + SQLSMALLINT resultColumns = -1; + CHECK_ODBC_OK(SQLNumResultCols(stmt, &resultColumns), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(resultColumns, 0); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, -1); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"UPSERT INTO row_count_test (id, value) VALUES (1, 10), (2, 20), (3, 30)", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLLEN diagRowCount = -2; + CHECK_ODBC_OK(SQLGetDiagField(SQL_HANDLE_STMT, stmt, 0, SQL_DIAG_ROW_COUNT, + &diagRowCount, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &resultColumns), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(resultColumns, 0); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, legacyCounts ? -1 : 3); + EXPECT_EQ(diagRowCount, rowCount); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"UPDATE row_count_test SET value = value + 1 WHERE id <= 2", + SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, legacyCounts ? -1 : 2); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"DELETE FROM row_count_test WHERE id = 3", + SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, legacyCounts ? -1 : 1); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"DELETE FROM row_count_test WHERE id = 100", + SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, legacyCounts ? -1 : 0); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"UPDATE row_count_test SET value = 0 WHERE id = 100", + SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, legacyCounts ? -1 : 0); + SQLFreeStmt(stmt, SQL_CLOSE); + + for (const char* query : { + "UPDATE row_count_test SET value = 0 WHERE NOT(1 = 1)", + "DELETE FROM row_count_test WHERE NOT(1 = 1)"}) { + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)query, SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, 0); + SQLFreeStmt(stmt, SQL_CLOSE); + } + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"PRAGMA TablePathPrefix = \"/local\";\n" + "UPDATE row_count_test SET value = value + 1 WHERE id = 1", + SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, legacyCounts ? -1 : 1); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLPrepare(stmt, + (SQLCHAR*)"DECLARE $p1 AS Int32? /* nullable */;\n" + "UPDATE row_count_test SET value = value + 1 WHERE id = $p1", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLINTEGER nativeId = 2; + SQLLEN nativeIdLength = 0; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, &nativeId, 0, &nativeIdLength), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, legacyCounts ? -1 : 1); + SQLFreeStmt(stmt, SQL_RESET_PARAMS); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT * FROM row_count_test", + SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, -1); + + SQLFreeStmt(stmt, SQL_CLOSE); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE row_count_test", SQL_NTS); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, ParameterArrays) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + const bool legacyCounts = HasLegacyRowCounts(dbc); + + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS row_count_param_test", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE row_count_param_test (id Int32, value Int32, PRIMARY KEY (id))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLPrepare(stmt, + (SQLCHAR*)"declare /* key */ $p1 as Int32;\n" + "DECLARE $p2 AS Int32;\n" + "UPSERT INTO row_count_param_test (id, value) VALUES ($p1, $p2)", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLINTEGER ids[] = {1, 2, 3}; + SQLINTEGER values[] = {10, 20, 30}; + SQLLEN idLengths[] = {0, 0, 0}; + SQLLEN valueLengths[] = {0, 0, 0}; + SQLUSMALLINT operations[] = {SQL_PARAM_PROCEED, SQL_PARAM_IGNORE, SQL_PARAM_PROCEED}; + SQLUSMALLINT statuses[] = {SQL_PARAM_UNUSED, SQL_PARAM_UNUSED, SQL_PARAM_UNUSED}; + SQLULEN processed = 0; + + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_PARAMSET_SIZE, + reinterpret_cast(3), 0), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_PARAM_OPERATION_PTR, + operations, 0), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_PARAM_STATUS_PTR, + statuses, 0), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, + &processed, 0), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, ids, 0, idLengths), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, values, 0, valueLengths), stmt, SQL_HANDLE_STMT); + + idLengths[2] = SQL_DATA_AT_EXEC; + EXPECT_EQ(SQLExecute(stmt), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "HYC00")); + EXPECT_EQ(processed, 0); + idLengths[2] = 0; + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + SQLLEN rowCount = -1; + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, legacyCounts ? -1 : 2); + EXPECT_EQ(processed, 3); + EXPECT_EQ(statuses[0], SQL_PARAM_SUCCESS); + EXPECT_EQ(statuses[1], SQL_PARAM_UNUSED); + EXPECT_EQ(statuses[2], SQL_PARAM_SUCCESS); + + SQLFreeStmt(stmt, SQL_CLOSE); + SQLFreeStmt(stmt, SQL_RESET_PARAMS); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"DELETE FROM row_count_param_test WHERE id = ?", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ids[2] = 100; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, ids, 0, idLengths), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, legacyCounts ? -1 : 1); + EXPECT_EQ(processed, 3); + EXPECT_EQ(statuses[0], SQL_PARAM_SUCCESS); + EXPECT_EQ(statuses[1], SQL_PARAM_UNUSED); + EXPECT_EQ(statuses[2], SQL_PARAM_SUCCESS); + + SQLFreeStmt(stmt, SQL_CLOSE); + SQLFreeStmt(stmt, SQL_RESET_PARAMS); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*) + "SELECT CASE WHEN (? = 1) THEN 1.5 ELSE 2.5 END AS value", SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLSMALLINT type = SQL_UNKNOWN_TYPE; + CHECK_ODBC_OK(SQLDescribeParam(stmt, 1, &type, nullptr, nullptr, nullptr), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(type, SQL_INTEGER); + idLengths[2] = SQL_NULL_DATA; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, type, + 0, 0, ids, 0, idLengths), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLRowCount(stmt, &rowCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(rowCount, -1); + EXPECT_EQ(processed, 3); + EXPECT_EQ(statuses[0], SQL_PARAM_SUCCESS); + EXPECT_EQ(statuses[1], SQL_PARAM_UNUSED); + EXPECT_EQ(statuses[2], SQL_PARAM_SUCCESS); + SQLUINTEGER arraySelects = 0; + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_PARAM_ARRAY_SELECTS, &arraySelects, 0, nullptr), dbc, SQL_HANDLE_DBC); + EXPECT_EQ(arraySelects, SQL_PAS_BATCH); + for (double expected : {1.5, 2.5}) { + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + double value = 0; + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_DOUBLE, &value, sizeof(value), nullptr), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(value, expected); + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + EXPECT_EQ(SQLMoreResults(stmt), expected == 1.5 ? SQL_SUCCESS : SQL_NO_DATA); + } + + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*)"SELECT ? + 0", SQL_NTS), stmt, SQL_HANDLE_STMT); + operations[0] = SQL_PARAM_IGNORE; + operations[1] = SQL_PARAM_PROCEED; + char numbers[][8] = {"ignored", "1", "bad"}; + SQLLEN lengths[] = {SQL_DATA_AT_EXEC, SQL_NTS, SQL_NTS}; + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_INTEGER, + 10, 0, numbers, sizeof(numbers[0]), lengths), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLExecute(stmt), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "22018")); + EXPECT_EQ(statuses[0], SQL_PARAM_UNUSED); + EXPECT_EQ(statuses[1], SQL_PARAM_SUCCESS); + EXPECT_EQ(statuses[2], SQL_PARAM_ERROR); + EXPECT_EQ(processed, 3); + EXPECT_EQ(SQLMoreResults(stmt), SQL_NO_DATA); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_PARAM_OPERATION_PTR, nullptr, 0), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_RESET_PARAMS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE row_count_param_test", SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, PreparedInsertUsesPerSetParameterNullability) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLExecDirect(stmt, + (SQLCHAR*)"DROP TABLE IF EXISTS prepared_insert_nullability_test", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE prepared_insert_nullability_test (" + "id Int64 NOT NULL, name Utf8, uid Uuid, u Uint64, dt Datetime, j Json, PRIMARY KEY (id))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + + SQLHDESC app; + SQLINTEGER placeholder = 0; + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_APP_PARAM_DESC, &app, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetDescRec(app, 1, SQL_C_LONG, 0, 0, 0, 0, &placeholder, nullptr, nullptr), app, SQL_HANDLE_DESC); + CHECK_ODBC_OK(SQLPrepare(stmt, + (SQLCHAR*)"INSERT INTO prepared_insert_nullability_test (id, name) VALUES (?, ?)", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLSMALLINT idType = SQL_UNKNOWN_TYPE, nameType = SQL_UNKNOWN_TYPE, nullable = SQL_NULLABLE_UNKNOWN; + CHECK_ODBC_OK(SQLDescribeParam(stmt, 1, &idType, nullptr, nullptr, &nullable), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(idType, SQL_BIGINT); + EXPECT_EQ(nullable, SQL_NO_NULLS); + CHECK_ODBC_OK(SQLDescribeParam(stmt, 2, &nameType, nullptr, nullptr, &nullable), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(nameType, SQL_VARCHAR); + EXPECT_EQ(nullable, SQL_NULLABLE); + SQLHDESC imp; + CHECK_ODBC_OK(SQLGetStmtAttr(stmt, SQL_ATTR_IMP_PARAM_DESC, &imp, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetDescField(imp, 1, SQL_DESC_NAME, (SQLPOINTER)"id", SQL_NTS), imp, SQL_HANDLE_DESC); + CHECK_ODBC_OK(SQLCopyDesc(imp, imp), imp, SQL_HANDLE_DESC); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*) + "INSERT INTO prepared_insert_nullability_test (name, id) VALUES (?, ?)", SQL_NTS), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLDescribeParam(stmt, 1, &nameType, nullptr, nullptr, nullptr), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(nameType, SQL_VARCHAR); + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*) + "INSERT INTO prepared_insert_nullability_test (id, uid, u, dt, j) VALUES (1, ?, ?, ?, ?)", + SQL_NTS), stmt, SQL_HANDLE_STMT); + for (SQLUSMALLINT i = 1; i <= 4; ++i) { + EXPECT_EQ(SQLDescribeParam(stmt, i, &nameType, nullptr, nullptr, nullptr), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "HYC00")); + } + CHECK_ODBC_OK(SQLPrepare(stmt, (SQLCHAR*) + "INSERT INTO prepared_insert_nullability_test (id, name) VALUES (?, ?)", SQL_NTS), stmt, SQL_HANDLE_STMT); + char ids[][2] = {"1", "2"}; + char names[][16] = {"alpha", "ignored"}; + SQLLEN idLengths[] = {1, 1}; + SQLLEN nameLengths[] = {5, SQL_NULL_DATA}; + SQLUSMALLINT statuses[] = {SQL_PARAM_UNUSED, SQL_PARAM_UNUSED}; + SQLULEN processed = 0; + + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_PARAMSET_SIZE, + reinterpret_cast(2), 0), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_PARAM_STATUS_PTR, + statuses, 0), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, + &processed, 0), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, + SQL_C_CHAR, idType, 19, 0, ids, sizeof(ids[0]), idLengths), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, + SQL_C_CHAR, nameType, 16, 0, names, sizeof(names[0]), nameLengths), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(processed, 2); + EXPECT_EQ(statuses[0], SQL_PARAM_SUCCESS); + EXPECT_EQ(statuses[1], SQL_PARAM_SUCCESS); + SQLFreeStmt(stmt, SQL_RESET_PARAMS); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT id, name FROM prepared_insert_nullability_test ORDER BY id", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLBIGINT id = 0; + char name[16] = {}; + SQLLEN indicator = 0; + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_SBIGINT, &id, sizeof(id), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(id, 1); + CHECK_ODBC_OK(SQLGetData(stmt, 2, SQL_C_CHAR, name, sizeof(name), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_STREQ(name, "alpha"); + + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLGetData(stmt, 1, SQL_C_SBIGINT, &id, sizeof(id), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(id, 2); + CHECK_ODBC_OK(SQLGetData(stmt, 2, SQL_C_CHAR, name, sizeof(name), &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(indicator, SQL_NULL_DATA); + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"DROP TABLE prepared_insert_nullability_test", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, AttrQueryTimeout) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLUINTEGER timeoutSec = 1; + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_QUERY_TIMEOUT, (SQLPOINTER)(uintptr_t)timeoutSec, 0), + stmt, SQL_HANDLE_STMT); + + SQLCHAR longQuery[] = + "SELECT COUNT(*) FROM AS_TABLE(ListMap(ListFromRange(1u, 100000000u), ($x)->(AsStruct($x AS v))))"; + ASSERT_EQ(SQLExecDirect(stmt, longQuery, SQL_NTS), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "HYT00")); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, AttrMaxRows) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_max_rows", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"CREATE TABLE test_max_rows (id Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"UPSERT INTO test_max_rows (id) VALUES (1), (2)", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + const SQLULEN maxRows = 1; + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_MAX_ROWS, (SQLPOINTER)(uintptr_t)maxRows, 0), + stmt, SQL_HANDLE_STMT); + SQLULEN maxRowsOut; + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_MAX_ROWS, &maxRowsOut, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(maxRowsOut, maxRows); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT id FROM test_max_rows ORDER BY id", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, AttrNoScan) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLCHAR selectEscapeFnQuery[] = "SELECT {fn ABS(-12)} AS value"; + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, (SQLPOINTER)SQL_NOSCAN_OFF, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLPrepare(stmt, selectEscapeFnQuery, SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLSMALLINT columnCount = 0; + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columnCount, 1); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, (SQLPOINTER)SQL_NOSCAN_ON, 0), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLNumResultCols(stmt, &columnCount), SQL_ERROR); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, (SQLPOINTER)SQL_NOSCAN_OFF, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLNumResultCols(stmt, &columnCount), stmt, SQL_HANDLE_STMT); + EXPECT_EQ(columnCount, 1); + CHECK_ODBC_OK(SQLExecDirect(stmt, selectEscapeFnQuery, SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER valueInt = 0; + SQLLEN valueInd = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &valueInt, 0, &valueInd), SQL_SUCCESS); + ASSERT_EQ(valueInt, 12); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, (SQLPOINTER)SQL_NOSCAN_ON, 0), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLExecDirect(stmt, selectEscapeFnQuery, SQL_NTS), SQL_ERROR); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, EscapeSequenceConvert) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, (SQLPOINTER)SQL_NOSCAN_OFF, 0), + stmt, SQL_HANDLE_STMT); + + SQLCHAR convertQuery[] = "SELECT {fn CONVERT(42, SQL_SMALLINT)} AS value"; + CHECK_ODBC_OK(SQLExecDirect(stmt, convertQuery, SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLSMALLINT valueSmall = 0; + SQLLEN valueInd = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_SSHORT, &valueSmall, 0, &valueInd), SQL_SUCCESS); + ASSERT_EQ(valueSmall, 42); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, EscapeSequenceDouble) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, (SQLPOINTER)SQL_NOSCAN_OFF, 0), + stmt, SQL_HANDLE_STMT); + + SQLCHAR convertDoubleQuery[] = "SELECT {fn CONVERT(2.5, SQL_DOUBLE)} AS value"; + CHECK_ODBC_OK(SQLExecDirect(stmt, convertDoubleQuery, SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + double valueDouble = 0; + SQLLEN valueInd = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_DOUBLE, &valueDouble, 0, &valueInd), SQL_SUCCESS); + ASSERT_LT(std::fabs(valueDouble - 2.5), 1e-9); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, EscapeSequenceNested) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, (SQLPOINTER)SQL_NOSCAN_OFF, 0), + stmt, SQL_HANDLE_STMT); + + SQLCHAR nestedFnQuery[] = "SELECT {fn {fn ABS(-10)}} AS value"; + CHECK_ODBC_OK(SQLExecDirect(stmt, nestedFnQuery, SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER valueInt = 0; + SQLLEN valueInd = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &valueInt, 0, &valueInd), SQL_SUCCESS); + ASSERT_EQ(valueInt, 10); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, EscapeSequenceString) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, (SQLPOINTER)SQL_NOSCAN_OFF, 0), + stmt, SQL_HANDLE_STMT); + + SQLCHAR asciiLowerQuery[] = "SELECT {fn String::AsciiToLower('AbC'u)} AS value"; + CHECK_ODBC_OK(SQLExecDirect(stmt, asciiLowerQuery, SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + char buf[32] = {}; + SQLLEN valueInd = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_CHAR, buf, sizeof(buf), &valueInd), SQL_SUCCESS); + ASSERT_STREQ(buf, "616263"); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, EscapeSequenceDate) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, (SQLPOINTER)SQL_NOSCAN_OFF, 0), + stmt, SQL_HANDLE_STMT); + + SQLCHAR dateQuery[] = "SELECT {d '2024-06-15'} AS value"; + CHECK_ODBC_OK(SQLExecDirect(stmt, dateQuery, SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + char buf[32] = {}; + SQLLEN valueInd = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_CHAR, buf, sizeof(buf), &valueInd), SQL_SUCCESS); + ASSERT_STREQ(buf, "2024-06-15"); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, EscapeSequenceTimestamp) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_NOSCAN, (SQLPOINTER)SQL_NOSCAN_OFF, 0), + stmt, SQL_HANDLE_STMT); + + SQLCHAR tsQuery[] = "SELECT {ts '2024-06-15 14:30:00'} AS value"; + CHECK_ODBC_OK(SQLExecDirect(stmt, tsQuery, SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + char buf[64] = {}; + SQLLEN valueInd = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_CHAR, buf, sizeof(buf), &valueInd), SQL_SUCCESS); + ASSERT_STREQ(buf, "2024-06-15 14:30:00"); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, CurrentUtcTimestampConversion) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLExecDirect(stmt, + (SQLCHAR*)"DROP TABLE IF EXISTS test_current_timestamp_conversion", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_current_timestamp_conversion (" + "id Int32, value Timestamp, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"INSERT INTO test_current_timestamp_conversion (id, value) " + "VALUES (1, CurrentUtcTimestamp())", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT id, value FROM test_current_timestamp_conversion WHERE id = 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + + SQLCHAR columnName[32] = {}; + SQLSMALLINT nameLength = 0; + SQLSMALLINT dataType = 0; + SQLULEN columnSize = 0; + SQLSMALLINT decimalDigits = 0; + SQLSMALLINT nullable = 0; + CHECK_ODBC_OK(SQLDescribeCol(stmt, 2, columnName, sizeof(columnName), &nameLength, + &dataType, &columnSize, &decimalDigits, &nullable), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(dataType, SQL_TYPE_TIMESTAMP); + + SQL_TIMESTAMP_STRUCT value{}; + SQLLEN indicator = 0; + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLGetData(stmt, 2, SQL_C_TIMESTAMP, &value, 0, &indicator), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(indicator, static_cast(sizeof(value))); + EXPECT_GE(value.year, 2026); + EXPECT_GE(value.month, 1); + EXPECT_LE(value.month, 12); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, NumericOutOfRange) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT CAST(3000000000 AS Uint64) AS v", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER value = 0; + SQLLEN indicator = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &value, sizeof(value), &indicator), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "22003")); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, UpsertAutocommitPersist) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_upsert_persist", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_upsert_persist (id Int32, val Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"UPSERT INTO test_upsert_persist (id, val) VALUES (1, 42)", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT val FROM test_upsert_persist WHERE id = 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER val = 0; + SQLLEN ind = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &val, sizeof(val), &ind), SQL_SUCCESS); + ASSERT_EQ(val, 42); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, SqlCBit) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT true AS b", SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + char bitVal = 0; + SQLLEN ind = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_BIT, &bitVal, sizeof(bitVal), &ind), SQL_SUCCESS); + ASSERT_EQ(bitVal, 1); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT false AS b", SQL_NTS), stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_BIT, &bitVal, sizeof(bitVal), &ind), SQL_SUCCESS); + ASSERT_EQ(bitVal, 0); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, CoreBoundTypeConversions) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; +#ifdef ODBC_TEST_IODBC + AllocEnv(&env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS); + const SQLRETURN connectRc = SQLDriverConnect( + dbc, nullptr, + reinterpret_cast(const_cast(kIodbcWideInteropConnStr)), SQL_NTS, + nullptr, 0, nullptr, SQL_DRIVER_NOPROMPT); + CHECK_ODBC_OK(connectRc, dbc, SQL_HANDLE_DBC); +#else + AllocEnvAndConnect(&env, &dbc); +#endif + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, + (SQLPOINTER)SQL_CURSOR_STATIC, 0), + stmt, SQL_HANDLE_STMT); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_bound_types", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + // Keep this server-backed test on YDB's default decimal shape, which does + // not require support for non-default parameterized decimals. + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"CREATE TABLE test_bound_types (" + "id Int32, u64 Uint64, text Utf8, bytes String, d Date, " + "tm Datetime, ts Timestamp, dec Decimal(22, 9), PRIMARY KEY (id))", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLPrepare(stmt, + (SQLCHAR*)"INSERT INTO test_bound_types " + "(id, u64, text, bytes, d, tm, ts, dec) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", + SQL_NTS), stmt, SQL_HANDLE_STMT); + + SQLINTEGER id = 1; + SQLUBIGINT u64 = std::numeric_limits::max(); + SQLWCHAR text[] = {'Y', 'D', 'B', 0}; + char bytes[] = {'a', '\0', 'b', 'c'}; + SQL_DATE_STRUCT date{2024, 6, 15}; + SQL_TIME_STRUCT time{14, 30, 20}; + SQL_TIMESTAMP_STRUCT timestamp{2024, 6, 15, 14, 30, 20, 123456000}; + SQLDOUBLE decimal = 123.456; + SQLLEN textLength = SQL_NTS; + SQLLEN bytesLength = sizeof(bytes); + CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, &id, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_UBIGINT, SQL_BIGINT, + 0, 0, &u64, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_WCHAR, SQL_WVARCHAR, + 3, 0, text, sizeof(text), &textLength), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 4, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_VARBINARY, + sizeof(bytes), 0, bytes, sizeof(bytes), &bytesLength), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 5, SQL_PARAM_INPUT, SQL_C_TYPE_DATE, SQL_TYPE_DATE, + 0, 0, &date, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 6, SQL_PARAM_INPUT, SQL_C_TYPE_TIME, SQL_TYPE_TIME, + 0, 0, &time, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 7, SQL_PARAM_INPUT, SQL_C_TYPE_TIMESTAMP, SQL_TYPE_TIMESTAMP, + 0, 0, ×tamp, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindParameter(stmt, 8, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DECIMAL, + 0, 0, &decimal, 0, nullptr), stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_RESET_PARAMS); + SQLFreeStmt(stmt, SQL_CLOSE); + + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT u64, text, bytes, d, tm, ts, dec, dec AS dec_text " + "FROM test_bound_types WHERE id = 1", + SQL_NTS), stmt, SQL_HANDLE_STMT); + SQLCHAR columnName[32] = {}; + SQLSMALLINT nameLength = 0; + SQLSMALLINT describedType = 0; + SQLULEN columnSize = 0; + SQLSMALLINT decimalDigits = 0; + SQLSMALLINT nullable = 0; + CHECK_ODBC_OK(SQLDescribeCol(stmt, 5, columnName, sizeof(columnName), &nameLength, + &describedType, &columnSize, &decimalDigits, &nullable), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(describedType, SQL_TYPE_TIME); + CHECK_ODBC_OK(SQLDescribeCol(stmt, 6, columnName, sizeof(columnName), &nameLength, + &describedType, &columnSize, &decimalDigits, &nullable), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(describedType, SQL_TYPE_TIMESTAMP); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLUBIGINT fetchedU64 = 0; + SQLWCHAR fetchedText[4] = {}; + char fetchedBytes[4] = {}; + SQL_DATE_STRUCT fetchedDate{}; + SQL_TIME_STRUCT fetchedTime{}; + SQL_TIMESTAMP_STRUCT fetchedTimestamp{}; + SQLDOUBLE fetchedDecimal = 0; + char fetchedDecimalText[32] = {}; + SQLLEN indicator = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_UBIGINT, &fetchedU64, sizeof(fetchedU64), &indicator), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 2, SQL_C_WCHAR, fetchedText, sizeof(fetchedText), &indicator), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 3, SQL_C_BINARY, fetchedBytes, sizeof(fetchedBytes), &indicator), SQL_SUCCESS); + EXPECT_EQ(indicator, static_cast(sizeof(bytes))); + ASSERT_EQ(SQLGetData(stmt, 4, SQL_C_TYPE_DATE, &fetchedDate, sizeof(fetchedDate), &indicator), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 5, SQL_C_TYPE_TIME, &fetchedTime, sizeof(fetchedTime), &indicator), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 6, SQL_C_TYPE_TIMESTAMP, &fetchedTimestamp, sizeof(fetchedTimestamp), &indicator), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 7, SQL_C_DOUBLE, &fetchedDecimal, sizeof(fetchedDecimal), &indicator), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 8, SQL_C_CHAR, fetchedDecimalText, sizeof(fetchedDecimalText), &indicator), SQL_SUCCESS); + + EXPECT_EQ(fetchedU64, u64); + EXPECT_EQ(fetchedText[0], 'Y'); + EXPECT_EQ(fetchedText[1], 'D'); + EXPECT_EQ(fetchedText[2], 'B'); + EXPECT_EQ(std::memcmp(fetchedBytes, bytes, sizeof(bytes)), 0); + EXPECT_EQ(fetchedDate.year, date.year); + EXPECT_EQ(fetchedDate.month, date.month); + EXPECT_EQ(fetchedDate.day, date.day); + EXPECT_EQ(fetchedTime.hour, time.hour); + EXPECT_EQ(fetchedTime.minute, time.minute); + EXPECT_EQ(fetchedTime.second, time.second); + EXPECT_EQ(fetchedTimestamp.fraction, timestamp.fraction); + EXPECT_NEAR(fetchedDecimal, decimal, 1e-9); + EXPECT_STREQ(fetchedDecimalText, "123.456000000"); + + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_FIRST, 0), SQL_SUCCESS); + std::memset(fetchedBytes, 0, sizeof(fetchedBytes)); + fetchedDecimal = 0; + ASSERT_EQ(SQLGetData(stmt, 3, SQL_C_BINARY, fetchedBytes, sizeof(fetchedBytes), &indicator), SQL_SUCCESS); + ASSERT_EQ(SQLGetData(stmt, 7, SQL_C_DOUBLE, &fetchedDecimal, sizeof(fetchedDecimal), &indicator), SQL_SUCCESS); + EXPECT_EQ(std::memcmp(fetchedBytes, bytes, sizeof(bytes)), 0); + EXPECT_NEAR(fetchedDecimal, decimal, 1e-9); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, CursorAttributesAndCapabilities) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLULEN value = 0; + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, &value, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(value, SQL_CURSOR_FORWARD_ONLY); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_CURSOR_SCROLLABLE, &value, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(value, SQL_NONSCROLLABLE); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_CONCURRENCY, &value, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(value, SQL_CONCUR_READ_ONLY); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_CONCURRENCY, + (SQLPOINTER)SQL_CONCUR_READ_ONLY, 0), + stmt, SQL_HANDLE_STMT); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLFetchScroll(stmt, SQL_FETCH_PRIOR, 0), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "HY106")); + CHECK_ODBC_OK(SQLFreeStmt(stmt, SQL_CLOSE), stmt, SQL_HANDLE_STMT); + + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_SCROLLABLE, + (SQLPOINTER)SQL_SCROLLABLE, 0), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_CURSOR_SCROLLABLE, &value, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(value, SQL_SCROLLABLE); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, &value, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(value, SQL_CURSOR_STATIC); + + EXPECT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_CONCURRENCY, + (SQLPOINTER)SQL_CONCUR_VALUES, 0), + SQL_SUCCESS_WITH_INFO); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "01S02")); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_CONCURRENCY, &value, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(value, SQL_CONCUR_READ_ONLY); + + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, + (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY, 0), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, + (SQLPOINTER)SQL_CURSOR_KEYSET_DRIVEN, 0), + SQL_SUCCESS_WITH_INFO); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "01S02")); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, &value, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(value, SQL_CURSOR_STATIC); + + SQLUINTEGER info = 0; + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_STATIC_CURSOR_ATTRIBUTES1, &info, 0, nullptr), + dbc, SQL_HANDLE_DBC); + EXPECT_EQ(info & (SQL_CA1_NEXT | SQL_CA1_ABSOLUTE | SQL_CA1_RELATIVE), + SQL_CA1_NEXT | SQL_CA1_ABSOLUTE | SQL_CA1_RELATIVE); + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_SCROLL_OPTIONS, &info, 0, nullptr), + dbc, SQL_HANDLE_DBC); + EXPECT_EQ(info & (SQL_SO_FORWARD_ONLY | SQL_SO_STATIC), + SQL_SO_FORWARD_ONLY | SQL_SO_STATIC); + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_SCROLL_CONCURRENCY, &info, 0, nullptr), + dbc, SQL_HANDLE_DBC); + EXPECT_EQ(info & SQL_SCCO_READ_ONLY, SQL_SCCO_READ_ONLY); + CHECK_ODBC_OK(SQLGetInfo(dbc, SQL_STATIC_CURSOR_ATTRIBUTES2, &info, 0, nullptr), + dbc, SQL_HANDLE_DBC); + EXPECT_EQ(info & SQL_CA2_READ_ONLY_CONCURRENCY, SQL_CA2_READ_ONLY_CONCURRENCY); + + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + EXPECT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, + (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY, 0), + SQL_ERROR); + const std::string cursorTypeError = GetOdbcError(stmt, SQL_HANDLE_STMT); + EXPECT_TRUE(SqlStatePrefix(cursorTypeError, "24000")) << cursorTypeError; + EXPECT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_CONCURRENCY, + (SQLPOINTER)SQL_CONCUR_READ_ONLY, 0), + SQL_ERROR); + const std::string concurrencyError = GetOdbcError(stmt, SQL_HANDLE_STMT); + EXPECT_TRUE(SqlStatePrefix(concurrencyError, "24000")) << concurrencyError; + CHECK_ODBC_OK(SQLFreeStmt(stmt, SQL_CLOSE), stmt, SQL_HANDLE_STMT); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, ForwardCursorCapsRowsetReservationToAvailableRows) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + const SQLULEN rowArraySize = std::numeric_limits::max() / 2; + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_ROW_ARRAY_SIZE, + (SQLPOINTER)(uintptr_t)rowArraySize, 0), + stmt, SQL_HANDLE_STMT); + + SQLINTEGER value = 0; + SQLLEN indicator = 0; + SQLULEN fetched = 0; + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_ROWS_FETCHED_PTR, &fetched, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindCol(stmt, 1, SQL_C_LONG, &value, 0, &indicator), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + EXPECT_EQ(fetched, 1); + EXPECT_EQ(value, 1); + EXPECT_EQ(SQLFetch(stmt), SQL_NO_DATA); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, ExtendedFetchKeepsLegacyRowsetsSeparate) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + SQLUSMALLINT supported = SQL_FALSE; + ASSERT_EQ(SQLGetFunctions(dbc, SQL_API_SQLEXTENDEDFETCH, &supported), SQL_SUCCESS); + EXPECT_EQ(supported, SQL_TRUE); + ASSERT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, + (SQLPOINTER)SQL_CURSOR_STATIC, 0), SQL_SUCCESS); + ASSERT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)3, 0), SQL_SUCCESS); + SQLULEN modernFetched = 99; + SQLUSMALLINT modernStatuses[3] = {99, 99, 99}; + ASSERT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_ROWS_FETCHED_PTR, &modernFetched, 0), SQL_SUCCESS); + ASSERT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_ROW_STATUS_PTR, modernStatuses, 0), SQL_SUCCESS); + constexpr size_t valueOffset = sizeof(SQLLEN) / sizeof(SQLINTEGER); + SQLINTEGER values[3 + valueOffset] = {}; + SQLLEN indicators[4] = {}; + SQLULEN bindOffset = sizeof(SQLLEN); + ASSERT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, &bindOffset, 0), SQL_SUCCESS); + ASSERT_EQ(SQLBindCol(stmt, 1, SQL_C_LONG, values, 0, indicators), SQL_SUCCESS); + const auto query = (SQLCHAR*)"SELECT * FROM AS_TABLE(ListMap(ListFromRange(1, 4), " + "($x) -> (AsStruct($x AS value)))) ORDER BY value"; + ASSERT_EQ(SQLExecDirect(stmt, query, SQL_NTS), SQL_SUCCESS); + + SQLULEN fetched = 99; + SQLUSMALLINT statuses[2] = {99, 99}; + ASSERT_EQ(SQLExtendedFetch(stmt, SQL_FETCH_NEXT, 0, &fetched, statuses), SQL_SUCCESS); + EXPECT_EQ(fetched, 1); // SQL_ROWSET_SIZE defaults to one, independently of the ARD. + EXPECT_EQ(values[0], 1); + EXPECT_EQ(values[valueOffset], 0); + EXPECT_EQ(indicators[0], sizeof(SQLINTEGER)); + EXPECT_EQ(indicators[1], 0); + EXPECT_EQ(statuses[0], SQL_ROW_SUCCESS); + EXPECT_EQ(statuses[1], 99); + EXPECT_EQ(modernFetched, 99); + EXPECT_EQ(modernStatuses[0], 99); + + ASSERT_EQ(SQLSetStmtOption(stmt, SQL_ROWSET_SIZE, 2), SQL_SUCCESS); + EXPECT_EQ(SQLSetStmtOption(stmt, SQL_ROWSET_SIZE, 0), SQL_ERROR); + SQLULEN size = 0; + ASSERT_EQ(SQLGetStmtOption(stmt, SQL_ROWSET_SIZE, &size), SQL_SUCCESS); + EXPECT_EQ(size, 2); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_ROW_ARRAY_SIZE, &size, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(size, 3); + SQLHDESC ard = SQL_NULL_HDESC; + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_APP_ROW_DESC, &ard, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(SQLSetDescField(ard, 0, SQL_DESC_BIND_OFFSET_PTR, &bindOffset, 0), SQL_SUCCESS); + ASSERT_EQ(SQLExtendedFetch(stmt, SQL_FETCH_ABSOLUTE, 2, &fetched, statuses), SQL_SUCCESS); + EXPECT_EQ(fetched, 2); + EXPECT_EQ(values[0], 2); + EXPECT_EQ(values[1], 3); + EXPECT_EQ(indicators[1], sizeof(SQLINTEGER)); + EXPECT_EQ(indicators[2], 0); + EXPECT_EQ(statuses[1], SQL_ROW_SUCCESS); + EXPECT_EQ(SQLExtendedFetch(stmt, SQL_FETCH_NEXT, 0, &fetched, statuses), SQL_NO_DATA); + EXPECT_EQ(fetched, 0); + EXPECT_EQ(statuses[0], SQL_ROW_NOROW); + EXPECT_EQ(statuses[1], SQL_ROW_NOROW); + EXPECT_EQ(modernFetched, 99); + EXPECT_EQ(modernStatuses[1], 99); + + ASSERT_EQ(SQLFreeStmt(stmt, SQL_CLOSE), SQL_SUCCESS); + ASSERT_EQ(SQLExecDirect(stmt, query, SQL_NTS), SQL_SUCCESS); + values[0] = 99; + indicators[0] = 99; + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + EXPECT_EQ(modernFetched, 3); + EXPECT_EQ(modernStatuses[2], SQL_ROW_SUCCESS); + EXPECT_EQ(values[0], 99); + EXPECT_EQ(indicators[0], 99); + EXPECT_EQ(values[valueOffset], 1); + EXPECT_EQ(values[valueOffset + 1], 2); + EXPECT_EQ(values[valueOffset + 2], 3); + EXPECT_EQ(indicators[3], sizeof(SQLINTEGER)); + + ASSERT_EQ(SQLFreeStmt(stmt, SQL_CLOSE), SQL_SUCCESS); + ASSERT_EQ(SQLSetStmtAttr(stmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, nullptr, 0), SQL_SUCCESS); + SQLSCHAR smallValues[2] = {}; + ASSERT_EQ(SQLBindCol(stmt, 1, SQL_C_STINYINT, smallValues, 0, indicators), SQL_SUCCESS); + ASSERT_EQ(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 128", SQL_NTS), SQL_SUCCESS); + EXPECT_EQ(SQLExtendedFetch(stmt, SQL_FETCH_NEXT, 0, &fetched, statuses), SQL_SUCCESS_WITH_INFO); + EXPECT_EQ(fetched, 1); + EXPECT_EQ(statuses[0], SQL_ROW_ERROR); + EXPECT_EQ(statuses[1], SQL_ROW_NOROW); + bool rowError = false; + SQLCHAR state[6] = {}; + for (SQLSMALLINT record = 1; SQL_SUCCEEDED(SQLGetDiagRec( + SQL_HANDLE_STMT, stmt, record, state, nullptr, nullptr, 0, nullptr)); ++record) { + rowError |= std::strcmp((char*)state, "01S01") == 0; + } + EXPECT_TRUE(rowError); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, StaticCursorScrollsRowsets) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, + (SQLPOINTER)SQL_CURSOR_STATIC, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_ROW_ARRAY_SIZE, + (SQLPOINTER)(uintptr_t)3, 0), + stmt, SQL_HANDLE_STMT); + + SQLINTEGER values[3] = {}; + SQLLEN indicators[3] = {}; + SQLUSMALLINT statuses[3] = {}; + SQLULEN fetched = 0; + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_ROW_STATUS_PTR, statuses, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_ROWS_FETCHED_PTR, &fetched, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindCol(stmt, 1, SQL_C_LONG, values, 0, indicators), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT * FROM AS_TABLE(ListMap(ListFromRange(1, 8), " + "($x) -> (AsStruct($x AS value)))) ORDER BY value", + SQL_NTS), stmt, SQL_HANDLE_STMT); + + SQLULEN rowNumber = 0; + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_NEXT, 0), SQL_SUCCESS); + EXPECT_EQ(fetched, 3); + EXPECT_EQ(values[0], 1); + EXPECT_EQ(values[1], 2); + EXPECT_EQ(values[2], 3); + EXPECT_EQ(statuses[0], SQL_ROW_SUCCESS); + EXPECT_EQ(statuses[1], SQL_ROW_SUCCESS); + EXPECT_EQ(statuses[2], SQL_ROW_SUCCESS); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_ROW_NUMBER, &rowNumber, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(rowNumber, 1); + SQLINTEGER current = 0; + SQLLEN currentIndicator = 0; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, ¤t, 0, ¤tIndicator), SQL_SUCCESS); + EXPECT_EQ(current, 1); + + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_ROW_ARRAY_SIZE, + (SQLPOINTER)(uintptr_t)2, 0), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_NEXT, 0), SQL_SUCCESS); + EXPECT_EQ(fetched, 2); + EXPECT_EQ(values[0], 4); + EXPECT_EQ(values[1], 5); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_ROW_NUMBER, &rowNumber, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(rowNumber, 4); + + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_PRIOR, 0), SQL_SUCCESS); + EXPECT_EQ(values[0], 2); + EXPECT_EQ(values[1], 3); + + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_FIRST, 0), SQL_SUCCESS); + EXPECT_EQ(values[0], 1); + EXPECT_EQ(values[1], 2); + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_RELATIVE, 3), SQL_SUCCESS); + EXPECT_EQ(values[0], 4); + EXPECT_EQ(values[1], 5); + + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_LAST, 0), SQL_SUCCESS); + EXPECT_EQ(values[0], 6); + EXPECT_EQ(values[1], 7); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_ROW_NUMBER, &rowNumber, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(rowNumber, 6); + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_ABSOLUTE, -3), SQL_SUCCESS); + EXPECT_EQ(values[0], 5); + EXPECT_EQ(values[1], 6); + + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_ABSOLUTE, 0), SQL_NO_DATA); + EXPECT_EQ(fetched, 0); + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_NEXT, 0), SQL_SUCCESS); + EXPECT_EQ(values[0], 1); + EXPECT_EQ(values[1], 2); + + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_ABSOLUTE, 100), SQL_NO_DATA); + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_PRIOR, 0), SQL_SUCCESS); + EXPECT_EQ(values[0], 6); + EXPECT_EQ(values[1], 7); + + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_ABSOLUTE, 2), SQL_SUCCESS); + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_PRIOR, 0), SQL_SUCCESS_WITH_INFO); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "01S06")); + EXPECT_EQ(values[0], 1); + EXPECT_EQ(values[1], 2); + + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_ABSOLUTE, 6), SQL_SUCCESS); + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_RELATIVE, -6), SQL_SUCCESS_WITH_INFO); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(stmt, SQL_HANDLE_STMT), "01S06")); + EXPECT_EQ(values[0], 1); + EXPECT_EQ(values[1], 2); + + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_ABSOLUTE, -1), SQL_SUCCESS); + EXPECT_EQ(fetched, 1); + EXPECT_EQ(values[0], 7); + EXPECT_EQ(statuses[0], SQL_ROW_SUCCESS); + EXPECT_EQ(statuses[1], SQL_ROW_NOROW); + ASSERT_EQ(SQLGetStmtAttr(stmt, SQL_ATTR_ROW_NUMBER, &rowNumber, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(rowNumber, 7); + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, ¤t, 0, ¤tIndicator), SQL_SUCCESS); + EXPECT_EQ(current, 7); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(StatementApi, StaticCursorHonorsMaxRows) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_CURSOR_TYPE, + (SQLPOINTER)SQL_CURSOR_STATIC, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_MAX_ROWS, + (SQLPOINTER)(uintptr_t)5, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_ROW_ARRAY_SIZE, + (SQLPOINTER)(uintptr_t)3, 0), + stmt, SQL_HANDLE_STMT); + + SQLINTEGER values[3] = {}; + SQLLEN indicators[3] = {}; + SQLULEN fetched = 0; + CHECK_ODBC_OK(SQLSetStmtAttr(stmt, SQL_ATTR_ROWS_FETCHED_PTR, &fetched, 0), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLBindCol(stmt, 1, SQL_C_LONG, values, 0, indicators), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLExecDirect(stmt, + (SQLCHAR*)"SELECT * FROM AS_TABLE(ListMap(ListFromRange(1, 9), " + "($x) -> (AsStruct($x AS value)))) ORDER BY value", + SQL_NTS), stmt, SQL_HANDLE_STMT); + + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_LAST, 0), SQL_SUCCESS); + EXPECT_EQ(fetched, 3); + EXPECT_EQ(values[0], 3); + EXPECT_EQ(values[1], 4); + EXPECT_EQ(values[2], 5); + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_ABSOLUTE, 6), SQL_NO_DATA); + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_FIRST, 0), SQL_SUCCESS); + ASSERT_EQ(SQLFetchScroll(stmt, SQL_FETCH_NEXT, 0), SQL_SUCCESS); + EXPECT_EQ(fetched, 2); + EXPECT_EQ(values[0], 4); + EXPECT_EQ(values[1], 5); + + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} diff --git a/odbc/tests/integration/test_utils.h b/odbc/tests/integration/test_utils.h new file mode 100644 index 00000000000..21046e71de4 --- /dev/null +++ b/odbc/tests/integration/test_utils.h @@ -0,0 +1,144 @@ +#pragma once + +#include + +#include +#include +#ifdef ODBC_TEST_IODBC +#include +#endif + +#include +#include +#include +#include + +inline std::string GetOdbcError(SQLHANDLE handle, SQLSMALLINT type) { + SQLCHAR sqlState[6] = {0}; + SQLCHAR message[256] = {0}; + SQLINTEGER nativeError = 0; + SQLSMALLINT textLength = 0; + SQLRETURN rc = SQLGetDiagRec(type, handle, 1, sqlState, &nativeError, message, sizeof(message), &textLength); + if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) { + return std::string((char*)sqlState) + ": " + (char*)message; + } + return "Unknown ODBC error"; +} + +#define CHECK_ODBC_OK(rc, handle, type) \ + ASSERT_TRUE((rc) == SQL_SUCCESS || (rc) == SQL_SUCCESS_WITH_INFO) << GetOdbcError(handle, type) + +inline const char* kConnStr = "Driver=" ODBC_DRIVER_PATH ";Server=localhost:2136;Database=/local;"; + +#ifdef ODBC_TEST_IODBC +// Test-harness workaround for iODBC 3.52, not the driver's SQLWCHAR ABI. +// iODBC classifies this driver as ANSI because it does not export SQLConnectW. +// It then binds SQL_C_WCHAR as SQL_C_CHAR, but skips the required UCS-4-to-ANSI +// rebind when both code-page hints are UCS-4. A distinct driver hint forces +// that conversion; the driver receives SQL_C_CHAR, never UTF-16 code units. +inline const char* kIodbcWideInteropConnStr = "Driver=" ODBC_DRIVER_PATH + ";DriverUnicodeType=utf16;Server=localhost:2136;Database=/local;"; +#endif + +inline bool SqlStatePrefix(std::string_view diag, std::string_view state) { + return diag.starts_with(state); +} + +inline void AllocEnv(SQLHENV* env) { + static bool configured = false; + if (!configured) { + setenv("ODBCINI", ODBC_TEST_ODBCINI, 1); + setenv("ODBCSYSINI", ODBC_TEST_ODBCSYSINI, 1); + configured = true; + } + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, env), SQL_SUCCESS); + ASSERT_EQ(SQLSetEnvAttr(*env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), SQL_SUCCESS); +#ifdef ODBC_TEST_IODBC + // iODBC permits the application Unicode code page to come from external + // configuration. Declare the integration binary's wchar_t (UCS-4) ABI + // explicitly before allocating a DBC, as iODBC's Unicode sample does. + ASSERT_EQ(SQLSetEnvAttr(*env, SQL_ATTR_APP_UNICODE_TYPE, + (SQLPOINTER)SQL_DM_CP_DEF, 0), SQL_SUCCESS); +#endif +} + +inline void AllocEnvAndConnect(SQLHENV* env, SQLHDBC* dbc) { + AllocEnv(env); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, *env, dbc), SQL_SUCCESS); + SQLRETURN rc = SQLDriverConnect( + *dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_COMPLETE); + CHECK_ODBC_OK(rc, *dbc, SQL_HANDLE_DBC); +} + +// ============================================================================ +// Type and Parameter Utilities +// ============================================================================ + +// Bind integer parameter and return result +inline SQLRETURN BindIntParam(SQLHSTMT stmt, SQLUSMALLINT paramNum, SQLINTEGER* value) { + return SQLBindParameter(stmt, paramNum, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, value, 0, nullptr); +} + +inline SQLRETURN BindInt64Param(SQLHSTMT stmt, SQLUSMALLINT paramNum, SQLBIGINT* value) { + return SQLBindParameter(stmt, paramNum, SQL_PARAM_INPUT, SQL_C_SBIGINT, SQL_BIGINT, 0, 0, value, 0, nullptr); +} + +inline SQLRETURN BindStringParam(SQLHSTMT stmt, SQLUSMALLINT paramNum, char* value, SQLLEN len) { + SQLLEN indicator = (len >= 0) ? len : SQL_NTS; + return SQLBindParameter(stmt, paramNum, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, + 0, 0, value, (indicator == SQL_NTS) ? 0 : indicator, &indicator); +} + +inline SQLRETURN BindDoubleParam(SQLHSTMT stmt, SQLUSMALLINT paramNum, double* value) { + return SQLBindParameter(stmt, paramNum, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, value, 0, nullptr); +} + +inline SQLRETURN BindNullParam(SQLHSTMT stmt, SQLUSMALLINT paramNum, SQLINTEGER* placeholder) { + static SQLLEN nullIndicator = SQL_NULL_DATA; + return SQLBindParameter(stmt, paramNum, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, + 0, 0, placeholder, 0, &nullIndicator); +} + +// Fetch and verify integer result +inline SQLINTEGER FetchIntResult(SQLHSTMT stmt, SQLUSMALLINT colNum = 1) { + SQLINTEGER result = 0; + SQLLEN indicator = 0; + SQLBindCol(stmt, colNum, SQL_C_LONG, &result, 0, &indicator); + SQLFetch(stmt); + return result; +} + +inline SQLBIGINT FetchInt64Result(SQLHSTMT stmt, SQLUSMALLINT colNum = 1) { + SQLBIGINT result = 0; + SQLLEN indicator = 0; + SQLBindCol(stmt, colNum, SQL_C_SBIGINT, &result, 0, &indicator); + SQLFetch(stmt); + return result; +} + +inline double FetchDoubleResult(SQLHSTMT stmt, SQLUSMALLINT colNum = 1) { + double result = 0.0; + SQLLEN indicator = 0; + SQLBindCol(stmt, colNum, SQL_C_DOUBLE, &result, 0, &indicator); + SQLFetch(stmt); + return result; +} + +inline std::string FetchStringResult(SQLHSTMT stmt, SQLUSMALLINT colNum = 1, size_t maxLen = 256) { + std::string result(maxLen, '\0'); + SQLLEN indicator = 0; + SQLBindCol(stmt, colNum, SQL_C_CHAR, &result[0], maxLen, &indicator); + SQLFetch(stmt); + if (indicator > 0 && indicator != SQL_NULL_DATA) { + result.resize(indicator); + } + return result; +} + +inline bool IsNullResult(SQLHSTMT stmt, SQLUSMALLINT colNum = 1) { + SQLINTEGER dummy; + SQLLEN indicator = 0; + SQLBindCol(stmt, colNum, SQL_C_LONG, &dummy, 0, &indicator); + SQLFetch(stmt); + return indicator == SQL_NULL_DATA; +} diff --git a/odbc/tests/integration/transaction_api_it.cpp b/odbc/tests/integration/transaction_api_it.cpp new file mode 100644 index 00000000000..b569d2ec07e --- /dev/null +++ b/odbc/tests/integration/transaction_api_it.cpp @@ -0,0 +1,182 @@ +#include "test_utils.h" + +TEST(TransactionApi, AutocommitDefaultOn) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + + SQLUINTEGER autocommit; + ASSERT_EQ(SQLGetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, &autocommit, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(autocommit, SQL_AUTOCOMMIT_ON); + + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(TransactionApi, AutocommitOnOffToggle) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, 0), + dbc, SQL_HANDLE_DBC); + SQLUINTEGER autocommit; + ASSERT_EQ(SQLGetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, &autocommit, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(autocommit, SQL_AUTOCOMMIT_OFF); + + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, 0), + dbc, SQL_HANDLE_DBC); + ASSERT_EQ(SQLGetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, &autocommit, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(autocommit, SQL_AUTOCOMMIT_ON); + + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(TransactionApi, AutocommitOffRollback) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_rollback", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"CREATE TABLE test_rollback (id Int32, value Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, 0), + dbc, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"UPSERT INTO test_rollback (id, value) VALUES (1, 100)", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLEndTran(SQL_HANDLE_DBC, dbc, SQL_ROLLBACK), dbc, SQL_HANDLE_DBC); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT value FROM test_rollback WHERE id = 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_NO_DATA); + CHECK_ODBC_OK(SQLEndTran(SQL_HANDLE_DBC, dbc, SQL_ROLLBACK), dbc, SQL_HANDLE_DBC); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(TransactionApi, AutocommitOffCommit) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_commit", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"CREATE TABLE test_commit (id Int32, value Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, 0), + dbc, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"UPSERT INTO test_commit (id, value) VALUES (1, 200)", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLEndTran(SQL_HANDLE_DBC, dbc, SQL_COMMIT), dbc, SQL_HANDLE_DBC); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT value FROM test_commit WHERE id = 1", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER value; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &value, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(value, 200); + CHECK_ODBC_OK(SQLEndTran(SQL_HANDLE_DBC, dbc, SQL_ROLLBACK), dbc, SQL_HANDLE_DBC); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(TransactionApi, MultipleStatementsInManualTransaction) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_multi_stmt", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"CREATE TABLE test_multi_stmt (id Int32, value Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, 0), + dbc, SQL_HANDLE_DBC); + for (int i = 1; i <= 5; ++i) { + char query[256]; + snprintf(query, sizeof(query), "UPSERT INTO test_multi_stmt (id, value) VALUES (%d, %d)", i, i * 10); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)query, SQL_NTS), stmt, SQL_HANDLE_STMT); + } + CHECK_ODBC_OK(SQLEndTran(SQL_HANDLE_DBC, dbc, SQL_COMMIT), dbc, SQL_HANDLE_DBC); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT COUNT(*) FROM test_multi_stmt", SQL_NTS), + stmt, SQL_HANDLE_STMT); + ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS); + SQLINTEGER count; + ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &count, 0, nullptr), SQL_SUCCESS); + ASSERT_EQ(count, 5); + CHECK_ODBC_OK(SQLEndTran(SQL_HANDLE_DBC, dbc, SQL_ROLLBACK), dbc, SQL_HANDLE_DBC); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(TransactionApi, SQLEndTranOnEnv) { + SQLHENV env; + SQLHDBC dbc; + SQLHSTMT stmt; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS); + SQLExecDirect(stmt, (SQLCHAR*)"DROP TABLE IF EXISTS test_env_tran", SQL_NTS); + SQLFreeStmt(stmt, SQL_CLOSE); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"CREATE TABLE test_env_tran (id Int32, PRIMARY KEY (id))", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLSetConnectAttr(dbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, 0), + dbc, SQL_HANDLE_DBC); + CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"UPSERT INTO test_env_tran (id) VALUES (1)", SQL_NTS), + stmt, SQL_HANDLE_STMT); + CHECK_ODBC_OK(SQLEndTran(SQL_HANDLE_ENV, env, SQL_COMMIT), env, SQL_HANDLE_ENV); + SQLFreeHandle(SQL_HANDLE_STMT, stmt); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(TransactionApi, SQLEndTranInvalid) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLEndTran(SQL_HANDLE_DBC, dbc, 999), SQL_ERROR); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(TransactionApi, TxnIsolationDefault) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + SQLUINTEGER isolation; + ASSERT_EQ(SQLGetConnectAttr(dbc, SQL_ATTR_TXN_ISOLATION, &isolation, sizeof(isolation), nullptr), SQL_SUCCESS); + ASSERT_EQ(isolation, SQL_TXN_SERIALIZABLE); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} + +TEST(TransactionApi, TxnIsolationUnsupportedInReadWrite) { + SQLHENV env; + SQLHDBC dbc; + AllocEnvAndConnect(&env, &dbc); + ASSERT_EQ(SQLSetConnectAttr(dbc, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER)SQL_TXN_READ_COMMITTED, 0), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(dbc, SQL_HANDLE_DBC), "HYC00")); + ASSERT_EQ(SQLSetConnectAttr(dbc, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER)9999, 0), SQL_ERROR); + EXPECT_TRUE(SqlStatePrefix(GetOdbcError(dbc, SQL_HANDLE_DBC), "HY024")); + SQLDisconnect(dbc); + SQLFreeHandle(SQL_HANDLE_DBC, dbc); + SQLFreeHandle(SQL_HANDLE_ENV, env); +} diff --git a/odbc/tests/test_integration_harness.py b/odbc/tests/test_integration_harness.py new file mode 100644 index 00000000000..3cfa9bc85a5 --- /dev/null +++ b/odbc/tests/test_integration_harness.py @@ -0,0 +1,296 @@ +import json, re, shutil, sys, tempfile, unittest +from pathlib import Path +from unittest import mock +import yaml +FRAMEWORKS = Path(__file__).resolve().parent / "frameworks" +sys.path.insert(0, str(FRAMEWORKS)) +import harness # noqa: E402 +class HarnessTests(unittest.TestCase): + def test_lua_crash_classification_preserves_driver_failures(self): + consumer = next(c for c in harness.load_registry()["consumers"] if c["id"] == "lua") + stack = "\n".join(f"#{i} 0x1234 in ?? ()" for i in range(5)) + stack += "\n#5 0x5678 in lua_pcallk ()" + for prefix in ("Program", 'Thread 1 "lua5.4"'): + crash = prefix + " received signal SIGSEGV, Segmentation fault.\n" + stack + test = {"id": "lua.connection_string.close%20objects", "status": "failed", "message": crash} + self.assertEqual(harness.expected_result(test, consumer["expected"])[0], "upstream_failure") + test["message"] += "\n#6 in SQLGetData from libydb-odbc.so" + self.assertIsNone(harness.expected_result(test, consumer["expected"])) + + def registry(self, change=lambda data, root: None): + context = tempfile.TemporaryDirectory(); self.addCleanup(context.cleanup) + root = Path(context.name) / "frameworks"; shutil.copytree(FRAMEWORKS, root) + path = root / "registry.yaml"; data = yaml.safe_load(path.read_text()) + change(data, root); path.write_text(yaml.safe_dump(data, sort_keys=False)); return path + def validate(self, tests, expected, test_rc=0, inventory=None, **inventory_fields): + context = tempfile.TemporaryDirectory(); self.addCleanup(context.cleanup) + root = Path(context.name); native, allure = root / "native", root / "allure" + native.mkdir(); allure.mkdir(); (native / "results.json").write_text(json.dumps({"tests": tests, "inventory": inventory if inventory is not None else [t["id"] for t in tests], **inventory_fields})) + for index in range(len(tests)): (allure / f"{index}-result.json").write_text("{}") + with mock.patch.object(harness, "RESULTS", root): + return harness.validate_results({"id": "sample", "expected": expected}, + native / "results.json", allure, test_rc) + def test_registry_guards(self): + registry = harness.load_registry() + runs = list(harness.consumer_runs(registry)) + expected_run_ids = { + consumer["id"] if mode == "all" else f"{consumer['id']}-{mode}" + for consumer in registry["consumers"] for mode in (consumer.get("modes") or ["all"]) + } + self.assertEqual({run["run_id"] for run in runs}, expected_run_ids) + self.assertEqual(len(runs), len(expected_run_ids)) + self.assertEqual(harness.infrastructure_test_id("consumer", "dsn"), + "consumer.dsn.infrastructure") + self.assertEqual(harness.infrastructure_test_id("consumer", "all"), + "consumer.infrastructure") + def framework(data): + return next(item for item in data["consumers"] if item["kind"] == "framework") + def discovered(data): + return next(item for item in data["consumers"] + if item.get("expected", {}).get("discovered")) + def duplicate(data, _): + data["consumers"].append(dict(data["consumers"][0])) + def unpinned(data, _): + data["consumers"][0]["runtime_image"] = "ubuntu:24.04" + def unpinned_ydb(data, _): + data["ydb"]["image"] = "ydbplatform/local-ydb:25.2.1" + def changed_source(data, _): + framework(data)["source"]["sha256"] = "0" * 64 + def add_classification(data, outcome, reason, consumer, pattern): + data.setdefault("classifications", []).append({ + "outcome": outcome, "reason": reason, "match": "raw assertion", "tests": {consumer: [pattern]}, + }) + def broad_failure(data, _): + consumer = discovered(data) + add_classification(data, "unsupported", "too broad", consumer["id"], + f"{consumer['id']}.*.future_suite.*") + def duplicate_classification(data, _): + consumer = discovered(data) + pattern = f"{consumer['id']}.*.future_suite.case" + add_classification(data, "unsupported", "known failure", consumer["id"], pattern) + add_classification(data, "skipped", "also skipped", consumer["id"], pattern) + def empty_reason(data, _): + consumer = discovered(data) + add_classification(data, "unsupported", "", consumer["id"], + f"{consumer['id']}.*.future_suite.case") + cases = [(duplicate, "duplicate consumer"), + (unpinned, "digest-pinned"), + (unpinned_ydb, "YDB image must provide logical affected-row statistics"), + (changed_source, "upstream.lock"), + (broad_failure, "suite-wide expected-result patterns"), + (duplicate_classification, "duplicate or unexplained expectations"), + (empty_reason, "reason must be a non-empty string")] + def missing_reference(data, _): + data["classifications"].append(dict(outcome="upstream_failure", reason="consumer bug", + match="assertion", tests={"lua": ["lua.*.case"]})) + def missing_reproducer(data, root): + missing_reference(data, root) + data["classifications"][-1]["reference"] = "https://example.org/issue/1" + cases += [(missing_reference, "upstream reference is required"), + (missing_reproducer, "checked-in reproducer is required")] + for change, message in cases: + with self.subTest(message=message), self.assertRaisesRegex(harness.HarnessError, message): + harness.load_registry(self.registry(change)) + def test_result_guards(self): + required = {"required": ["sample.case"]} + self.assertFalse(self.validate([{"id": "sample.case", "status": "passed"}], required)) + for tests, message in (([], "empty"), ([{"id": "other", "status": "passed"}], "missing"), + ([{"id": "sample.case", "status": "skipped"}], "status")): + self.assertTrue(any(message in error for error in self.validate(tests, required))) + fixed_failure = {"required": ["sample.case"], + "unsupported": {"sample.case": {"reason": "unsupported feature", "match": "raw assertion"}}} + self.assertFalse(self.validate( + [{"id": "sample.case", "status": "failed", "message": "raw assertion"}], + fixed_failure, test_rc=1)) + discovered = { + "discovered": True, + "required": ["sample.*.*"], + "unsupported": {"sample.legacy.knownFailure": {"reason": "unsupported feature", "match": "failed assertion"}}, + "skipped": {"sample.upstream.disabled": {"reason": "upstream gate", "match": "disabled upstream"}}, + } + tests = [ + {"id": "sample.core.passes", "status": "passed"}, + {"id": "sample.future.newSuiteCase", "status": "passed"}, + {"id": "sample.legacy.knownFailure", "status": "failed", "message": "failed assertion"}, + {"id": "sample.upstream.disabled", "status": "skipped", "message": "disabled upstream"}, + ] + self.assertFalse(self.validate(tests, discovered, test_rc=1)) + passing_failure = [dict(test) for test in tests] + passing_failure[2] = {"id": "sample.legacy.knownFailure", "status": "passed"} + self.assertTrue(any("for unsupported" in error + for error in self.validate(passing_failure, discovered))) + stale = dict(discovered) + stale["unsupported"] = dict(discovered["unsupported"]) + stale["unsupported"]["sample.removed.case"] = {"reason": "stale", "match": "never"} + self.assertTrue(any("pattern matched no tests" in error + for error in self.validate(tests, stale, test_rc=1))) + ambiguous = { + "discovered": True, + "required": ["sample.*"], + "unsupported": {"sample.*.knownFailure": {"reason": "unsupported feature", "match": "failure"}}, + "skipped": {"sample.legacy.*": {"reason": "upstream gate", "match": "failure"}}, + } + self.assertTrue(any("ambiguous expected result" in error for error in self.validate( + [{"id": "sample.legacy.knownFailure", "status": "failed", "message": "failure"}], + ambiguous, test_rc=1))) + self.assertTrue(any("although every reported test passed" in error for error in self.validate( + [{"id": "sample.core.passes", "status": "passed"}], + {"discovered": True, "required": ["sample.*"]}, test_rc=2))) + for status, diagnostic, phase in [("failed", "fixture is broken", "test"), + ("broken", "failed assertion", "test"), + ("failed", "failed assertion", "setup")]: + changed = [dict(t) for t in tests] + changed[2].update(status=status, message=diagnostic, phase=phase) + self.assertTrue(self.validate(changed, discovered, test_rc=1)) + for problems in ([{"kind": "failure", "message": "failed assertion"}, + {"kind": "failure", "message": "unrelated defect"}], + [{"kind": "error", "message": "failed assertion"}]): + changed = [dict(t) for t in tests] + changed[2]["problems"] = problems + self.assertTrue(self.validate(changed, discovered, test_rc=1)) + upstream = {"required": ["sample.case"], "upstream_failure": { + "sample.case": {"reason": "reproduced consumer defect", "match": "consumer assertion"}}} + self.assertFalse(self.validate( + [{"id": "sample.case", "status": "failed", "message": "consumer assertion"}], upstream, test_rc=1)) + self.assertTrue(self.validate([{"id": "sample.case", "status": "passed"}], upstream)) + upstream["upstream_failure"]["sample.case"]["allow_pass"] = True + self.assertFalse(self.validate([{"id": "sample.case", "status": "passed"}], upstream)) + for test in [{"id": "sample.case", "status": "failed", "message": "driver assertion"}, + {"id": "sample.case", "status": "broken", "message": "consumer assertion"}, + {"id": "sample.case", "status": "failed", "message": "consumer assertion", "phase": "setup"}]: + self.assertTrue(self.validate([test], upstream)) + self.assertTrue(self.validate(tests, discovered, test_rc=-9)) + self.assertTrue(self.validate(tests, discovered, inventory=[t["id"] for t in tests] + ["sample.missing.row"])) + rows = { + "sample.function@pass": {"id": "sample.function@pass", "parent_id": "sample.function", "status": "passed"}, + "sample.function@fail": {"id": "sample.function@fail", "parent_id": "sample.function", "status": "failed", "message": "real defect"}, + } + self.assertTrue(harness.validate_classified_results(rows, {"required": ["sample.*"]})) + self.assertEqual(harness.matching_ids(rows, "sample.function"), set(rows)) + planned = dict(inventory=["sample.function"], inventory_kind="parents", + inventory_rows={"sample.function": 2}) + complete = [dict(test, status="passed") for test in rows.values()] + expected = {"discovered": True, "required": ["sample.*"]} + self.assertFalse(self.validate(complete, expected, **planned)) + self.assertTrue(any("data rows" in error for error in self.validate(complete[:1], expected, **planned))) + self.assertEqual(harness.glob_ids( + {"sample.one.alpha", "sample.two.beta", "sample.three.gamma"}, + "sample.{one,two}.{alpha,beta}"), + {"sample.one.alpha", "sample.two.beta"}) + infrastructure = [{"id": "sample.dsn.infrastructure", "status": "broken", + "message": "fixture patch exited 2"}] + errors = self.validate(infrastructure, discovered) + self.assertEqual(errors, ["sample.dsn.infrastructure: fixture patch exited 2"]) + def test_manual_expected_reason_reaches_allure(self): + context = tempfile.TemporaryDirectory(); self.addCleanup(context.cleanup) + root = Path(context.name); native, allure = root / "native" / "results.json", root / "allure" + native.parent.mkdir() + native.write_text(json.dumps({"tests": [{ + "id": "sample.suite.knownFailure", "name": "known failure", "status": "failed", + "message": "raw assertion", "trace": "raw stack", "start": 1, "stop": 2, + }]})) + config = {"classifications": [ + {"outcome": "unsupported", "reason": "manually classified reason", "match": "raw assertion", + "tests": {"sample": ["sample.suite.knownFailure"]}}, + ]} + expected = {"discovered": True, "required": ["sample.*.*"]} + expected.update(harness.load_classifications(config, [{"id": "sample"}])["sample"]) + consumer = {"id": "sample", "expected": expected} + harness.annotate_expected_results(consumer, native) + metadata = { + "consumer": "sample", "language": "C++", "tier": "core", + "driver_commit": "commit", "runtime_version": "runtime", "ydb_image": "ydb", + "connection_mode": "dsn", "run_id": "sample-dsn", "endpoint": "localhost:2136", + "database": "/local", "package_sha256": "package", + "upstream_revision": "revision", "upstream_sha256": "source", + } + harness.convert_allure(native, allure, metadata) + result = json.loads(next(allure.glob("*-result.json")).read_text()) + self.assertEqual(result["statusDetails"]["message"], + "Expected unsupported: manually classified reason\nReported FAILED: raw assertion") + self.assertTrue(result["statusDetails"]["known"]) + self.assertEqual(json.loads(native.read_text())["tests"][0]["message"], "raw assertion") + self.assertIn("raw stack", result["statusDetails"]["trace"]) + self.assertIn({"name": "originalStatus", "value": "failed"}, result["labels"]) + def test_allure_ids_include_connection_mode(self): + context = tempfile.TemporaryDirectory(); self.addCleanup(context.cleanup) + root = Path(context.name); identities = [] + for mode in ("dsn", "connection_string"): + native, allure = root / mode / "native" / "results.json", root / mode / "allure" + native.parent.mkdir(parents=True) + native.write_text(json.dumps({"tests": [{ + "id": harness.infrastructure_test_id("qt", mode), "name": "infrastructure", + "status": "broken", "start": 1, "stop": 2, "message": "failure"}]})) + metadata = {"consumer": "qt", "language": "C++", "tier": "core", + "driver_commit": "commit", "runtime_version": "6.4.2", + "ydb_image": "ydb", "connection_mode": mode, + "run_id": f"qt-{mode}", "endpoint": "localhost:2136", + "database": "/local", "package_sha256": "package", + "upstream_revision": "revision", "upstream_sha256": "source"} + harness.convert_allure(native, allure, metadata) + result = json.loads(next(allure.glob("*-result.json")).read_text()) + identities.append((result["uuid"], result["historyId"], result["testCaseId"])) + self.assertEqual(len({identity[0] for identity in identities}), 2) + self.assertEqual(len({identity[1] for identity in identities}), 2) + self.assertEqual(len({identity[2] for identity in identities}), 2) + def test_aggregation_preserves_attachments_and_rejects_mixed_packages(self): + context = tempfile.TemporaryDirectory(); self.addCleanup(context.cleanup) + root = Path(context.name); source = root / "input"; source.mkdir() + for run_id in ("sample-dsn", "sample-connection_string"): + artifact = source / run_id + (artifact / "native").mkdir(parents=True) + (artifact / "allure").mkdir() + (artifact / "native/results.json").write_text(json.dumps({"tests": [{"id": run_id, "status": "passed"}]})) + metadata = {"run_id": run_id, "driver_commit": "commit", "package_sha256": "package", "ydb_image": "ydb"} + (artifact / "metadata.json").write_text(json.dumps(metadata)) + (artifact / "validation.json").write_text(json.dumps({"ok": True, "test_count": 1, "counts": {"passed": 1}})) + attachment = run_id + ".txt" + (artifact / "allure" / attachment).write_text("raw diagnostic") + (artifact / "allure" / (run_id + "-result.json")).write_text(json.dumps({"attachments": [{"source": attachment}]})) + runs = [{"run_id": path.name} for path in source.iterdir()] + with mock.patch.object(harness, "load_registry", return_value={}), mock.patch.object(harness, "consumer_runs", return_value=runs): + self.assertEqual(harness.aggregate(source, root / "good"), 0) + self.assertTrue((root / "good/allure-results/sample-dsn.txt").is_file()) + path = source / "sample-dsn/metadata.json" + value = json.loads(path.read_text()); value["package_sha256"] = "another-package" + path.write_text(json.dumps(value)) + self.assertEqual(harness.aggregate(source, root / "mixed"), 1) + shutil.rmtree(source / "sample-dsn") + self.assertEqual(harness.aggregate(source, root / "missing"), 1) + + def test_qt_fixture_patch_is_reviewable(self): + patch = (FRAMEWORKS / "qt" / "ydb.patch").read_text() + lock = yaml.safe_load((FRAMEWORKS / "qt" / "upstream.lock").read_text()) + runner = (FRAMEWORKS / "qt" / "run-tests").read_text() + self.assertIn(f"Applies to qtbase revision {lock['revision']}.", patch) + self.assertIn('["patch", "--batch", "--forward", "--fuzz=0", "-p1", "-i", patch]', runner) + self.assertNotIn("adapt_fixtures", runner) + self.assertNotIn("re.subn", runner) + self.assertNotIn("retry", runner) + self.assertNotIn("YDB_QT_TEST_MODE", runner + patch) + self.assertIn("Path(root).chmod(0o755)", runner) + self.assertIn("fixture patch exited", runner) + self.assertIn('q.exec("drop table if exists " + tableName)', patch) + self.assertIn('"qsqldatabase": {"transaction"}', runner) + changed = [line for line in patch.splitlines() + if line[:1] in {"+", "-"} and not line.startswith(("+++", "---"))] + assertion = re.compile(r"\b(?:QCOMPARE|QVERIFY|QFAIL|QSKIP|QEXPECT_FAIL)\b") + string_literal = re.compile(r'"(?:\\.|[^"\\])*"') + def assertion_shape(line): + shape = re.sub(r"\s+", "", string_literal.sub('""', line[1:])) + if shape.startswith("QVERIFY(q.prepare("): + return "QVERIFY(q.prepare(...))" + return shape + removed_assertions = [assertion_shape(line) for line in changed + if line.startswith("-") and assertion.search(line)] + added_assertions = [assertion_shape(line) for line in changed + if line.startswith("+") and assertion.search(line)] + self.assertCountEqual(added_assertions, removed_assertions) + self.assertFalse(any(line.startswith("-") and re.search(r"\bq\.(?:addBindValue|bindValue)\(", line) + for line in changed), "Fixture patches must preserve original parameter bindings") + removed_keys = [line for line in changed + if line.startswith("-") and "primary key" in line.lower()] + added_keys = [line for line in changed + if line.startswith("+") and "primary key" in line.lower()] + self.assertGreaterEqual(len(added_keys), len(removed_keys)) +if __name__ == "__main__": unittest.main() diff --git a/odbc/tests/unit/CMakeLists.txt b/odbc/tests/unit/CMakeLists.txt new file mode 100644 index 00000000000..1be3dd355c5 --- /dev/null +++ b/odbc/tests/unit/CMakeLists.txt @@ -0,0 +1,93 @@ +set(YDB_ODBC_UNIT_INCLUDE_DIRS + ${CMAKE_CURRENT_SOURCE_DIR}/../../src + ${ODBC_INCLUDE_DIRS} +) + +add_ydb_test(NAME odbc-convert_ut GTEST + SOURCES + convert_ut.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/convert.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/sql_type_map.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/types.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/util.cpp + INCLUDE_DIRS + ${YDB_ODBC_UNIT_INCLUDE_DIRS} + LINK_LIBRARIES + yutil + YDB-CPP-SDK::Params + api-protos + LABELS + unit +) + +add_ydb_test(NAME odbc-escape_ut GTEST + SOURCES + escape_ut.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/escape.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/sql_type_map.cpp + INCLUDE_DIRS + ${YDB_ODBC_UNIT_INCLUDE_DIRS} + LINK_LIBRARIES + yutil + LABELS + unit +) + +add_ydb_test(NAME odbc-param_rewrite_ut GTEST + SOURCES + param_rewrite_ut.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/escape.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/sql_type_map.cpp + INCLUDE_DIRS + ${YDB_ODBC_UNIT_INCLUDE_DIRS} + LINK_LIBRARIES + yutil + LABELS + unit +) + +add_ydb_test(NAME odbc-conn_string_ut GTEST + SOURCES + conn_string_ut.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/util.cpp + INCLUDE_DIRS + ${YDB_ODBC_UNIT_INCLUDE_DIRS} + LINK_LIBRARIES + yutil + YDB-CPP-SDK::Params + LABELS + unit +) + +add_ydb_test(NAME odbc-sql_like_ut GTEST + SOURCES + sql_like_ut.cpp + INCLUDE_DIRS + ${YDB_ODBC_UNIT_INCLUDE_DIRS} + LINK_LIBRARIES + yutil + LABELS + unit +) + +add_ydb_test(NAME odbc-cursor_ut GTEST + SOURCES + cursor_ut.cpp + INCLUDE_DIRS + ${YDB_ODBC_UNIT_INCLUDE_DIRS} + LINK_LIBRARIES + ydb-odbc + LABELS + unit +) + +add_ydb_test(NAME odbc-descriptor_ut GTEST + SOURCES + descriptor_ut.cpp + INCLUDE_DIRS + ${YDB_ODBC_UNIT_INCLUDE_DIRS} + LINK_LIBRARIES + ydb-odbc + LABELS + unit +) diff --git a/odbc/tests/unit/conn_string_ut.cpp b/odbc/tests/unit/conn_string_ut.cpp new file mode 100644 index 00000000000..8b406c30b65 --- /dev/null +++ b/odbc/tests/unit/conn_string_ut.cpp @@ -0,0 +1,50 @@ +#include "utils/util.h" + +#include + +TEST(ConnString, ParsesBraceEscapedSemicolons) { + const auto params = NYdb::NOdbc::ParseConnectionString("Database={path;with;semicolons};Server=host"); + ASSERT_EQ(params.at("Database"), "path;with;semicolons"); + ASSERT_EQ(params.at("Server"), "host"); +} + +TEST(ConnString, DecodesEscapedClosingBrace) { + const auto params = NYdb::NOdbc::ParseConnectionString( + "PWD={a}}b};Database=/local;Server=host"); + ASSERT_EQ(params.at("PWD"), "a}b"); + ASSERT_EQ(params.at("Database"), "/local"); + ASSERT_EQ(params.at("Server"), "host"); +} + +TEST(ConnString, ParsesSimplePairs) { + const auto params = NYdb::NOdbc::ParseConnectionString("DSN=YDB;Database=/local;Server=grpc://localhost:2136"); + ASSERT_EQ(params.at("DSN"), "YDB"); + ASSERT_EQ(params.at("Database"), "/local"); + ASSERT_EQ(params.at("Server"), "grpc://localhost:2136"); +} + +TEST(ConnString, TrimsWhitespace) { + const auto params = NYdb::NOdbc::ParseConnectionString(" Database = /local ; Server = host "); + ASSERT_EQ(params.at("Database"), "/local"); + ASSERT_EQ(params.at("Server"), "host"); +} + +TEST(OdbcString, ConvertsUtf16ToUtf8) { + SQLWCHAR text[] = {'Y', 'D', 'B', ' ', 0x041f, 0x0440, 0x0438, 0x0432, 0x0435, 0x0442, 0}; + EXPECT_EQ(NYdb::NOdbc::GetString(text, SQL_NTS), "YDB \xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82"); +} + +TEST(OdbcString, ConvertsUtf16SurrogatePairToUtf8) { + SQLWCHAR text[] = {0xd83d, 0xde80, 0}; + EXPECT_EQ(NYdb::NOdbc::GetString(text, SQL_NTS), "\xf0\x9f\x9a\x80"); +} + +TEST(OdbcString, IgnoresAnsiTerminatorIncludedInExplicitLength) { + SQLCHAR text[] = {'/', 'l', 'o', 'c', 'a', 'l', 0}; + EXPECT_EQ(NYdb::NOdbc::GetString(text, 7), "/local"); +} + +TEST(OdbcString, IgnoresUtf16TerminatorIncludedInExplicitLength) { + SQLWCHAR text[] = {'S', 'E', 'L', 'E', 'C', 'T', ' ', '4', '2', 0}; + EXPECT_EQ(NYdb::NOdbc::GetString(text, 10), "SELECT 42"); +} diff --git a/odbc/tests/unit/convert_ut.cpp b/odbc/tests/unit/convert_ut.cpp new file mode 100644 index 00000000000..ec2edc966e8 --- /dev/null +++ b/odbc/tests/unit/convert_ut.cpp @@ -0,0 +1,635 @@ +#include "utils/convert.h" +#include "utils/types.h" +#undef BOOL + +#include + +#include + +#include + +#include + +#include + +using namespace NYdb::NOdbc; +using namespace NYdb; + +template +void CheckProto(const T& value, const std::string& expected) { + std::string protoStr; + google::protobuf::TextFormat::PrintToString(value, &protoStr); + ASSERT_EQ(protoStr, expected); +} + +TEST(OdbcConvert, Int64ToYdb) { + SQLBIGINT v = 42; + TBoundParam param{ + 1, // ParamNumber + SQL_C_SBIGINT, // ValueType + SQL_BIGINT, // ParameterType + 0, 0, // ColumnSize, DecimalDigits + &v, // ParameterValuePtr + sizeof(v), // BufferLength + nullptr // StrLenOrIndPtr + }; + + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetType().GetProto(), "type_id: INT64\n"); + CheckProto(value->GetProto(), "int64_value: 42\n"); +} + +TEST(OdbcConvert, UnsignedCSelectsYdbUnsignedType) { + SQLUBIGINT v = 123; + TBoundParam param{ + 1, SQL_C_UBIGINT, SQL_BIGINT, 0, 0, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetType().GetProto(), "type_id: UINT64\n"); + CheckProto(value->GetProto(), "uint64_value: 123\n"); + EXPECT_EQ(DescribeYdbType(value->GetType()).ColumnSize, 20); +} + +TEST(OdbcConvert, WideStringToYdbUtf8) { + SQLWCHAR text[] = {'h', 'e', 'l', 'l', 'o', 0}; + SQLLEN length = SQL_NTS; + TBoundParam param{ + 1, SQL_C_WCHAR, SQL_WVARCHAR, 0, 0, + text, sizeof(text), &length + }; + TParamsBuilder paramsBuilder; + ASSERT_EQ(ConvertParam(param, paramsBuilder.AddParam("$p1")), SQL_SUCCESS); + const auto value = paramsBuilder.Build().GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetType().GetProto(), "type_id: UTF8\n"); + CheckProto(value->GetProto(), "text_value: \"hello\"\n"); +} + +TEST(OdbcConvert, TimestampStructToYdbTimestamp) { + SQL_TIMESTAMP_STRUCT timestamp{2024, 6, 15, 14, 30, 20, 123456000}; + TBoundParam param{ + 1, SQL_C_TYPE_TIMESTAMP, SQL_TYPE_TIMESTAMP, 0, 0, + ×tamp, sizeof(timestamp), nullptr + }; + TParamsBuilder paramsBuilder; + ASSERT_EQ(ConvertParam(param, paramsBuilder.AddParam("$p1")), SQL_SUCCESS); + const auto value = paramsBuilder.Build().GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetType().GetProto(), "type_id: TIMESTAMP\n"); + TValueParser timestampParser(*value); + EXPECT_EQ(timestampParser.GetTimestamp(), TInstant::MicroSeconds(1718461820123456)); + for (const auto& [fraction, state] : { + std::pair{123456001, "22008"}, + {999999999, "22008"}, {1000000000, "22007"}}) { + timestamp.fraction = fraction; + TParamsBuilder invalid; + EXPECT_EQ(ConvertParam(param, invalid.AddParam("$p1")), SQL_ERROR); + EXPECT_STREQ(ConsumeLastConvertSqlState(), state); + } + + SQL_DATE_STRUCT date{1960, 2, 29}, fetched{}; + TBoundParam wideDate{1, SQL_C_TYPE_DATE, SQL_TYPE_DATE, 0, 0, &date, sizeof(date), nullptr}; + wideDate.WideTemporal = EWideTemporal::Date32; + TParamsBuilder wideBuilder; + ASSERT_EQ(ConvertParam(wideDate, wideBuilder.AddParam("$date")), SQL_SUCCESS); + const auto dateValue = wideBuilder.Build().GetValue("$date"); + ASSERT_TRUE(dateValue); + CheckProto(dateValue->GetType().GetProto(), "type_id: DATE32\n"); + TValueParser dateParser(*dateValue); + ASSERT_EQ(ConvertColumn(dateParser, SQL_C_TYPE_DATE, &fetched, sizeof(fetched), nullptr), SQL_SUCCESS); + EXPECT_EQ(fetched.year, 1960); + EXPECT_EQ(fetched.month, 2); + EXPECT_EQ(fetched.day, 29); + + timestamp = {1960, 2, 29, 12, 0, 0, 0}; + param.WideTemporal = EWideTemporal::Datetime64; + TParamsBuilder datetimeBuilder; + ASSERT_EQ(ConvertParam(param, datetimeBuilder.AddParam("$datetime")), SQL_SUCCESS); + const auto datetimeValue = datetimeBuilder.Build().GetValue("$datetime"); + ASSERT_TRUE(datetimeValue); + CheckProto(datetimeValue->GetType().GetProto(), "type_id: DATETIME64\n"); + TValueParser datetimeParser(*datetimeValue); + EXPECT_EQ(datetimeParser.GetDatetime64(), + std::chrono::sys_days(std::chrono::year{1960} / 2 / 29) + std::chrono::hours(12)); + for (const SQLUINTEGER fraction : {1U, 1000U, 123456000U}) { + timestamp.fraction = fraction; + TParamsBuilder invalid; + EXPECT_EQ(ConvertParam(param, invalid.AddParam("$datetime")), SQL_ERROR); + EXPECT_STREQ(ConsumeLastConvertSqlState(), "22008"); + } + param.IsNullData = true; + TParamsBuilder nullDatetimeBuilder; + ASSERT_EQ(ConvertParam(param, nullDatetimeBuilder.AddParam("$datetime")), SQL_SUCCESS); + const auto nullDatetimeValue = nullDatetimeBuilder.Build().GetValue("$datetime"); + ASSERT_TRUE(nullDatetimeValue); + CheckProto(nullDatetimeValue->GetType().GetProto(), + "optional_type {\n item {\n type_id: DATETIME64\n }\n}\n"); + TValueParser nullDatetimeParser(*nullDatetimeValue); + EXPECT_FALSE(nullDatetimeParser.GetOptionalDatetime64()); + + const std::tuple temporal[] = { + {"2024-06-15", SQL_TYPE_DATE, ""}, {"14:30:20", SQL_TYPE_TIME, ""}, + {"2024-06-15", SQL_TYPE_TIME, "22018"}, + {" 2024-06-15 14:30:20.123456 ", SQL_TYPE_TIMESTAMP, ""}, + {"2024-06-15 14:30:20.123456789", SQL_TYPE_TIMESTAMP, "22008"}, + {"14:30:20.5", SQL_TYPE_TIMESTAMP, ""}, + {"bad", SQL_TYPE_DATE, "22018"}, + }; + for (const auto& [text, type, state] : temporal) { + SQLLEN length = SQL_NTS; + TParamsBuilder builder; + const TBoundParam parameter{1, SQL_C_CHAR, type, 0, 0, const_cast(text), 0, &length}; + ASSERT_EQ(ConvertParam(parameter, builder.AddParam("$p1")), *state ? SQL_ERROR : SQL_SUCCESS); + if (*state) { + EXPECT_STREQ(ConsumeLastConvertSqlState(), state); + continue; + } + const auto converted = builder.Build().GetValue("$p1"); + TValueParser parser(*converted); + if (type == SQL_TYPE_DATE) EXPECT_EQ(parser.GetDate(), TInstant::Days(19889)); + else if (type == SQL_TYPE_TIME) EXPECT_EQ(parser.GetDatetime(), TInstant::Seconds(52220)); + else if (text[2] == ':') { + EXPECT_EQ(parser.GetTimestamp().MicroSeconds() % TDuration::Days(1).MicroSeconds(), 52220500000ULL); + } else EXPECT_EQ(parser.GetTimestamp(), TInstant::MicroSeconds(1718461820123456)); + } +} + +TEST(OdbcConvert, DoubleToYdb) { + SQLDOUBLE v = 3.14; + TBoundParam param{ + 1, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetType().GetProto(), "type_id: DOUBLE\n"); + CheckProto(value->GetProto(), "double_value: 3.14\n"); +} + +TEST(OdbcConvert, DoubleToYdbDecimalPreservesPrecisionAndScale) { + SQLDOUBLE v = 123.456; + TBoundParam param{ + 1, SQL_C_DOUBLE, SQL_DECIMAL, 18, 5, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ASSERT_EQ(ConvertParam(param, paramsBuilder.AddParam("$p1")), SQL_SUCCESS); + const auto value = paramsBuilder.Build().GetValue("$p1"); + ASSERT_TRUE(value); + + TValueParser parser(*value); + const auto decimal = parser.GetDecimal(); + EXPECT_EQ(decimal.DecimalType_.Precision, 18); + EXPECT_EQ(decimal.DecimalType_.Scale, 5); + EXPECT_EQ(decimal.ToString(), "123.456"); + + char text[16] = {}; + SQLLEN textLength = 0; + ASSERT_EQ(ConvertColumn(parser, SQL_C_CHAR, text, sizeof(text), &textLength), SQL_SUCCESS); + EXPECT_EQ(textLength, 9); + EXPECT_STREQ(text, "123.45600"); +} + +TEST(OdbcConvert, StringToYdbUtf8) { + const char* str = "hello"; + SQLLEN len = 5; + TBoundParam param{ + 1, SQL_C_CHAR, SQL_VARCHAR, 0, 0, (SQLPOINTER)str, len, nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetType().GetProto(), "type_id: UTF8\n"); + CheckProto(value->GetProto(), "text_value: \"hello\"\n"); +} + +TEST(OdbcConvert, StringToYdbBinary) { + const char* str = "bin\x01\x02"; + SQLLEN len = 5; + TBoundParam param{ + 1, SQL_C_BINARY, SQL_BINARY, 0, 0, (SQLPOINTER)str, len, nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetType().GetProto(), "type_id: STRING\n"); + CheckProto(value->GetProto(), "bytes_value: \"bin\\001\\002\"\n"); + + TValueParser parser(*value); + SQLLEN offset = 0; + char chunk[4]; + std::string hex; + for (int i = 0; i < 4; ++i) { + ASSERT_EQ(ConvertColumn(parser, SQL_C_CHAR, chunk, sizeof(chunk), &len, &offset), + i == 3 ? SQL_SUCCESS : SQL_SUCCESS_WITH_INFO); + hex += chunk; + } + EXPECT_EQ(hex, "62696e0102"); + EXPECT_EQ(ConvertColumn(parser, SQL_C_CHAR, chunk, sizeof(chunk), &len, &offset), SQL_NO_DATA); + offset = 0; + SQLWCHAR wide[4]; + ASSERT_EQ(ConvertColumn(parser, SQL_C_WCHAR, wide, sizeof(wide), &len, &offset), SQL_SUCCESS_WITH_INFO); + EXPECT_EQ(len, 10 * sizeof(SQLWCHAR)); + EXPECT_EQ(wide[0], '6'); + EXPECT_EQ(wide[1], '2'); + EXPECT_EQ(wide[2], '6'); + ASSERT_EQ(ConvertColumn(parser, SQL_C_WCHAR, wide, sizeof(wide), &len, &offset), SQL_SUCCESS_WITH_INFO); + EXPECT_EQ(wide[0], '9'); + EXPECT_EQ(wide[1], '6'); + EXPECT_EQ(wide[2], 'e'); + + // Binary input to character SQL types preserves its bytes, including NULs. + char bytes[] = {'a', 0, 'b'}; + SQLLEN length = sizeof(bytes); + for (SQLSMALLINT type : {SQL_VARCHAR, SQL_WVARCHAR}) { + TParamsBuilder builder; + ASSERT_EQ(ConvertParam({1, SQL_C_BINARY, type, 0, 0, bytes, sizeof(bytes), &length}, + builder.AddParam("$p1")), SQL_SUCCESS); + const auto converted = builder.Build().GetValue("$p1"); + TValueParser text(*converted); + EXPECT_EQ(text.GetUtf8(), std::string(bytes, sizeof(bytes))); + } +} + +TEST(OdbcConvert, NativeValuesToCharacterParameters) { + SQLINTEGER integer = 42; + SQLDOUBLE real = 0.1; + SQLREAL single = 0.1f; + SQL_DATE_STRUCT date{1960, 2, 29}; + SQL_TIMESTAMP_STRUCT timestamp{2026, 10, 26, 12, 34, 56, 123456789}; + SQL_TIME_STRUCT time{12, 34, 56}; + const std::pair cases[] = { + {{1, SQL_C_LONG, SQL_VARCHAR, 0, 0, &integer, 0, nullptr}, "42"}, + {{1, SQL_C_DOUBLE, SQL_VARCHAR, 0, 0, &real, 0, nullptr}, "0.1"}, + {{1, SQL_C_FLOAT, SQL_VARCHAR, 0, 0, &single, 0, nullptr}, "0.1"}, + {{1, SQL_C_TYPE_DATE, SQL_VARCHAR, 0, 0, &date, 0, nullptr}, "1960-02-29"}, + {{1, SQL_C_TYPE_TIMESTAMP, SQL_VARCHAR, 0, 0, ×tamp, 0, nullptr}, "2026-10-26 12:34:56.123456789"}, + {{1, SQL_C_TYPE_TIME, SQL_VARCHAR, 0, 0, &time, 0, nullptr}, "12:34:56"}, + }; + for (const auto& [parameter, expected] : cases) { + TParamsBuilder builder; + ASSERT_EQ(ConvertParam(parameter, builder.AddParam("$p1")), SQL_SUCCESS); + const auto value = builder.Build().GetValue("$p1"); + TValueParser parser(*value); + EXPECT_EQ(parser.GetUtf8(), expected); + } + date.month = 257; + TParamsBuilder invalid; + EXPECT_EQ(ConvertParam({1, SQL_C_TYPE_DATE, SQL_VARCHAR, 0, 0, &date, 0, nullptr}, + invalid.AddParam("$p1")), SQL_ERROR); + EXPECT_STREQ(ConsumeLastConvertSqlState(), "22008"); +} + +TEST(OdbcConvert, CharacterToNumericParameters) { + const std::tuple cases[] = { + {" +42 ", SQL_INTEGER, "", 42}, {"2147483648", SQL_INTEGER, "22001", 0}, {"bad", SQL_INTEGER, "22018", 0}, + {"+-42", SQL_INTEGER, "22018", 0}, {"1.0", SQL_INTEGER, "", 1}, {"1e2", SQL_INTEGER, "", 100}, + {"1.5", SQL_INTEGER, "22001", 0}, {"1e+-2", SQL_INTEGER, "22018", 0}, + {"9007199254740993.0", SQL_BIGINT, "", 9007199254740993LL}, + {"9.223372036854775807e18", SQL_BIGINT, "", 9223372036854775807LL}, + {"0e999999999999", SQL_INTEGER, "", 0}, {"1.00000000000000000001", SQL_INTEGER, "22001", 0}, + {"1.00000000000000000001", SQL_BIT, "22001", 0}, + {"1.25", SQL_DOUBLE, "", 0}, {"1e999", SQL_DOUBLE, "22003", 0}, + {"0x10", SQL_DOUBLE, "22018", 0}, {"0X2", SQL_BIT, "22018", 0}, + }; + for (const auto& [text, type, state, expected] : cases) { + SQLLEN length = SQL_NTS; + const TBoundParam parameter{1, SQL_C_CHAR, type, 10, 0, + const_cast(text), 0, &length}; + TParamsBuilder builder; + EXPECT_EQ(ConvertParam(parameter, builder.AddParam("$p1")), *state ? SQL_ERROR : SQL_SUCCESS); + if (*state) { + EXPECT_STREQ(ConsumeLastConvertSqlState(), state); + } else { + const auto value = builder.Build().GetValue("$p1"); + TValueParser parser(*value); + if (type == SQL_INTEGER) EXPECT_EQ(parser.GetInt32(), expected); + else if (type == SQL_BIGINT) EXPECT_EQ(parser.GetInt64(), expected); + else EXPECT_EQ(parser.GetDouble(), 1.25); + } + } + SQLINTEGER integer = 42; + SQLDOUBLE real = 42.75, overflow = 9223372036854775808.0; + const std::pair numeric[] = { + {{1, SQL_C_LONG, SQL_DOUBLE, 0, 0, &integer, 0, nullptr}, ""}, + {{1, SQL_C_DOUBLE, SQL_INTEGER, 0, 0, &real, 0, nullptr}, ""}, + {{1, SQL_C_DOUBLE, SQL_BIGINT, 0, 0, &overflow, 0, nullptr}, "22003"}, + }; + for (const auto& [parameter, state] : numeric) { + TParamsBuilder builder; + EXPECT_EQ(ConvertParam(parameter, builder.AddParam("$p1")), *state ? SQL_ERROR : SQL_SUCCESS); + if (*state) EXPECT_STREQ(ConsumeLastConvertSqlState(), state); + else { + const auto value = builder.Build().GetValue("$p1"); + TValueParser parser(*value); + if (parameter.ParameterType == SQL_DOUBLE) EXPECT_EQ(parser.GetDouble(), 42); + else EXPECT_EQ(parser.GetInt32(), 42); + } + } +} + +TEST(OdbcConvert, Int64NullToYdb) { + SQLBIGINT v = 42; + SQLLEN nullInd = SQL_NULL_DATA; + TBoundParam param{ + 1, SQL_C_SBIGINT, SQL_BIGINT, 0, 0, &v, sizeof(v), &nullInd + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetType().GetProto(), "optional_type {\n item {\n type_id: INT64\n }\n}\n"); + CheckProto(value->GetProto(), "null_flag_value: NULL_VALUE\n"); +} + +TEST(OdbcConvert, StringNullToYdb) { + const char* str = "test"; + SQLLEN nullInd = SQL_NULL_DATA; + TBoundParam param{ + 1, SQL_C_CHAR, SQL_VARCHAR, 0, 0, (SQLPOINTER)str, 4, &nullInd + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetType().GetProto(), "optional_type {\n item {\n type_id: UTF8\n }\n}\n"); + CheckProto(value->GetProto(), "null_flag_value: NULL_VALUE\n"); +} + +TEST(OdbcConvert, Int32ToYdb) { + SQLINTEGER v = 42; + TBoundParam param{ + 1, SQL_C_LONG, SQL_INTEGER, 0, 0, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetType().GetProto(), "type_id: INT32\n"); + CheckProto(value->GetProto(), "int32_value: 42\n"); +} + +TEST(OdbcConvert, NonNullValueCanUseOptionalDeclaredType) { + SQLINTEGER v = 42; + TBoundParam param{ + 1, SQL_C_LONG, SQL_INTEGER, 0, 0, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ASSERT_EQ(ConvertParam(param, paramsBuilder.AddParam("$p1"), true), SQL_SUCCESS); + const auto value = paramsBuilder.Build().GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetType().GetProto(), + "optional_type {\n item {\n type_id: INT32\n }\n}\n"); + CheckProto(value->GetProto(), "int32_value: 42\n"); +} + +TEST(OdbcConvert, Int32NegativeToYdb) { + SQLINTEGER v = -999; + TBoundParam param{ + 1, SQL_C_LONG, SQL_INTEGER, 0, 0, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "int32_value: -999\n"); +} + +TEST(OdbcConvert, Int32ZeroToYdb) { + SQLINTEGER v = 0; + TBoundParam param{ + 1, SQL_C_LONG, SQL_INTEGER, 0, 0, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "int32_value: 0\n"); +} + +TEST(OdbcConvert, Int32MaxToYdb) { + SQLINTEGER v = 2147483647; // INT32_MAX + TBoundParam param{ + 1, SQL_C_LONG, SQL_INTEGER, 0, 0, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "int32_value: 2147483647\n"); +} + +TEST(OdbcConvert, Int32NullToYdb) { + SQLINTEGER v = 42; + SQLLEN nullInd = SQL_NULL_DATA; + TBoundParam param{ + 1, SQL_C_LONG, SQL_INTEGER, 0, 0, &v, sizeof(v), &nullInd + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "null_flag_value: NULL_VALUE\n"); +} + +TEST(OdbcConvert, Int64NegativeToYdb) { + SQLBIGINT v = -123456789012345LL; + TBoundParam param{ + 1, SQL_C_SBIGINT, SQL_BIGINT, 0, 0, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "int64_value: -123456789012345\n"); +} + +TEST(OdbcConvert, Int64ZeroToYdb) { + SQLBIGINT v = 0; + TBoundParam param{ + 1, SQL_C_SBIGINT, SQL_BIGINT, 0, 0, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "int64_value: 0\n"); +} + +TEST(OdbcConvert, DoubleNegativeToYdb) { + SQLDOUBLE v = -2.71828; + TBoundParam param{ + 1, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); +} + +TEST(OdbcConvert, DoubleZeroToYdb) { + SQLDOUBLE v = 0.0; + TBoundParam param{ + 1, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &v, sizeof(v), nullptr + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "double_value: 0\n"); +} + +TEST(OdbcConvert, DoubleNullToYdb) { + SQLDOUBLE v = 3.14; + SQLLEN nullInd = SQL_NULL_DATA; + TBoundParam param{ + 1, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &v, sizeof(v), &nullInd + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "null_flag_value: NULL_VALUE\n"); +} + +TEST(OdbcConvert, StringEmptyToYdb) { + const char* str = ""; + SQLLEN len = 0; + TBoundParam param{ + 1, SQL_C_CHAR, SQL_VARCHAR, 0, 0, (SQLPOINTER)str, len, &len + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "text_value: \"\"\n"); +} + +TEST(OdbcConvert, StringUnicodeToYdb) { + const char* str = "ΠŸΡ€ΠΈΠ²Π΅Ρ‚"; + SQLLEN len = SQL_NTS; + TBoundParam param{ + 1, SQL_C_CHAR, SQL_VARCHAR, 0, 0, (SQLPOINTER)str, 0, &len + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); +} + +TEST(OdbcConvert, StringWithLengthToYdb) { + const char* str = "hello world"; + SQLLEN len = 5; // Only "hello" + TBoundParam param{ + 1, SQL_C_CHAR, SQL_VARCHAR, 0, 0, (SQLPOINTER)str, len, &len + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "text_value: \"hello\"\n"); +} + +TEST(OdbcConvert, StringNullTerminatedToYdb) { + const char* str = "test"; + SQLLEN len = SQL_NTS; + TBoundParam param{ + 1, SQL_C_CHAR, SQL_VARCHAR, 0, 0, (SQLPOINTER)str, 0, &len + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "text_value: \"test\"\n"); +} + + +TEST(OdbcConvert, BinaryNullToYdb) { + const char* data = "\x01\x02\x03"; + SQLLEN nullInd = SQL_NULL_DATA; + TBoundParam param{ + 1, SQL_C_BINARY, SQL_BINARY, 0, 0, (SQLPOINTER)data, 3, &nullInd + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "null_flag_value: NULL_VALUE\n"); +} + +TEST(OdbcConvert, BinaryEmptyToYdb) { + const char* data = ""; + SQLLEN len = 0; + TBoundParam param{ + 1, SQL_C_BINARY, SQL_BINARY, 0, 0, (SQLPOINTER)data, len, &len + }; + TParamsBuilder paramsBuilder; + ConvertParam(param, paramsBuilder.AddParam("$p1")); + auto params = paramsBuilder.Build(); + auto value = params.GetValue("$p1"); + ASSERT_TRUE(value); + CheckProto(value->GetProto(), "bytes_value: \"\"\n"); +} + +TEST(OdbcConvert, VirtualScalarUsesSharedIntegerConversion) { + const TOdbcScalar value = int64_t{123}; + SQLSMALLINT result = 0; + SQLLEN length = 0; + + ASSERT_EQ(ConvertColumn(value, SQL_C_SHORT, &result, sizeof(result), &length), SQL_SUCCESS); + EXPECT_EQ(result, 123); + EXPECT_EQ(length, sizeof(result)); +} + +TEST(OdbcConvert, VirtualScalarPreservesRangeSqlState) { + const TOdbcScalar value = uint64_t{256}; + SQLCHAR result = 0; + + EXPECT_EQ(ConvertColumn(value, SQL_C_UTINYINT, &result, sizeof(result), nullptr), SQL_ERROR); + EXPECT_STREQ(ConsumeLastConvertSqlState(), "22003"); +} + +TEST(OdbcConvert, VirtualScalarNullRequiresIndicator) { + const TOdbcScalar value = std::monostate{}; + + EXPECT_EQ(ConvertColumn(value, SQL_C_CHAR, nullptr, 0, nullptr), SQL_ERROR); + EXPECT_STREQ(ConsumeLastConvertSqlState(), "22002"); +} + +TEST(OdbcConvert, InvalidUtf8ToWidePreservesConversionState) { + const TOdbcScalar value = std::string("\xff", 1); + SQLWCHAR output[2] = {}; + + EXPECT_EQ(ConvertColumn(value, SQL_C_WCHAR, output, sizeof(output), nullptr), SQL_ERROR); + EXPECT_STREQ(ConsumeLastConvertSqlState(), "22018"); +} diff --git a/odbc/tests/unit/cursor_ut.cpp b/odbc/tests/unit/cursor_ut.cpp new file mode 100644 index 00000000000..32b51e8db98 --- /dev/null +++ b/odbc/tests/unit/cursor_ut.cpp @@ -0,0 +1,132 @@ +#include "utils/cursor_window.h" + +#include + +#include + +namespace NYdb::NOdbc { +namespace { + +TEST(CursorWindow, PreservesScrollableRowsetPositioning) { + TCursorWindow window(7); + EXPECT_EQ(window.RowNumber(), 0); + + auto fetch = window.Fetch(SQL_FETCH_NEXT, 0, 3, 0); + EXPECT_EQ(fetch.Rows, 3); + EXPECT_FALSE(fetch.OverlappedStart); + EXPECT_EQ(window.Resolve(0), 0); + EXPECT_EQ(window.Resolve(2), 2); + EXPECT_EQ(window.RowNumber(), 1); + + fetch = window.Fetch(SQL_FETCH_NEXT, 0, 2, 0); + EXPECT_EQ(fetch.Rows, 2); + EXPECT_EQ(window.Resolve(0), 3); + EXPECT_EQ(window.RowNumber(), 4); + + fetch = window.Fetch(SQL_FETCH_PRIOR, 0, 2, 0); + EXPECT_EQ(fetch.Rows, 2); + EXPECT_EQ(window.Resolve(0), 1); + EXPECT_EQ(window.RowNumber(), 2); + + fetch = window.Fetch(SQL_FETCH_LAST, 0, 2, 0); + EXPECT_EQ(fetch.Rows, 2); + EXPECT_EQ(window.Resolve(0), 5); + EXPECT_EQ(window.RowNumber(), 6); + + fetch = window.Fetch(SQL_FETCH_ABSOLUTE, -3, 2, 0); + EXPECT_EQ(fetch.Rows, 2); + EXPECT_EQ(window.Resolve(0), 4); + + EXPECT_EQ(window.Fetch(SQL_FETCH_ABSOLUTE, 0, 2, 0).Rows, 0); + EXPECT_FALSE(window.Resolve(0)); + EXPECT_EQ(window.RowNumber(), 0); + EXPECT_EQ(window.Fetch(SQL_FETCH_NEXT, 0, 2, 0).Rows, 2); + EXPECT_EQ(window.Resolve(0), 0); + + EXPECT_EQ(window.Fetch(SQL_FETCH_ABSOLUTE, 100, 2, 0).Rows, 0); + EXPECT_EQ(window.RowNumber(), 0); + EXPECT_EQ(window.Fetch(SQL_FETCH_PRIOR, 0, 2, 0).Rows, 2); + EXPECT_EQ(window.Resolve(0), 5); + + ASSERT_EQ(window.Fetch(SQL_FETCH_ABSOLUTE, 2, 2, 0).Rows, 2); + fetch = window.Fetch(SQL_FETCH_PRIOR, 0, 2, 0); + EXPECT_EQ(fetch.Rows, 2); + EXPECT_TRUE(fetch.OverlappedStart); + EXPECT_EQ(window.Resolve(0), 0); + + fetch = window.Fetch(SQL_FETCH_ABSOLUTE, -1, 2, 0); + EXPECT_EQ(fetch.Rows, 1); + EXPECT_EQ(window.Resolve(0), 6); + EXPECT_FALSE(window.Resolve(1)); +} + +TEST(CursorWindow, AppliesLimitBeforePositioning) { + TCursorWindow window(8); + auto fetch = window.Fetch(SQL_FETCH_LAST, 0, 3, 5); + EXPECT_EQ(fetch.Rows, 3); + EXPECT_EQ(window.Resolve(0), 2); + EXPECT_EQ(window.Resolve(2), 4); + + EXPECT_EQ(window.Fetch(SQL_FETCH_ABSOLUTE, 6, 3, 5).Rows, 0); + EXPECT_EQ(window.Fetch(SQL_FETCH_PRIOR, 0, 3, 5).Rows, 3); + EXPECT_EQ(window.Resolve(0), 2); +} + +TEST(CursorWindow, ResolvesRelativePositionsAtBoundaries) { + TCursorWindow window(7); + + EXPECT_EQ(window.Fetch(SQL_FETCH_RELATIVE, -1, 2, 0).Rows, 0); + EXPECT_EQ(window.Fetch(SQL_FETCH_RELATIVE, 2, 2, 0).Rows, 2); + EXPECT_EQ(window.Resolve(0), 1); + + auto fetch = window.Fetch(SQL_FETCH_RELATIVE, -2, 2, 0); + EXPECT_EQ(fetch.Rows, 2); + EXPECT_TRUE(fetch.OverlappedStart); + EXPECT_EQ(window.Resolve(0), 0); + + EXPECT_EQ(window.Fetch(SQL_FETCH_RELATIVE, 4, 2, 0).Rows, 2); + EXPECT_EQ(window.Resolve(0), 4); + + EXPECT_EQ(window.Fetch(SQL_FETCH_ABSOLUTE, 100, 2, 0).Rows, 0); + EXPECT_EQ(window.Fetch(SQL_FETCH_RELATIVE, -2, 2, 0).Rows, 2); + EXPECT_EQ(window.Resolve(0), 5); +} + +TEST(CursorWindow, DetectsRelativeRowsetsOverlappingTheBeginning) { + TCursorWindow window(10); + + ASSERT_EQ(window.Fetch(SQL_FETCH_ABSOLUTE, 6, 2, 0).Rows, 2); + auto fetch = window.Fetch(SQL_FETCH_RELATIVE, -6, 2, 0); + EXPECT_EQ(fetch.Rows, 2); + EXPECT_TRUE(fetch.OverlappedStart); + EXPECT_EQ(window.Resolve(0), 0); + EXPECT_EQ(window.Resolve(1), 1); + + ASSERT_EQ(window.Fetch(SQL_FETCH_ABSOLUTE, 6, 2, 0).Rows, 2); + fetch = window.Fetch(SQL_FETCH_RELATIVE, -7, 2, 0); + EXPECT_EQ(fetch.Rows, 0); + EXPECT_FALSE(fetch.OverlappedStart); + EXPECT_FALSE(window.Resolve(0)); +} + +TEST(CursorWindow, HandlesEmptyAndExtremeOffsets) { + TCursorWindow empty(0); + EXPECT_EQ(empty.Fetch(SQL_FETCH_FIRST, 0, 1, 0).Rows, 0); + EXPECT_EQ(empty.Fetch(SQL_FETCH_LAST, 0, 1, 0).Rows, 0); + EXPECT_EQ(empty.Fetch(SQL_FETCH_ABSOLUTE, + std::numeric_limits::min(), 1, 0).Rows, + 0); + + TCursorWindow window(3); + EXPECT_EQ(window.Fetch(SQL_FETCH_NEXT, 0, 0, 0).Rows, 0); + EXPECT_FALSE(window.Resolve(0)); + + ASSERT_EQ(window.Fetch(SQL_FETCH_ABSOLUTE, 2, + std::numeric_limits::max(), 0).Rows, + 2); + EXPECT_EQ(window.Fetch(SQL_FETCH_NEXT, 0, 1, 0).Rows, 0); + EXPECT_FALSE(window.Resolve(0)); +} + +} // namespace +} // namespace NYdb::NOdbc diff --git a/odbc/tests/unit/descriptor_ut.cpp b/odbc/tests/unit/descriptor_ut.cpp new file mode 100644 index 00000000000..c3754bd8853 --- /dev/null +++ b/odbc/tests/unit/descriptor_ut.cpp @@ -0,0 +1,151 @@ +#include "connection.h" +#include "descriptor.h" +#include "statement.h" + +#include + +namespace NYdb::NOdbc { +namespace { + +class TOdbcDescriptor : public ::testing::Test { +protected: + TConnection Connection_; + TDescriptor Descriptor_{&Connection_}; + std::unique_lock Lock_ = Descriptor_.LockOperation(); +}; + +TEST_F(TOdbcDescriptor, ScalarUpdatePreservesOtherFields) { + std::string name(256, 'x'); + ASSERT_EQ(Descriptor_.SetDescField(1, SQL_DESC_NAME, name.data(), SQL_NTS), SQL_SUCCESS); + SQLINTEGER value = 42; + ASSERT_EQ(Descriptor_.SetDescField(1, SQL_DESC_DATA_PTR, &value, 0), SQL_SUCCESS); + ASSERT_EQ(Descriptor_.SetDescField(1, SQL_DESC_CONCISE_TYPE, + reinterpret_cast(SQL_C_LONG), 0), SQL_SUCCESS); + + char output[257] = {}; + ASSERT_EQ(Descriptor_.GetDescField(1, SQL_DESC_NAME, output, sizeof(output), nullptr), SQL_SUCCESS); + EXPECT_EQ(output, name); + SQLPOINTER pointer = nullptr; + ASSERT_EQ(Descriptor_.GetDescField(1, SQL_DESC_DATA_PTR, &pointer, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(pointer, &value); + SQLSMALLINT type = 0; + ASSERT_EQ(Descriptor_.GetDescField(1, SQL_DESC_CONCISE_TYPE, &type, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(type, SQL_C_LONG); +} + +TEST_F(TOdbcDescriptor, RejectedFieldsLeaveDescriptorUnchanged) { + char name[] = "original"; + ASSERT_EQ(Descriptor_.SetDescField(1, SQL_DESC_NAME, name, SQL_NTS), SQL_SUCCESS); + const auto generation = Descriptor_.GetGeneration(); + + EXPECT_EQ(Descriptor_.SetDescField(2, SQL_DESC_NAME, name, -7), SQL_ERROR); + SQLCHAR state[6] = {}; + ASSERT_EQ(Descriptor_.GetDiagRec(1, state, nullptr, nullptr, 0, nullptr), SQL_SUCCESS); + EXPECT_STREQ(reinterpret_cast(state), "HY090"); + EXPECT_EQ(Descriptor_.SetDescField(2, SQL_DESC_NAME, nullptr, SQL_NTS), SQL_ERROR); + EXPECT_EQ(Descriptor_.SetDescField(2, 32767, nullptr, 0), SQL_ERROR); + EXPECT_THROW(Descriptor_.SetDescField(0, SQL_DESC_CONCISE_TYPE, + reinterpret_cast(SQL_C_LONG), 0), TOdbcException); + EXPECT_EQ(Descriptor_.GetGeneration(), generation); + + SQLSMALLINT count = 0; + ASSERT_EQ(Descriptor_.GetDescField(0, SQL_DESC_COUNT, &count, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(count, 1); + char output[16] = {}; + ASSERT_EQ(Descriptor_.GetDescField(1, SQL_DESC_NAME, output, sizeof(output), nullptr), SQL_SUCCESS); + EXPECT_STREQ(output, name); +} + +TEST_F(TOdbcDescriptor, FetchUsesLatestColumnBinding) { + TStatement statement(&Connection_); + ASSERT_EQ(statement.GetTypeInfo(SQL_INTEGER), SQL_SUCCESS); + SQLINTEGER first = 111, second = 222; + ASSERT_EQ(statement.BindCol(2, SQL_C_LONG, &first, sizeof(first), nullptr), SQL_SUCCESS); + ASSERT_EQ(statement.BindCol(2, SQL_C_LONG, &second, sizeof(second), nullptr), SQL_SUCCESS); + ASSERT_EQ(statement.Fetch(), SQL_SUCCESS); + EXPECT_EQ(first, 111); + EXPECT_EQ(second, SQL_INTEGER); +} + +TEST(OdbcStatement, NoOpUnbindPreservesDescriptorGenerations) { + TConnection connection; + TStatement statement(&connection); + SQLINTEGER value = 0; + ASSERT_EQ(statement.BindCol(1, SQL_C_LONG, &value, sizeof(value), nullptr), SQL_SUCCESS); + SQLHDESC handle = SQL_NULL_HDESC; + ASSERT_EQ(statement.GetStmtAttr(SQL_ATTR_APP_ROW_DESC, &handle, 0, nullptr), SQL_SUCCESS); + auto& descriptor = *CheckedHandle(handle); + TDescriptorState before, after; + uint64_t generation = 0, nextGeneration = 0; + descriptor.Snapshot(before, generation); + + ASSERT_EQ(statement.BindCol(2, SQL_C_LONG, nullptr, 0, nullptr), SQL_SUCCESS); + descriptor.Snapshot(after, nextGeneration); + EXPECT_EQ(nextGeneration, generation); + EXPECT_EQ(after.GetSchemaGeneration(), before.GetSchemaGeneration()); + EXPECT_EQ(after.GetRecordCount(), 1); + + ASSERT_EQ(statement.BindCol(1, SQL_C_LONG, nullptr, 0, nullptr), SQL_SUCCESS); + descriptor.Snapshot(after, nextGeneration); + EXPECT_NE(nextGeneration, generation); + EXPECT_NE(after.GetSchemaGeneration(), before.GetSchemaGeneration()); + EXPECT_EQ(after.GetRecordCount(), 0); +} + +TEST(OdbcStatement, CancelClearsNeedDataAndAllowsReuse) { + TConnection connection; + TStatement statement(&connection); + ASSERT_EQ(statement.Prepare("SELECT ?"), SQL_SUCCESS); + char token = 0; + SQLLEN indicator = SQL_DATA_AT_EXEC; + ASSERT_EQ(statement.BindParameter(1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, + 16, 0, &token, 0, &indicator), SQL_SUCCESS); + ASSERT_EQ(statement.Execute(), SQL_NEED_DATA); + EXPECT_TRUE(statement.NeedsData()); + char data[] = "cancelled"; + EXPECT_THROW(statement.PutData(data, SQL_NTS), TOdbcException); + ASSERT_EQ(statement.Cancel(), SQL_SUCCESS); + EXPECT_FALSE(statement.NeedsData()); + ASSERT_EQ(statement.Execute(), SQL_NEED_DATA); + SQLPOINTER value = nullptr; + ASSERT_EQ(statement.ParamData(&value), SQL_NEED_DATA); + EXPECT_EQ(value, &token); + ASSERT_EQ(statement.PutData(data, SQL_NTS), SQL_SUCCESS); + + ASSERT_EQ(statement.Cancel(), SQL_SUCCESS); + EXPECT_FALSE(statement.NeedsData()); + EXPECT_EQ(statement.ParamData(&value), SQL_NO_DATA); + SQLRETURN result = SQL_ERROR; + ASSERT_EQ(statement.GetDiagField(0, SQL_DIAG_RETURNCODE, &result, 0, nullptr), SQL_SUCCESS); + EXPECT_EQ(result, SQL_SUCCESS); + + ASSERT_EQ(statement.Execute(), SQL_NEED_DATA); + EXPECT_TRUE(statement.NeedsData()); + ASSERT_EQ(statement.ParamData(&value), SQL_NEED_DATA); + EXPECT_EQ(value, &token); + EXPECT_EQ(statement.Cancel(), SQL_SUCCESS); +} + +TEST_F(TOdbcDescriptor, ExecuteUsesLatestParameterBinding) { + TStatement statement(&Connection_); + ASSERT_EQ(statement.Prepare("SELECT ?"), SQL_SUCCESS); + char first = 0, second = 0; + SQLLEN indicator = 0; + ASSERT_EQ(statement.BindParameter(1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, + 16, 0, &first, 0, &indicator), SQL_SUCCESS); + ASSERT_EQ(statement.BindParameter(1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, + 16, 0, &second, 0, &indicator), SQL_SUCCESS); + indicator = SQL_DATA_AT_EXEC; + ASSERT_EQ(statement.Execute(), SQL_NEED_DATA); + SQLPOINTER token = nullptr; + ASSERT_EQ(statement.ParamData(&token), SQL_NEED_DATA); + EXPECT_EQ(token, &second); + char data[] = "value"; + EXPECT_EQ(statement.PutData(data, SQL_NTS), SQL_SUCCESS); + SQLSMALLINT type = 0; + ASSERT_EQ(statement.DescribeParam(1, &type, nullptr, nullptr, nullptr), SQL_SUCCESS); + EXPECT_EQ(type, SQL_VARCHAR); +} + +} // namespace +} // namespace NYdb::NOdbc diff --git a/odbc/tests/unit/escape_ut.cpp b/odbc/tests/unit/escape_ut.cpp new file mode 100644 index 00000000000..3806c42788c --- /dev/null +++ b/odbc/tests/unit/escape_ut.cpp @@ -0,0 +1,102 @@ +#include "utils/escape.h" + +#include + +using NYdb::NOdbc::RewriteOdbcEscapes; + +TEST(OdbcEscapeRewrite, FnUnwraps) { + EXPECT_EQ(RewriteOdbcEscapes("SELECT {fn ABS(-12)} AS v"), "SELECT ABS(-12) AS v"); +} + +TEST(OdbcEscapeRewrite, FnCaseInsensitive) { + EXPECT_EQ(RewriteOdbcEscapes("{FN LOWER('A')}"), "LOWER('A')"); +} + +TEST(OdbcEscapeRewrite, OjUnwraps) { + EXPECT_EQ(RewriteOdbcEscapes("{oj LEFT OUTER JOIN t ON a=b}"), "LEFT OUTER JOIN t ON a=b"); +} + +TEST(OdbcEscapeRewrite, DateLiteral) { + EXPECT_EQ(RewriteOdbcEscapes("SELECT {d '2024-01-01'}"), "SELECT CAST('2024-01-01's AS Date)"); +} + +TEST(OdbcEscapeRewrite, TimeLiteral) { + EXPECT_EQ(RewriteOdbcEscapes("{t '14:30:00'}"), "CAST('1970-01-01T14:30:00Z's AS Datetime)"); +} + +TEST(OdbcEscapeRewrite, TimestampLiteralNormalizesSpaceToT) { + EXPECT_EQ( + RewriteOdbcEscapes("SELECT {ts '2024-06-15 14:30:00.123456'} AS v"), + "SELECT CAST('2024-06-15T14:30:00.123456Z's AS Timestamp) AS v"); +} + +TEST(OdbcEscapeRewrite, TimestampLiteralKeepsExistingZ) { + EXPECT_EQ( + RewriteOdbcEscapes("SELECT {ts '2024-06-15T14:30:00Z'} AS v"), + "SELECT CAST('2024-06-15T14:30:00Z's AS Timestamp) AS v"); +} + +TEST(OdbcEscapeRewrite, TemporalLiteralsWithUnicodeLiterals) { + EXPECT_EQ( + RewriteOdbcEscapes("--!ansi_lexer\nPRAGMA UnicodeLiterals;\n" + "SELECT {d '2024-01-01'}, {t '14:30:00'}, {ts '2024-06-15 14:30:00.123456'}"), + "--!ansi_lexer\nPRAGMA UnicodeLiterals;\n" + "SELECT CAST('2024-01-01's AS Date), CAST('1970-01-01T14:30:00Z's AS Datetime), " + "CAST('2024-06-15T14:30:00.123456Z's AS Timestamp)"); +} + +TEST(OdbcEscapeRewrite, Call) { + EXPECT_EQ(RewriteOdbcEscapes("{call sp_demo(1, 2)}"), "CALL sp_demo(1, 2)"); +} + +TEST(OdbcEscapeRewrite, OutputCallBecomesPlainCall) { + EXPECT_EQ(RewriteOdbcEscapes("{?= call sp(1)}"), "CALL sp(1)"); +} + +TEST(OdbcEscapeRewrite, EscapeClause) { + EXPECT_EQ(RewriteOdbcEscapes("LIKE 'a%' {escape '\\'}"), "LIKE 'a%' ESCAPE '\\'"); +} + +TEST(OdbcEscapeRewrite, ConvertOdbcToYqlCast) { + EXPECT_EQ( + RewriteOdbcEscapes("SELECT {fn CONVERT(42, SQL_SMALLINT)} AS v"), + "SELECT CAST(42 AS Int16) AS v"); +} + +TEST(OdbcEscapeRewrite, ConvertNestedInFn) { + EXPECT_EQ(RewriteOdbcEscapes("{fn CONVERT(x, SQL_INTEGER)}"), "CAST(x AS Int32)"); +} + +TEST(OdbcEscapeRewrite, NestedFnEscapes) { + EXPECT_EQ(RewriteOdbcEscapes("{fn {fn ABS(1)}}"), "ABS(1)"); +} + +TEST(OdbcEscapeRewrite, NestedConvertArguments) { + EXPECT_EQ( + RewriteOdbcEscapes("{fn CONVERT(COALESCE(x, 1), SQL_INTEGER)}"), + "CAST(COALESCE(x, 1) AS Int32)"); +} + +TEST(OdbcEscapeRewrite, LeavesQuotedEscapesAlone) { + EXPECT_EQ(RewriteOdbcEscapes("SELECT '{fn ABS(1)}'"), "SELECT '{fn ABS(1)}'"); +} + +TEST(OdbcEscapeRewrite, LeavesBackslashEscapedQuoteAlone) { + EXPECT_EQ( + RewriteOdbcEscapes("SELECT 'can\\'{fn ABS(1)}'"), + "SELECT 'can\\'{fn ABS(1)}'"); +} + +TEST(OdbcEscapeRewrite, LeavesCommentedEscapesAlone) { + EXPECT_EQ( + RewriteOdbcEscapes("-- {fn ABS(-1)}\nSELECT {fn ABS(-1)} /* {fn ABS(-2)} */"), + "-- {fn ABS(-1)}\nSELECT ABS(-1) /* {fn ABS(-2)} */"); +} + +TEST(OdbcEscapeRewrite, UnknownBraceLeftUnchanged) { + EXPECT_EQ(RewriteOdbcEscapes("{not_a_keyword 1}"), "{not_a_keyword 1}"); +} + +TEST(OdbcEscapeRewrite, EmptyInput) { + EXPECT_EQ(RewriteOdbcEscapes(""), ""); +} diff --git a/odbc/tests/unit/param_rewrite_ut.cpp b/odbc/tests/unit/param_rewrite_ut.cpp new file mode 100644 index 00000000000..f0c8d3c289f --- /dev/null +++ b/odbc/tests/unit/param_rewrite_ut.cpp @@ -0,0 +1,224 @@ +#include "utils/bindings.h" +#include "utils/param_rewrite.h" + +#include +#include + +using NYdb::NOdbc::RewriteOdbcSql; +using NYdb::NOdbc::CountOdbcParams; +using NYdb::NOdbc::GetDeclaredParamOptionality; +using NYdb::NOdbc::HasMultipleSqlStatements; +using NYdb::NOdbc::StartsWithSqlStatement; +using NYdb::NOdbc::TBoundParam; +using NYdb::NOdbc::BuildParamMetadataQuery; + +namespace { + +TBoundParam IntParam(SQLUSMALLINT n) { + static SQLINTEGER value = 0; + return {n, SQL_C_LONG, SQL_INTEGER, 0, 0, &value, 0, nullptr}; +} + +TBoundParam NullIntParam(SQLUSMALLINT n) { + static SQLINTEGER value = 0; + static SQLLEN indicator = SQL_NULL_DATA; + return {n, SQL_C_LONG, SQL_INTEGER, 0, 0, &value, 0, &indicator}; +} + +NYdb::NOdbc::TParamRewriteResult RewriteParams( + std::string_view sql, + const std::vector& params) { + return RewriteOdbcSql(sql, params, false); +} + +} // namespace + +TEST(OdbcParamRewrite, RewritesQuestionMarks) { + const std::vector params = {IntParam(1), IntParam(2)}; + const auto result = RewriteParams("SELECT ? + ? AS result", params); + ASSERT_TRUE(result.Success); + EXPECT_EQ(result.Sql, + "DECLARE $p1 AS Int32;\n" + "DECLARE $p2 AS Int32;\n" + "SELECT $p1 + $p2 AS result"); + EXPECT_EQ(RewriteParams("--!ansi_lexer\n/* header */ SELECT ? AS \"result\"", {IntParam(1)}).Sql, + "--!ansi_lexer\n/* header */ DECLARE $p1 AS Int32;\nSELECT $p1 AS \"result\""); +} + +TEST(OdbcParamRewrite, ParameterMetadataProbes) { + const std::pair cases[] = { + {"/* ? */ INSERT INTO `test` (`id`, str) VALUES (?, ?)", + "SELECT `id` AS __p1, str AS __p2 FROM `test` LIMIT 0"}, + {"SELECT * FROM t AS x WHERE x.id = ? AND x.str = ? ORDER BY id, str", + "SELECT x.id AS __p1, x.str AS __p2 FROM t AS x LIMIT 0"}, + {"SELECT * FROM t x WHERE x.id = ?", "SELECT x.id AS __p1 FROM t AS x LIMIT 0"}, + {"UPDATE t SET value = ?, id = ? WHERE id = ?", + "SELECT value AS __p1, id AS __p2, id AS __p3 FROM t LIMIT 0"}, + {"SELECT CASE WHEN (? = 1) THEN 1.5 ELSE 2.5 END, (? = 'x'), ? IS NULL", + "SELECT Just(1) AS __p1, NULL AS __p2, NULL AS __p3 LIMIT 0"}, + {"SELECT ? + 1.0 AS a", "SELECT Just(1.0) AS __p1 LIMIT 0"}, + {"SELECT 1.0 + ? AS a", "SELECT Just(1.0) AS __p1 LIMIT 0"}, + {"SELECT (? * 1e-3)", "SELECT Just(1e-3) AS __p1 LIMIT 0"}, + {"SELECT (? = -1)", "SELECT Just(-1) AS __p1 LIMIT 0"}, + {"--!ansi_lexer\nPRAGMA UnicodeLiterals;\nINSERT INTO t (id) VALUES (?)", + "--!ansi_lexer\nPRAGMA UnicodeLiterals;\nSELECT id AS __p1 FROM t LIMIT 0"}, + }; + for (const auto& [sql, expected] : cases) { + SCOPED_TRACE(sql); + EXPECT_EQ(BuildParamMetadataQuery(sql, true, 1, CountOdbcParams(sql)), expected); + } + for (const char* sql : {"SELECT ?", "SELECT (? = DangerousFunction())", + "SELECT * FROM t WHERE ? = DangerousFunction()", + "SELECT (? = 1 + 2)", "SELECT (? = 1); DELETE FROM t", "SELECT * FROM t, u WHERE t.id = ?", + "SELECT * FROM t WHERE price * ? > 100", "SELECT * FROM t WHERE ts - ? > Timestamp('2026-01-01')", + "PRAGMA TablePathPrefix = '/local'; SELECT ? = 1", + "SELECT * FROM t VIEW idx WHERE id = ?", "SELECT * FROM t SAMPLE 0.1 WHERE id = ?", + "SELECT * FROM t TABLESAMPLE SYSTEM(1) WHERE id = ?", "SELECT * FROM t FLATTEN BY a WHERE id = ?", + "SELECT ? + 1", "SELECT ? + 1.0 + 2", + "SELECT ? = 'x'", "SELECT CAST(? AS Int32)", + "DECLARE $p1 AS Int32?; SELECT $p1 = 1", + "SELECT * FROM t JOIN u ON t.id = u.id WHERE t.id = ?"}) { + SCOPED_TRACE(sql); + EXPECT_FALSE(BuildParamMetadataQuery(sql, true, 1, CountOdbcParams(sql))); + } + EXPECT_FALSE(BuildParamMetadataQuery("SELECT * FROM t WHERE id = ? AND ? IS NULL", true, 2, 2)); + EXPECT_FALSE(BuildParamMetadataQuery("SELECT ?, {fn CONVERT(?, SQL_INTEGER)}", true, 1, 1)); +} + +TEST(OdbcParamRewrite, RewritesEscapesAndParametersInOnePass) { + const auto result = RewriteOdbcSql( + "SELECT {fn CONVERT(?, SQL_INTEGER)}", {IntParam(1)}, true); + ASSERT_TRUE(result.Success); + EXPECT_EQ(result.Sql, "DECLARE $p1 AS Int32;\nSELECT CAST($p1 AS Int32)"); +} + +TEST(OdbcParamRewrite, UsesBoundCTypeForYdbDeclaration) { + SQLUBIGINT value = 42; + const std::vector params = {{ + 1, SQL_C_UBIGINT, SQL_BIGINT, 0, 0, + &value, sizeof(value), nullptr + }}; + EXPECT_EQ(RewriteParams("SELECT ?", params).Sql, + "DECLARE $p1 AS Uint64;\nSELECT $p1"); +} + +TEST(OdbcParamRewrite, PreservesTemporalAndDecimalTypes) { + SQL_TIMESTAMP_STRUCT timestamp{}; + SQLDOUBLE decimal = 0; + const std::vector params = { + {1, SQL_C_TYPE_TIMESTAMP, SQL_TYPE_TIMESTAMP, 0, 0, + ×tamp, sizeof(timestamp), nullptr}, + {2, SQL_C_DOUBLE, SQL_DECIMAL, 18, 5, + &decimal, sizeof(decimal), nullptr}, + }; + EXPECT_EQ(RewriteParams("SELECT ?, ?", params).Sql, + "DECLARE $p1 AS Timestamp;\n" + "DECLARE $p2 AS Decimal(18, 5);\n" + "SELECT $p1, $p2"); +} + +TEST(OdbcParamRewrite, SkipsLiteralAndYqlOptionalSyntax) { + const std::vector params = {IntParam(1)}; + EXPECT_EQ(RewriteParams("SELECT '?', ?", params).Sql, + "DECLARE $p1 AS Int32;\nSELECT '?', $p1"); + EXPECT_EQ(RewriteParams("DECLARE $p1 AS Int32?;\nSELECT $p1", params).Sql, + "DECLARE $p1 AS Int32?;\nSELECT $p1"); + EXPECT_EQ(CountOdbcParams("--!ansi_lexer\nSELECT '\\', ?"), 1); + EXPECT_EQ(RewriteParams("SELECT $p1 + 10", params).Sql, + "DECLARE $p1 AS Int32;\nSELECT $p1 + 10"); +} + +TEST(OdbcParamRewrite, DetectsOptionalDeclarationsBeforeComments) { + EXPECT_EQ(GetDeclaredParamOptionality( + "DECLARE $p1 AS Int32? /* nullable */;\nSELECT $p1", 1), true); + EXPECT_EQ(GetDeclaredParamOptionality( + "DECLARE $p1 AS Int32? -- nullable\n;\nSELECT $p1", 1), true); + EXPECT_EQ(GetDeclaredParamOptionality( + "DECLARE $p1 AS Int32 /* not optional?; */;\nSELECT $p1", 1), false); + EXPECT_EQ(GetDeclaredParamOptionality( + "/* DECLARE $p1 AS Int32?; */\nSELECT $p1", 1), std::nullopt); + EXPECT_EQ(GetDeclaredParamOptionality( + "pragma TablePathPrefix = \"/local\"; declare /* p */ $p1 as Int32?; SELECT $p1", 1), + true); +} + +TEST(OdbcParamRewrite, SkipsParameterMarkersInComments) { + const std::string sql = "SELECT ? -- optional ? $p8\n/* disabled $p9 ? */"; + const auto result = RewriteParams(sql, {IntParam(1)}); + ASSERT_TRUE(result.Success); + EXPECT_EQ(result.Sql, + "DECLARE $p1 AS Int32;\n" + "SELECT $p1 -- optional ? $p8\n/* disabled $p9 ? */"); + EXPECT_EQ(CountOdbcParams(sql), 1); + EXPECT_EQ(CountOdbcParams("SELECT 1 -- optional ? $p8"), 0); + EXPECT_EQ(CountOdbcParams("SELECT 1 /* disabled ? $p9"), 0); +} + +TEST(OdbcParamRewrite, PrependsDeclareForNativeDollarParams) { + const std::vector params = {IntParam(1), IntParam(2)}; + const auto result = RewriteParams("SELECT $p1 + $p2 AS result", params); + ASSERT_TRUE(result.Success); + EXPECT_EQ(result.Sql, + "DECLARE $p1 AS Int32;\n" + "DECLARE $p2 AS Int32;\n" + "SELECT $p1 + $p2 AS result"); +} + +TEST(OdbcParamRewrite, DeclaresOnlyNullValuesOptional) { + const auto result = RewriteParams( + "SELECT ?, ?", {IntParam(1), NullIntParam(2)}); + ASSERT_TRUE(result.Success); + EXPECT_EQ(result.Sql, + "DECLARE $p1 AS Int32;\n" + "DECLARE $p2 AS Int32?;\n" + "SELECT $p1, $p2"); +} + +TEST(OdbcParamRewrite, RejectsMismatchedBindCount) { + const auto result = RewriteParams("SELECT ? + ?", {IntParam(1)}); + ASSERT_FALSE(result.Success); + EXPECT_EQ(result.SqlState, "07002"); +} + +TEST(OdbcParamRewrite, CountOdbcParams) { + EXPECT_EQ(CountOdbcParams("SELECT ? + ?"), 2); + EXPECT_EQ(CountOdbcParams("SELECT $p1"), 1); + EXPECT_EQ(CountOdbcParams("SELECT $p1 + $p2"), 2); + EXPECT_EQ(CountOdbcParams("SELECT 1"), 0); +} + +TEST(OdbcParamRewrite, ParameterCountLimits) { + std::string markers; + for (size_t i = 0; i < 32767; ++i) markers += "?,"; + EXPECT_EQ(CountOdbcParams(markers), 32767); + EXPECT_EQ(CountOdbcParams("SELECT $p32767"), 32767); + EXPECT_TRUE(RewriteOdbcSql("SELECT $p32767", {IntParam(32767)}, false).Success); + markers += "?,"; + for (const auto& sql : {markers, markers + markers, std::string("SELECT $p32768"), + std::string("SELECT $p65536"), std::string("SELECT $p999999999999999999999")}) { + EXPECT_THROW(CountOdbcParams(sql), std::length_error); + EXPECT_THROW(RewriteOdbcSql(sql, {}, false), std::length_error); + } + EXPECT_EQ(CountOdbcParams("SELECT '$p999999999999999999999', '?' /* $p65536 ? */ -- ?"), 0); +} + +TEST(OdbcParamRewrite, ClassifiesAfterTrivia) { + EXPECT_TRUE(StartsWithSqlStatement(" -- lead\n /* block */ INSERT INTO t VALUES (1)", {"INSERT"})); + EXPECT_TRUE(StartsWithSqlStatement( + "PRAGMA TablePathPrefix = \"/local\"; DECLARE $p1 AS Int32; UPSERT INTO t VALUES ($p1)", + {"UPSERT"})); + EXPECT_TRUE(StartsWithSqlStatement( + "$rows = (SELECT 1); SELECT * FROM $rows; -- trailing", {"SELECT"})); + EXPECT_TRUE(StartsWithSqlStatement( + "DEFINE ACTION $read() AS SELECT 1; END DEFINE; SELECT 2", {"SELECT"})); + EXPECT_TRUE(StartsWithSqlStatement( + "PRAGMA config = \"quoted\\\";value\"; CREATE TABLE t (id Int32)", {"CREATE"})); + EXPECT_TRUE(StartsWithSqlStatement("DELETE FROM t; SELECT * FROM t", {"DELETE"})); + EXPECT_FALSE(StartsWithSqlStatement("DELETE FROM t; SELECT * FROM t", {"SELECT"})); + EXPECT_TRUE(HasMultipleSqlStatements("DELETE FROM t; SELECT * FROM t")); + EXPECT_TRUE(HasMultipleSqlStatements("PRAGMA x; DELETE FROM t; SELECT * FROM t")); + EXPECT_FALSE(HasMultipleSqlStatements("PRAGMA x; SELECT 1; -- trailing")); + EXPECT_FALSE(HasMultipleSqlStatements( + "DEFINE ACTION $read() AS SELECT 1; END DEFINE; SELECT 2")); + EXPECT_FALSE(StartsWithSqlStatement(" -- lead\n SELECT 1", {"INSERT", "UPDATE"})); +} diff --git a/odbc/tests/unit/sql_like_ut.cpp b/odbc/tests/unit/sql_like_ut.cpp new file mode 100644 index 00000000000..48bdffbe46a --- /dev/null +++ b/odbc/tests/unit/sql_like_ut.cpp @@ -0,0 +1,45 @@ +#include "utils/sql_like.h" + +#include + +using NYdb::NOdbc::SqlLikeMatch; + +TEST(SqlLikeMatch, PercentMatchesSubstring) { + EXPECT_TRUE(SqlLikeMatch("/local/foo_bar", "%foo%")); + EXPECT_TRUE(SqlLikeMatch("/local/pfx_foo_sfx", "%foo%")); + EXPECT_FALSE(SqlLikeMatch("/local/other", "%foo%")); +} + +TEST(SqlLikeMatch, UnderscoreMatchesSingleChar) { + EXPECT_TRUE(SqlLikeMatch("a_c", "a_c")); + EXPECT_TRUE(SqlLikeMatch("abc", "a_c")); + EXPECT_FALSE(SqlLikeMatch("abbc", "a_c")); +} + +TEST(SqlLikeMatch, EmptyPatternMatchesOnlyEmptyText) { + EXPECT_TRUE(SqlLikeMatch("", "")); + EXPECT_FALSE(SqlLikeMatch("anything", "")); +} + +TEST(SqlLikeMatch, PercentAtEnds) { + EXPECT_TRUE(SqlLikeMatch("hello", "%hello%")); + EXPECT_TRUE(SqlLikeMatch("hello", "hel%")); + EXPECT_TRUE(SqlLikeMatch("hello", "%llo")); +} + +TEST(SqlLikeMatch, BackslashEscapesWildcards) { + EXPECT_TRUE(SqlLikeMatch("a_c", "a\\_c")); + EXPECT_FALSE(SqlLikeMatch("abc", "a\\_c")); + EXPECT_TRUE(SqlLikeMatch("rate%", "rate\\%")); + EXPECT_FALSE(SqlLikeMatch("rate123", "rate\\%")); + EXPECT_TRUE(SqlLikeMatch("a\\b", "a\\\\b")); + EXPECT_TRUE(SqlLikeMatch("prefix_value_suffix", "%\\_value\\_%")); + EXPECT_FALSE(SqlLikeMatch("prefixXvalueYsuffix", "%\\_value\\_%")); +} + +TEST(SqlLikeMatch, BackslashWithoutSpecialCharacterIsLiteral) { + EXPECT_TRUE(SqlLikeMatch("a\\b", "a\\b")); + EXPECT_FALSE(SqlLikeMatch("ab", "a\\b")); + EXPECT_TRUE(SqlLikeMatch("abc\\", "abc\\")); + EXPECT_FALSE(SqlLikeMatch("abc", "abc\\")); +} diff --git a/scripts/build_cpack_deb_packages.sh b/scripts/build_cpack_deb_packages.sh index bce14ab8d2e..f4f52902001 100755 --- a/scripts/build_cpack_deb_packages.sh +++ b/scripts/build_cpack_deb_packages.sh @@ -6,6 +6,12 @@ OUTPUT_DIR="${1:-${SOURCE_DIR}/build-deb/packages}" BUILD_ROOT="${YDB_DEB_BUILD_ROOT:-${SOURCE_DIR}/build-deb}" CPM_SOURCE_CACHE="${CPM_SOURCE_CACHE:-${SOURCE_DIR}/.cache/cpm}" CCACHE_DIR="${CCACHE_DIR:-${SOURCE_DIR}/.cache/ccache}" +YDB_DEB_COMPONENTS="${YDB_DEB_COMPONENTS:-}" + +if [ -n "$YDB_DEB_COMPONENTS" ] && [ "$YDB_DEB_COMPONENTS" != "ydb-odbc" ]; then + echo "Only the ydb-odbc component build is supported" >&2 + exit 2 +fi mkdir -p "$OUTPUT_DIR" "$BUILD_ROOT" "$CPM_SOURCE_CACHE" "$CCACHE_DIR" OUTPUT_DIR="$(realpath "$OUTPUT_DIR")" @@ -21,12 +27,12 @@ if [ "${YDB_DEB_INSTALL_DEPS:-1}" = "1" ]; then export DEBIAN_FRONTEND=noninteractive "${SUDO[@]}" apt-get update "${SUDO[@]}" apt-get install -y --no-install-recommends \ - build-essential ca-certificates ccache cmake ninja-build pkg-config git \ + build-essential ca-certificates ccache cmake file ninja-build pkg-config git \ libidn11-dev libssl-dev zlib1g-dev \ libprotobuf-dev protobuf-compiler libgrpc++-dev protobuf-compiler-grpc \ libabsl-dev libbrotli-dev liblz4-dev libzstd-dev libbz2-dev libxxhash-dev \ libsnappy-dev libdouble-conversion-dev libre2-dev \ - libc-ares-dev rapidjson-dev python3 ragel yasm + libc-ares-dev rapidjson-dev odbcinst unixodbc-dev python3 ragel yasm fi export CPM_SOURCE_CACHE CCACHE_DIR @@ -40,6 +46,10 @@ fi google_build="${BUILD_ROOT}/googleapis" sdk_build="${BUILD_ROOT}/sdk" +otel=ON +if [ "$YDB_DEB_COMPONENTS" = "ydb-odbc" ]; then + otel=OFF +fi cmake -S "${SOURCE_DIR}/scripts/googleapis_deb" -B "$google_build" -G Ninja \ -DCMAKE_BUILD_TYPE=Release \ @@ -60,12 +70,17 @@ cmake -S "$SOURCE_DIR" -B "$sdk_build" -G Ninja \ -DYDB_SDK_INSTALL=ON \ -DYDB_SDK_EXAMPLES=OFF \ -DYDB_SDK_TESTS=OFF \ - -DYDB_SDK_ENABLE_OTEL_METRICS=ON \ - -DYDB_SDK_ENABLE_OTEL_TRACE=ON \ + -DYDB_SDK_ENABLE_OTEL_METRICS="$otel" \ + -DYDB_SDK_ENABLE_OTEL_TRACE="$otel" \ + -DYDB_SDK_ODBC=ON \ "${compiler_cache_args[@]}" -cmake --build "$sdk_build" --target package --parallel - -cp -f "$google_build"/*.deb "$sdk_build"/*.deb "$OUTPUT_DIR"/ +if [ "$YDB_DEB_COMPONENTS" = "ydb-odbc" ]; then + cmake --build "$sdk_build" --target ydb-odbc --parallel + (cd "$sdk_build" && cpack -G DEB -B "$OUTPUT_DIR" -D CPACK_COMPONENTS_ALL=ydb-odbc) +else + cmake --build "$sdk_build" --target package --parallel + cp -f "$google_build"/*.deb "$sdk_build"/*.deb "$OUTPUT_DIR"/ +fi if command -v ccache >/dev/null 2>&1; then ccache --show-stats || true diff --git a/scripts/googleapis_deb/CMakeLists.txt b/scripts/googleapis_deb/CMakeLists.txt index a2587f7538f..4915e86415f 100644 --- a/scripts/googleapis_deb/CMakeLists.txt +++ b/scripts/googleapis_deb/CMakeLists.txt @@ -43,6 +43,8 @@ endforeach() add_library(api-common-protos STATIC ${PROTO_SRCS} ${PROTO_HDRS}) add_library(yandex-googleapis-api-common-protos::api-common-protos ALIAS api-common-protos) +set_target_properties(api-common-protos PROPERTIES POSITION_INDEPENDENT_CODE ON) + target_include_directories(api-common-protos PUBLIC $ $ diff --git a/tests/unit/library/operation_id/CMakeLists.txt b/tests/unit/library/operation_id/CMakeLists.txt index a6f2143949a..63d77da600a 100644 --- a/tests/unit/library/operation_id/CMakeLists.txt +++ b/tests/unit/library/operation_id/CMakeLists.txt @@ -5,6 +5,7 @@ add_ydb_test(NAME operation_id_ut GTEST yutil lib-operation_id-protos library-operation_id + cpp-testing-unittest LABELS unit )