Java.yml

name: Java JDBC
on:
  push:
    branches-ignore:
      - 'vendoring-*'
  pull_request:
  workflow_dispatch:
    inputs:
      skip_tests:
        description: 'Skip test runs'
        required: false
        default: 'false'
        type: 'string'
      duckdb_sha:
        description: 'DuckDB SHA for release event tracking'
        required: false
        default: ''
        type: 'string'
      duckdb_version:
        description: 'DuckDB version for release event tracking'
        required: false
        default: ''
        type: 'string'
      pr_number:
        description: 'Vendoring PR number to merge after successful CI'
        required: false
        default: ''
        type: 'string'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.head_ref || '' }}-${{ github.base_ref || '' }}-${{ (github.ref != 'refs/heads/main' && !startsWith(github.ref, 'refs/heads/v')) || github.run_id }}
  cancel-in-progress: true

jobs:

  format-check:
    name: Format Check
    if: ${{ !(github.event_name == 'pull_request' && startsWith(github.head_ref, 'vendoring-')) }}
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-slim' || 'ubuntu-latest' }}
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
      - run: |
          python ./scripts/retry.py --timeout 1m -- \
            python -m pip install --user --break-system-packages clang_format==11.0.1
          export PATH=~/.local/bin:$PATH 
          which clang-format
          clang-format --version
          make format-check

  java-linux-amd64:
    name: Linux (amd64)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-x64' || 'ubuntu-latest' }}
    needs: format-check
    env:
      MANYLINUX_IMAGE: quay.io/pypa/manylinux_2_28_x86_64
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Cache Key
        id: cache_key
        run: |
          DUCKDB_VERSION=$(python ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-$DUCKDB_VERSION"
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Build
        uses: ./.github/composite-actions/linux-build-docker
        with:
          docker_image: '${{ env.MANYLINUX_IMAGE }}'

      - name: Save Cache
        uses: actions/cache/save@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }} 

      - name: List Symbols
        run: |
          nm -gU ./build/release/libduckdb_java.so_linux_amd64

      - name: Check jemalloc
        run: |
          nm ./build/release/libduckdb_java.so_linux_amd64 | grep jemalloc || exit 1

      - name: Check Module Name
        run: |
          java \
            --module-path ./build/release/duckdb_jdbc.jar \
            -d duckdb.jdbc

      - name: JDBC Tests EL8
        if: ${{ inputs.skip_tests != 'true' }}
        uses: ./.github/composite-actions/linux-tests-docker
        with:
          docker_image: '${{ env.MANYLINUX_IMAGE }}'

      - name: JDBC Tests
        if: ${{ inputs.skip_tests != 'true' }}
        uses: ./.github/composite-actions/linux-tests-host

      - uses: actions/upload-artifact@v4
        with:
          name: java-linux-amd64
          path: |
            build/release/duckdb_jdbc.jar

  java-linux-amd64-tck:
    name: Linux TCK (amd64)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-x64' || 'ubuntu-latest' }}
    needs: java-linux-amd64
    env:
      MANYLINUX_IMAGE: quay.io/pypa/manylinux_2_28_x86_64
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Cache Key
        id: cache_key
        run: |
          DUCKDB_VERSION=$(python ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-$DUCKDB_VERSION"
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Build
        if: ${{ inputs.skip_tests != 'true' }}
        uses: ./.github/composite-actions/linux-build-docker
        with:
          docker_image: '${{ env.MANYLINUX_IMAGE }}'

      - name: Checkout Platform TCK
        if: ${{ inputs.skip_tests != 'true' }}
        uses: actions/checkout@v7
        with:
          repository: jakartaee/platform-tck
          ref: 10.0.6
          path: platform-tck

      - name: Checkout CTS Runner 
        if: ${{ inputs.skip_tests != 'true' }}
        uses: actions/checkout@v7
        with:
          repository: duckdb/jdbc_compatibility_test_suite_runner
          path: jdbc_compatibility_test_suite_runner

      - name: CTS tests
        if: ${{ inputs.skip_tests != 'true' }}
        run: |
          docker run                                           \
          -v.:/duckdb                                          \
          -e JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk         \
          -e DUCKDB_JAR=/duckdb/build/release/duckdb_jdbc.jar  \
          -e PLATFORM_TCK_DIR=/duckdb/platform-tck             \
          ${{ env.MANYLINUX_IMAGE }}                           \
          bash -c "
            set -e
            cat /etc/os-release
            dnf install -y \
              java-1.8.0-openjdk-devel
            make -C /duckdb/jdbc_compatibility_test_suite_runner test
          "

  java-linux-amd64-graal:
    name: Linux Graal (amd64)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-x64' || 'ubuntu-latest' }}
    needs: java-linux-amd64
    env:
      MANYLINUX_IMAGE: quay.io/pypa/manylinux_2_28_x86_64
      DUCKDB_JDBC_JAR: ${{ github.workspace }}/build/release/duckdb_jdbc.jar
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Cache Key
        id: cache_key
        run: |
          DUCKDB_VERSION=$(python ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-$DUCKDB_VERSION"
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Build
        if: ${{ inputs.skip_tests != 'true' }}
        uses: ./.github/composite-actions/linux-build-docker
        with:
          docker_image: '${{ env.MANYLINUX_IMAGE }}'

      - name: Set up GraalVM
        if: ${{ inputs.skip_tests != 'true' }}
        uses: graalvm/setup-graalvm@v1
        with:
          java-version: '25'
          distribution: 'graalvm-community'

      - name: Native Image Hello World
        if: ${{ inputs.skip_tests != 'true' }}
        run: |
          java ${{ github.workspace }}/src/test/external/RunGraalNativeImage.java \
            ${{ github.workspace }}/src/test/external/graal

  java-linux-amd64-spark:
    name: Linux Spark (amd64)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-x64' || 'ubuntu-latest' }}
    needs: java-linux-amd64
    env:
      MANYLINUX_IMAGE: quay.io/pypa/manylinux_2_28_x86_64
      DUCKDB_JDBC_JAR: ${{ github.workspace }}/build/release/duckdb_jdbc.jar
      SPARK_SQL_EXE: ${{ github.workspace }}/sparktest/spark-3.5.3-bin-hadoop3/bin/spark-sql
      POSTGRES_HOST: 127.0.0.1
      POSTGRES_PORT: 5432
      POSTGRES_MAINTENANCE_DB: postgres
      POSTGRES_USERNAME: postgres
      POSTGRES_PASSWORD: postgres
      DUCKLAKE_CATALOG_DB: lake_test
      PARQUET_FILE_URL: https://blobs.duckdb.org/data/taxi_2019_04.parquet
      SESSION_INIT_SQL_FILE: ${{ github.workspace }}/sparktest/spark-session-init.sql
      MINIO_EXE: ${{ github.workspace }}/sparktest/minio
      MINIO_PID: ${{ github.workspace }}/sparktest/minio.pid
      MC_EXE: ${{ github.workspace }}/sparktest/mc
      MINIO_DATA: ${{ github.workspace }}/sparktest/minio_data
      MINIO_HOST: 127.0.0.1
      MINIO_PORT: 9000

    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Cache Key
        id: cache_key
        run: |
          DUCKDB_VERSION=$(python ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-$DUCKDB_VERSION"
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        if: ${{ inputs.skip_tests != 'true' }}
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Setup JDK
        uses: actions/setup-java@v6
        with:
          distribution: corretto
          java-version: '17'

      - name: Build
        if: ${{ inputs.skip_tests != 'true' }}
        uses: ./.github/composite-actions/linux-build-docker
        with:
          docker_image: '${{ env.MANYLINUX_IMAGE }}'

      - name: Spark Test Resources
        if: ${{ inputs.skip_tests != 'true' }}
        run: |
          mkdir sparktest
          cd sparktest
          cmake ..

      - name: Setup Postgres
        run: |
          docker run -d \
            --name postgres \
            -p 5432:${{ env.POSTGRES_PORT }} \
            -e POSTGRES_USER=${{ env.POSTGRES_USERNAME }} \
            -e POSTGRES_PASSWORD=${{ env.POSTGRES_PASSWORD }} \
            -e POSTGRES_DB=${{ env.POSTGRES_MAINTENANCE_DB }} \
            ghcr.io/infrastructure-as-code/postgres:18-alpine
          python ./scripts/retry.py --retries 0 --timeout 1m -- \
            bash -lc '
              until docker exec postgres pg_isready -U ${{ env.POSTGRES_USERNAME }} -d ${{ env.POSTGRES_MAINTENANCE_DB }}; do
                sleep 2
              done
            '

      - name: Setup Minio
        if: ${{ inputs.skip_tests != 'true' }}
        working-directory: sparktest
        run: |
          python ../scripts/retry.py --timeout 1m -- \
            wget -nv https://github.com/minio/minio/releases/download/RELEASE.2025-09-07T16-13-09Z/minio.linux-amd64.RELEASE.2025-09-07T16-13-09Z
          mv minio.linux-amd64.RELEASE.2025-09-07T16-13-09Z minio
          chmod +x minio
          ./minio --version
          python ../scripts/retry.py --timeout 1m -- \
            wget -nv https://github.com/minio/mc/releases/download/RELEASE.2025-08-13T08-35-41Z/mc.linux-amd64.RELEASE.2025-08-13T08-35-41Z
          mv mc.linux-amd64.RELEASE.2025-08-13T08-35-41Z mc
          chmod +x mc
          ./mc --version
          java -version
          java ${{ github.workspace }}/src/test/external/SetupMinio.java

      - name: Setup DuckLake
        if: ${{ inputs.skip_tests != 'true' }}
        working-directory: sparktest
        run: |
          cat ${{ env.SESSION_INIT_SQL_FILE }}
          python ../scripts/retry.py --timeout 1m -- \
            wget -nv https://github.com/pgjdbc/pgjdbc/releases/download/REL42.7.7/postgresql-42.7.7.jar
          java -version
          java -cp ${{ env.DUCKDB_JDBC_JAR }}:postgresql-42.7.7.jar ${{ github.workspace }}/src/test/external/SetupDuckLake.java

      - name: Spark Tests
        if: ${{ inputs.skip_tests != 'true' }}
        working-directory: sparktest
        run: |
          python ../scripts/retry.py --timeout 1m -- \
            wget -nv https://blobs.duckdb.org/ci/spark-3.5.3-bin-hadoop3.tgz
          tar xf spark-3.5.3-bin-hadoop3.tgz
          cat spark-test.sql
          java -version
          java ${{ github.workspace }}/src/test/external/RunSpark.java spark-test.sql

  java-linux-amd64-asan:
    name: Linux ASan (amd64)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-x64' || 'ubuntu-latest' }}
    needs: java-linux-amd64
    env:
      GEN: ninja
      CC: 'ccache gcc'
      CXX: 'ccache g++'
      CCACHE_DIR: ${{ github.workspace }}/ccache

    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Dependencies
        run: |
          echo "set man-db/auto-update false" | sudo debconf-communicate || true
          sudo dpkg-reconfigure man-db || true
          python ./scripts/retry.py --timeout 2m -- \
            sudo apt-get update -y -q -o=Dpkg::Use-Pty=0
          python ./scripts/retry.py --timeout 2m -- \
            sudo apt-get install -y -q -o=Dpkg::Use-Pty=0 \
            ccache \
            ninja-build

      - name: Cache Key
        id: cache_key
        run: |
          DUCKDB_VERSION=$(python ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-$DUCKDB_VERSION"-asan
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Build (patched)
        if: ${{ inputs.skip_tests != 'true' }}
        run: |
          patch -p1 < ./data/asan/appender_asan_failure.patch
          git diff HEAD
          make sanitized

      - name: Save Cache
        uses: actions/cache/save@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }} 

      - name: ASan (patched)
        if: ${{ inputs.skip_tests != 'true' }}
        env:
          LD_PRELOAD: "/usr/lib/x86_64-linux-gnu/libasan.so.8 /usr/lib/x86_64-linux-gnu/libstdc++.so.6"
        run: |
          java \
            -cp ./build/sanitized/duckdb_jdbc_nolib.jar:./build/sanitized/duckdb_jdbc_tests.jar \
            org.duckdb.TestDuckDBJDBC \
            quick \
            > asan_patched.log 2>&1 \
            || true
          cat asan_patched.log
          grep heap-use-after-free asan_patched.log
          grep Java_org_duckdb_DuckDBBindings_duckdb_1appender_1create_1ext asan_patched.log
          grep ABORTING asan_patched.log

      - name: Build
        if: ${{ inputs.skip_tests != 'true' }}
        run: |
          git checkout src/jni/bindings_appender.cpp
          git status
          make sanitized

      - name: ASan
        if: ${{ inputs.skip_tests != 'true' }}
        env:
          LD_PRELOAD: "/usr/lib/x86_64-linux-gnu/libasan.so.8 /usr/lib/x86_64-linux-gnu/libstdc++.so.6"
        run: |
          java \
            -cp ./build/sanitized/duckdb_jdbc_nolib.jar:./build/sanitized/duckdb_jdbc_tests.jar \
            org.duckdb.TestDuckDBJDBC \
            quick \
            > asan.log 2>&1 \
            || true
          grep -qPz "TestDuckDBJDBC#test_write_map success in 0 seconds\nOK" asan.log
          if grep -q ABORTING asan.log; then
            exit 1
          fi

      - name: Upload Log
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: asan.log
          path: |
            asan.log

  java-linux-amd64-jepsen:
    name: Linux Jepsen (amd64)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-x64' || 'ubuntu-latest' }}
    needs: java-linux-amd64
    env:
      MANYLINUX_IMAGE: quay.io/pypa/manylinux_2_28_x86_64
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Checkout Jepsen
        uses: actions/checkout@v7
        with:
          repository: jepsen-io/duckdb
          ref: 95731d970339780b934ac106831d704ce3ad23ba
          path: jepsen

      - name: Cache Key
        id: cache_key
        run: |
          DUCKDB_VERSION=$(python ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-$DUCKDB_VERSION"
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Build
        uses: ./.github/composite-actions/linux-build-docker
        with:
          docker_image: '${{ env.MANYLINUX_IMAGE }}'

      - name: Install Dependencies 
        run: |
          echo "set man-db/auto-update false" | sudo debconf-communicate || true
          sudo dpkg-reconfigure man-db || true
          python ./scripts/retry.py --timeout 1m -- \
            sudo apt-get update -y -q -o=Dpkg::Use-Pty=0
          python ./scripts/retry.py --timeout 1m -- \
            sudo apt-get install -y -q -o=Dpkg::Use-Pty=0 \
            gnuplot \
            graphviz \
            leiningen

      - name: Setup JDK
        uses: actions/setup-java@v6
        with:
          distribution: corretto
          java-version: '21'

      - name: Check JDK version
        run: |
          which java
          java -version
          echo $JAVA_HOME
          $JAVA_HOME/bin/java -version

      - name: Install JAR
        run: |
          mvn -B -ntp --version
          mvn -B -ntp install:install-file \
            -Dfile=${{ github.workspace }}/build/release/duckdb_jdbc.jar \
            -DgroupId=org.duckdb \
            -DartifactId=duckdb_jdbc \
            -Dversion=1-jepsen \
            -Dpackaging=jar

      - name: Run Jepsen
        working-directory: jepsen
        run: |
          patch -p1 < ${{ github.workspace }}/data/jepsen/jepsen.patch
          lein --version
          python ../scripts/retry.py --retries 1 --timeout 5m -- \
            lein run test \
            --time-limit 10 \
            --max-writes-per-key 8 \
            --concurrency 5 \
            --rate 1000 \
            --log-sql \
            --upsert merge-into \
            --duckdb-log \
            | grep -v '^INFO' \
            | tee jepsen.log
          tail -n 1 jepsen.log | grep -q '^Everything looks good!'

      - name: Zip Results
        if: always()
        working-directory: jepsen
        run: |
          zip -qyr store.zip store

      - name: Upload Results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: jepsen
          path: |
            jepsen/store.zip

  java-linux-aarch64:
    name: Linux (aarch64)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-arm64' || 'ubuntu-24.04-arm' }}
    needs: java-linux-amd64
    env:
      MANYLINUX_IMAGE: quay.io/pypa/manylinux_2_28_aarch64
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Cache Key
        id: cache_key
        run: |
          DUCKDB_VERSION=$(python ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-$DUCKDB_VERSION"
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Build
        uses: ./.github/composite-actions/linux-build-docker
        with:
          docker_image: '${{ env.MANYLINUX_IMAGE }}'

      - name: Save Cache
        uses: actions/cache/save@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }} 

      - name: List Symbols
        run: |
          nm -gU ./build/release/libduckdb_java.so_linux_arm64

      - name: Check jemalloc
        run: |
          nm ./build/release/libduckdb_java.so_linux_arm64 | grep jemalloc || exit 1

      - name: JDBC Tests EL8
        if: ${{ inputs.skip_tests != 'true' }}
        uses: ./.github/composite-actions/linux-tests-docker
        with:
          docker_image: '${{ env.MANYLINUX_IMAGE }}'

      - name: JDBC Tests
        if: ${{ inputs.skip_tests != 'true' }}
        uses: ./.github/composite-actions/linux-tests-host

      - uses: actions/upload-artifact@v4
        with:
          name: java-linux-aarch64
          path: |
            build/release/duckdb_jdbc.jar

  java-linux-amd64-musl:
    name: Linux (amd64-musl)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-x64' || 'ubuntu-latest' }}
    needs: java-linux-amd64
    env:
      ALPINE_IMAGE: alpine:3.22
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Cache Key
        id: cache_key
        run: |
          DUCKDB_VERSION=$(python ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-$DUCKDB_VERSION"-musl
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Build
        uses: ./.github/composite-actions/linux-build-musl-docker
        with:
          docker_image: '${{ env.ALPINE_IMAGE }}'

      - name: Save Cache
        uses: actions/cache/save@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }} 

      - name: List Symbols
        run: |
          nm -gU ./build/release/libduckdb_java.so_linux_amd64

      - name: Check jemalloc
        run: |
          ! (nm ./build/release/libduckdb_java.so_linux_amd64 | grep jemalloc) || exit 1

      - name: JDBC Tests
        if: ${{ inputs.skip_tests != 'true' }}
        uses: ./.github/composite-actions/linux-tests-musl-docker
        with:
          docker_image: '${{ env.ALPINE_IMAGE }}'

      - uses: actions/upload-artifact@v4
        with:
          name: java-linux-amd64-musl
          path: |
            build/release/duckdb_jdbc.jar

  java-linux-aarch64-musl:
    name: Linux (aarch64-musl)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-arm64' || 'ubuntu-24.04-arm' }}
    needs: java-linux-amd64
    env:
      ALPINE_IMAGE: alpine:3.22
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Cache Key
        id: cache_key
        run: |
          DUCKDB_VERSION=$(python ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-$DUCKDB_VERSION"-musl
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Build
        uses: ./.github/composite-actions/linux-build-musl-docker
        with:
          docker_image: '${{ env.ALPINE_IMAGE }}'

      - name: Save Cache
        uses: actions/cache/save@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }} 

      - name: List Symbols
        run: |
          nm -gU ./build/release/libduckdb_java.so_linux_arm64

      - name: Check jemalloc
        run: |
          ! (nm ./build/release/libduckdb_java.so_linux_arm64 | grep jemalloc) || exit 1

      - name: JDBC Tests
        if: ${{ inputs.skip_tests != 'true' }}
        uses: ./.github/composite-actions/linux-tests-musl-docker
        with:
          docker_image: '${{ env.ALPINE_IMAGE }}'

      - uses: actions/upload-artifact@v4
        with:
          name: java-linux-aarch64-musl
          path: |
            build/release/duckdb_jdbc.jar

  java-windows-amd64:
    name: Windows (amd64)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-windows-x64' || 'windows-latest' }}
    needs: java-linux-amd64
    env:
      CC: 'ccache cl'
      CXX: 'ccache cl'
      CCACHE_DIR: ${{ github.workspace }}/ccache
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
          ref: ${{ inputs.git_ref }}

      - name: Dependencies
        shell: bash
        run: |
          python ./scripts/retry.py --timeout 1m -- \
            choco install \
            ccache \
            -y --force --no-progress

      - name: Setup JDK 
        uses: actions/setup-java@v6
        with:
          distribution: corretto
          java-version: '8'

      - name: Cache Key
        id: cache_key
        shell: bash
        run: |
          DUCKDB_VERSION=$(python ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-$DUCKDB_VERSION"
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Build
        shell: cmd
        run: |
          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
          mkdir build
          cd build
          mkdir release
          cd release
          cmake ../.. -G Ninja -DCMAKE_BUILD_TYPE=Release
          cmake --build . --config Release --parallel

      - name: Save Cache
        uses: actions/cache/save@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }} 

      - name: List Symbols
        shell: cmd
        run: |
          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
          dumpbin.exe /imports build\release\libduckdb_java.so_windows_amd64
          dumpbin.exe /exports build\release\libduckdb_java.so_windows_amd64

      - name: Java Tests
        if: ${{ inputs.skip_tests != 'true' }}
        shell: bash
        run: |
          java -version
          make test

      - uses: actions/upload-artifact@v4
        with:
          name: java-windows-amd64
          path: |
            build/release/duckdb_jdbc.jar

  java-windows-aarch64:
    name: Windows (aarch64)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-windows-x64' || 'windows-latest' }}
    needs: java-linux-amd64
    env:
      CC: 'ccache cl'
      CXX: 'ccache cl'
      CCACHE_DIR: ${{ github.workspace }}/ccache
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
          ref: ${{ inputs.git_ref }}

      - name: Dependencies
        shell: bash
        run: |
          python ./scripts/retry.py --timeout 1m -- \
            choco install \
            ccache \
            -y --force --no-progress

      - name: Setup JDK 
        uses: actions/setup-java@v6
        with:
          distribution: corretto
          java-version: '8'

      - name: Cache Key
        id: cache_key
        shell: bash
        run: |
          DUCKDB_VERSION=$(python ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-$DUCKDB_VERSION"
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Build
        shell: cmd
        run: |
          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsamd64_arm64.bat"
          mkdir build
          cd build
          mkdir release
          cd release
          cmake ../.. -G Ninja -DCMAKE_BUILD_TYPE=Release -DOVERRIDE_JDBC_OS_ARCH=arm64
          cmake --build . --config Release --parallel

      - name: Save Cache
        uses: actions/cache/save@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }} 

      - name: List Symbols
        shell: cmd
        run: |
          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsamd64_arm64.bat"
          dumpbin.exe /imports build\release\libduckdb_java.so_windows_arm64
          dumpbin.exe /exports build\release\libduckdb_java.so_windows_arm64

      - name: Java Tests
        if: ${{ false && inputs.skip_tests != 'true' }}
        shell: bash
        run: |
          java -version
          make test

      - uses: actions/upload-artifact@v4
        with:
          name: java-windows-aarch64
          path: |
            build/release/duckdb_jdbc.jar

  java-macos-aarch64:
    name: macOS (aarch64)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-macos-arm64' || 'macos-latest' }}
    needs: java-linux-amd64
    env:
      GEN: ninja
      CC: 'ccache clang'
      CXX: 'ccache clang++'
      CCACHE_DIR: ${{ github.workspace }}/ccache
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Cache Key
        id: cache_key
        run: |
          DUCKDB_VERSION=$(python3 ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-arm64-$DUCKDB_VERSION"
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Install Dependencies
        run: |
          python3 ./scripts/retry.py --timeout 1m -- \
            brew install -q \
            ccache \
            ninja

      - name: Setup JDK
        uses: actions/setup-java@v6
        with:
          distribution: corretto
          java-version: '8'

      - name: Build
        shell: bash
        run: make release

      - name: Save Cache
        uses: actions/cache/save@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }} 

      - name: List Symbols
        run: |
          nm -gU ./build/release/libduckdb_java.so_macos_arm64

      - name: Check jemalloc
        run: |
          ! (nm ./build/release/libduckdb_java.so_macos_arm64 | grep jemalloc) || exit 1

      - name: Check architecture
        shell: bash
        run: test "$(lipo -archs build/release/libduckdb_java.so_macos_arm64)" = "arm64"

      - name: Java Tests
        if: ${{ inputs.skip_tests != 'true' }}
        shell: bash
        run: make test

      - uses: actions/upload-artifact@v4
        with:
          name: java-macos-aarch64
          path: |
            build/release/duckdb_jdbc.jar

  java-macos-amd64:
    name: macOS (amd64)
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-macos-arm64' || 'macos-latest' }}
    needs: java-linux-amd64
    env:
      GEN: ninja
      CC: 'ccache clang'
      CXX: 'ccache clang++'
      CCACHE_DIR: ${{ github.workspace }}/ccache
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Cache Key
        id: cache_key
        run: |
          DUCKDB_VERSION=$(python3 ./scripts/print_duckdb_version.py)
          KEY="${{ runner.os }}-${{ runner.arch }}-amd64-$DUCKDB_VERSION"
          echo "value=${KEY}" >> "${GITHUB_OUTPUT}"

      - name: Restore Cache
        uses: actions/cache/restore@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }}

      - name: Install Dependencies
        run: |
          python3 ./scripts/retry.py --timeout 1m -- \
            brew install -q \
            ccache \
            ninja

      - name: Setup JDK
        uses: actions/setup-java@v6
        with:
          distribution: corretto
          java-version: '8'
          architecture: x64

      - name: Build
        shell: bash
        run: OSX_BUILD_AMD64=1 make release

      - name: Save Cache
        uses: actions/cache/save@v6
        with:
          path: ${{ github.workspace }}/ccache
          key: ${{ steps.cache_key.outputs.value }} 

      - name: List Symbols
        run: |
          nm -gU ./build/release/libduckdb_java.so_macos_amd64

      - name: Check jemalloc
        run: |
          ! (nm ./build/release/libduckdb_java.so_macos_amd64 | grep jemalloc) || exit 1

      - name: Check architecture
        shell: bash
        run: test "$(lipo -archs build/release/libduckdb_java.so_macos_amd64)" = "x86_64"

      - name: Java Tests
        if: ${{ inputs.skip_tests != 'true' }}
        shell: bash
        run: make test

      - uses: actions/upload-artifact@v4
        with:
          name: java-macos-amd64
          path: |
            build/release/duckdb_jdbc.jar

  maven-deploy:
    if: ${{ github.repository == 'duckdb/duckdb-java' && startsWith(github.ref, 'refs/tags/') }}
    name: Maven Deploy
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-slim' || 'ubuntu-latest' }}
    needs:
      - java-linux-amd64
      - java-linux-amd64-tck
      - java-linux-amd64-graal
      - java-linux-amd64-spark
      - java-linux-amd64-asan
      - java-linux-amd64-jepsen
      - java-linux-aarch64
      - java-linux-amd64-musl
      - java-linux-aarch64-musl
      - java-windows-amd64
      - java-windows-aarch64
      - java-macos-aarch64
      - java-macos-amd64

    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - shell: bash
        run: mkdir jdbc-artifacts

      - uses: actions/download-artifact@v4
        with:
          name: java-linux-amd64
          path: jdbc-artifacts/java-linux-amd64

      - uses: actions/download-artifact@v4
        with:
          name: java-linux-aarch64
          path: jdbc-artifacts/java-linux-aarch64

      - uses: actions/download-artifact@v4
        with:
          name: java-linux-amd64-musl
          path: jdbc-artifacts/java-linux-amd64-musl

      - uses: actions/download-artifact@v4
        with:
          name: java-linux-aarch64-musl
          path: jdbc-artifacts/java-linux-aarch64-musl

      - uses: actions/download-artifact@v4
        with:
          name: java-windows-amd64
          path: jdbc-artifacts/java-windows-amd64

      - uses: actions/download-artifact@v4
        with:
          name: java-windows-aarch64
          path: jdbc-artifacts/java-windows-aarch64

      - uses: actions/download-artifact@v4
        with:
          name: java-macos-aarch64
          path: jdbc-artifacts/java-macos-aarch64

      - uses: actions/download-artifact@v4
        with:
          name: java-macos-amd64
          path: jdbc-artifacts/java-macos-amd64

      - name: Combine JARs
        shell: bash
        env:
          MAVEN_USERNAME: ${{ secrets.MAVEN_USERNAME }}
          MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
        run: |
          mkdir -m  700 -p ~/.gnupg
          echo -e "passphrase asdf\npinentry-mode loopback\nno-tty\nbatch\n" > ~/.gnupg/gpg.conf
          echo "${{ secrets.MAVEN_PGP_PK }}" | base64 -d > maven_pgp_key
          gpg --batch --import maven_pgp_key
          python ./scripts/jdbc_maven_deploy.py ${{ github.ref_name }} jdbc-artifacts .

      - name: Upload artifacts
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: java-jars
          path: |
            jdbc-artifacts

  maven-snapshot-deploy:
    if: ${{ github.repository == 'duckdb/duckdb-java' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/vendoring-main') && github.event_name == 'workflow_dispatch' }}
    name: Maven S3 Deploy
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-slim' || 'ubuntu-latest' }}
    needs:
      - java-linux-amd64
      - java-linux-amd64-tck
      - java-linux-amd64-graal
      - java-linux-amd64-spark
      - java-linux-amd64-asan
      - java-linux-amd64-jepsen
      - java-linux-aarch64
      - java-linux-amd64-musl
      - java-linux-aarch64-musl
      - java-windows-amd64
      - java-windows-aarch64
      - java-macos-aarch64
      - java-macos-amd64

    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - shell: bash
        run: mkdir jdbc-artifacts

      - uses: actions/download-artifact@v4
        with:
          name: java-linux-amd64
          path: jdbc-artifacts/java-linux-amd64

      - uses: actions/download-artifact@v4
        with:
          name: java-linux-aarch64
          path: jdbc-artifacts/java-linux-aarch64

      - uses: actions/download-artifact@v4
        with:
          name: java-linux-amd64-musl
          path: jdbc-artifacts/java-linux-amd64-musl

      - uses: actions/download-artifact@v4
        with:
          name: java-linux-aarch64-musl
          path: jdbc-artifacts/java-linux-aarch64-musl

      - uses: actions/download-artifact@v4
        with:
          name: java-windows-amd64
          path: jdbc-artifacts/java-windows-amd64

      - uses: actions/download-artifact@v4
        with:
          name: java-windows-aarch64
          path: jdbc-artifacts/java-windows-aarch64

      - uses: actions/download-artifact@v4
        with:
          name: java-macos-aarch64
          path: jdbc-artifacts/java-macos-aarch64

      - uses: actions/download-artifact@v4
        with:
          name: java-macos-amd64
          path: jdbc-artifacts/java-macos-amd64

      - name: Deploy snapshot to S3
        shell: bash
        env:
          AWS_ENDPOINT_URL: ${{ secrets.S3_DUCKDB_STAGING_ENDPOINT }}
          AWS_ACCESS_KEY_ID: ${{ secrets.S3_DUCKDB_STAGING_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_DUCKDB_STAGING_KEY }}
        run: |
          mkdir -m  700 -p ~/.gnupg
          echo -e "passphrase asdf\npinentry-mode loopback\nno-tty\nbatch\n" > ~/.gnupg/gpg.conf
          echo "${{ secrets.MAVEN_PGP_PK }}" | base64 -d > maven_pgp_key
          gpg --batch --import maven_pgp_key
          python ./scripts/retry.py --timeout 1m -- \
            python ./scripts/jdbc_maven_deploy_s3.py jdbc-artifacts ${{ inputs.duckdb_version }} ${{ inputs.pr_number }}

  java-finalize-vendoring:
    name: Finalize vendoring
    if: ${{ always() && github.repository == 'duckdb/duckdb-java' && github.event_name == 'workflow_dispatch' && startsWith(github.ref, 'refs/heads/vendoring-') && inputs.pr_number != '' && inputs.duckdb_sha != '' }}
    needs:
      - java-linux-amd64
      - java-linux-amd64-tck
      - java-linux-amd64-graal
      - java-linux-amd64-spark
      - java-linux-amd64-asan
      - java-linux-amd64-jepsen
      - java-linux-aarch64
      - java-linux-amd64-musl
      - java-linux-aarch64-musl
      - java-windows-amd64
      - java-windows-aarch64
      - java-macos-aarch64
      - java-macos-amd64
    runs-on: ${{ github.repository_owner == 'duckdb' && 'namespace-profile-linux-slim' || 'ubuntu-latest' }}
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: Merge vendoring PR
        id: merge_vendoring_pr
        if: ${{ !contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') && !contains(needs.*.result, 'skipped') }}
        continue-on-error: true
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
            BASE_BRANCH=$(gh pr view ${{ inputs.pr_number }} --json baseRefName --jq '.baseRefName')
            PR_TITLE=$(gh pr view ${{ inputs.pr_number }} --json title --jq '.title')
            echo "Merging PR number: ${{ inputs.pr_number }} with message: ${PR_TITLE}"
            python ./scripts/retry.py --timeout 1m -- \
              gh pr merge ${{ inputs.pr_number }} \
              --rebase \
              --subject "${PR_TITLE}" \
              --body ""
            echo "base_branch=${BASE_BRANCH}" >> "${GITHUB_OUTPUT}"

      - name: Update vendoring branch
        id: update_vendoring_branch
        if: ${{ steps.merge_vendoring_pr.outcome == 'success' }}
        continue-on-error: true
        run: |
            BASE_BRANCH="${{ steps.merge_vendoring_pr.outputs.base_branch }}"
            git checkout --track origin/${BASE_BRANCH}
            python ./scripts/retry.py --timeout 1m -- \
              git pull --ff-only
            # Delete vendoring-${BASE_BRANCH} branch and re-create it for future PRs
            python ./scripts/retry.py --timeout 1m -- \
              git push --delete origin vendoring-${BASE_BRANCH}
            git branch -D vendoring-${BASE_BRANCH}
            git branch vendoring-${BASE_BRANCH}
            python ./scripts/retry.py --timeout 1m -- \
              git push origin vendoring-${BASE_BRANCH}

      - name: Record client status
        if: always()
        uses: duckdb/duckdb-workflow-trigger/dispatch@main
        with:
          github_token: ${{ secrets.DUCKDB_RELEASE_DISPATCH_TOKEN }}
          event: client_ready
          client: java
          duckdb_version: ${{ inputs.duckdb_version }}
          duckdb_commit: ${{ inputs.duckdb_sha }}
          status: ${{ (contains(needs.*.result, 'failure') || steps.merge_vendoring_pr.outcome == 'failure') && 'failure' || contains(needs.*.result, 'cancelled') && 'cancelled' || contains(needs.*.result, 'skipped') && 'skipped' || 'success' }}
          message: DuckDB Java client ready

      - name: Fail on unsuccessful final status
        if: ${{ always() && (contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') || steps.merge_vendoring_pr.outcome == 'failure' || steps.update_vendoring_branch.outcome == 'failure') }}
        run: exit 1