ci.yaml

name: CI
run-name: "${{ github.event_name == 'workflow_dispatch' && format('Dispatch : Run integration test with JDK {0} ({1})', inputs.INT_TEST_JAVA_RUNTIME_VERSION, inputs.INT_TEST_JAVA_RUNTIME_VENDOR) || '' }}"

on:
  pull_request:
  workflow_dispatch:
    inputs:
      INT_TEST_JAVA_RUNTIME_VERSION:
        description: JDK version used to run the integration test
        type: choice
        required: false
        default: '8'
        options:
          - '8'
          - '11'
          - '17'
          - '21'
      INT_TEST_JAVA_RUNTIME_VENDOR:
        description: Vendor of the JDK used to run the integration test
        type: choice
        required: false
        default: 'temurin'
        options:
          - 'corretto'
          - 'microsoft'
          - 'oracle'
          - 'temurin'

env:
  TERM: dumb
  JAVA_VERSION: '8'
  JAVA_VENDOR: 'temurin'
  INT_TEST_JAVA_RUNTIME_VERSION: "${{ github.event_name != 'workflow_dispatch' && '8' || inputs.INT_TEST_JAVA_RUNTIME_VERSION }}"
  INT_TEST_JAVA_RUNTIME_VENDOR: "${{ github.event_name != 'workflow_dispatch' && 'temurin' || inputs.INT_TEST_JAVA_RUNTIME_VENDOR }}"

jobs:
  check:
    name: Gradle check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name:  Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Setup and execute Gradle 'check' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: check buildSrc:check

      - name: Save Gradle test reports
        if: always()
        run: |
          mkdir -p /tmp/gradle_test_reports/core
          mkdir -p /tmp/gradle_test_reports/server
          mkdir -p /tmp/gradle_test_reports/schema-loader
          cp -a core/build/reports/tests/test /tmp/gradle_test_reports/core/
          cp -a server/build/reports/tests/test /tmp/gradle_test_reports/server/
          cp -a schema-loader/build/reports/tests/test /tmp/gradle_test_reports/schema-loader/

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: gradle_check_reports
          path: /tmp/gradle_test_reports

      - name: Save SpotBugs reports
        if: always()
        run: |
          mkdir -p /tmp/gradle_spotbugs_reports/core
          mkdir -p /tmp/gradle_spotbugs_reports/server
          mkdir -p /tmp/gradle_spotbugs_reports/schema-loader
          mkdir -p /tmp/gradle_spotbugs_reports/integration-test
          cp -a core/build/reports/spotbugs /tmp/gradle_spotbugs_reports/core/
          cp -a server/build/reports/spotbugs /tmp/gradle_spotbugs_reports/server/
          cp -a schema-loader/build/reports/spotbugs /tmp/gradle_spotbugs_reports/schema-loader/
          cp -a integration-test/build/reports/spotbugs /tmp/gradle_spotbugs_reports/integration-test/

      - name: Upload Spotbugs reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: gradle_spotbugs_reports
          path: /tmp/gradle_spotbugs_reports

  dockerfile-lint:
    name: Lint dockerfiles
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Dockerfile Lint for ScalarDB Server
        uses: gradle/gradle-build-action@v3
        with:
          arguments: ':server:dockerfileLint'

      - name: Dockerfile Lint for ScalarDB Schema Loader
        if: always()
        uses: gradle/gradle-build-action@v3
        with:
          arguments: ':schema-loader:dockerfileLint'

  integration-test-for-cassandra-3-0:
    name: Cassandra 3.0 integration test
    runs-on: ubuntu-latest

    services:
      cassandra:
        image: cassandra:3.0
        env:
          MAX_HEAP_SIZE: 2048m
          HEAP_NEWSIZE: 512m
        ports:
          - 9042:9042

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestCassandra' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestCassandra -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: cassandra_3.0_integration_test_reports
          path: core/build/reports/tests/integrationTestCassandra

  integration-test-for-cassandra-3-11:
    name: Cassandra 3.11 integration test
    runs-on: ubuntu-latest

    services:
      cassandra:
        image: cassandra:3.11
        env:
          MAX_HEAP_SIZE: 2048m
          HEAP_NEWSIZE: 512m
        ports:
          - 9042:9042

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestCassandra' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestCassandra -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: cassandra_3.11_integration_test_reports
          path: core/build/reports/tests/integrationTestCassandra

  integration-test-for-cosmos:
    name: Cosmos DB integration test
    runs-on: self-hosted

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Generate unique prefix using the epoch
        run: |
          echo "db_prefix=$(date +%s%3N)" >> $GITHUB_ENV

      - name: Setup and execute Gradle 'integrationTestCosmos' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestCosmos -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.cosmos.uri=${{ secrets.COSMOS_URI }} -Dscalardb.cosmos.password=${{ secrets.COSMOS_PASSWORD }} -Dscalardb.cosmos.database_prefix=${{ env.db_prefix }}_

      - name : Delete gradle daemon log files
        if: always()
#       Delete all files modified more than 3 days ago with the ".out.log" file extension located in the "/home/azureuser/.gradle/daemon"
#       folder hierarchy. These files accumulate over time and can end up using a lot of disk space
        run : find /home/azureuser/.gradle/daemon -name "*.out.log" -type f -mtime +3 -exec rm -vf {} +

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: cosmos_integration_test_reports
          path: core/build/reports/tests/integrationTestCosmos

  integration-test-for-dynamo:
    name: DynamoDB integration test
    runs-on: ubuntu-latest

    services:
      dynamodb:
        image: amazon/dynamodb-local:1.17.0
        ports:
          - 8000:8000

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestDynamo' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestDynamo -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: dynamo_integration_test_reports
          path: core/build/reports/tests/integrationTestDynamo

  integration-test-for-jdbc-mysql-5-7:
    name: MySQL 5.7 integration test
    runs-on: ubuntu-latest

    steps:
      - name: Run MySQL 5.7
        run: |
          docker run -e MYSQL_ROOT_PASSWORD=mysql -p 3306:3306 -d mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_bin

      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: mysql_5.7_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-mysql-8-0:
    name: MySQL 8.0 integration test
    runs-on: ubuntu-latest

    steps:
      - name: Run MySQL 8.0
        run: |
          docker run -e MYSQL_ROOT_PASSWORD=mysql -p 3306:3306 -d mysql:8.0 --character-set-server=utf8mb4 --collation-server=utf8mb4_bin

      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}


      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: mysql_8.0_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-mysql-8-1:
    name: MySQL 8.1 integration test
    runs-on: ubuntu-latest

    steps:
      - name: Run MySQL 8.1
        run: |
          docker run -e MYSQL_ROOT_PASSWORD=mysql -p 3306:3306 -d mysql:8.1 --character-set-server=utf8mb4 --collation-server=utf8mb4_bin

      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: mysql_8.1_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-postgresql-12:
    name: PostgreSQL 12 integration test
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:12-alpine
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
        ports:
          - 5432:5432

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:postgresql://localhost:5432/ -Dscalardb.jdbc.username=postgres -Dscalardb.jdbc.password=postgres

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: postgresql_12_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-postgresql-13:
    name: PostgreSQL 13 integration test
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:13-alpine
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
        ports:
          - 5432:5432

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:postgresql://localhost:5432/ -Dscalardb.jdbc.username=postgres -Dscalardb.jdbc.password=postgres

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: postgresql_13_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-postgresql-14:
    name: PostgreSQL 14 integration test
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:14-alpine
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
        ports:
          - 5432:5432

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:postgresql://localhost:5432/ -Dscalardb.jdbc.username=postgres -Dscalardb.jdbc.password=postgres

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: postgresql_14_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-postgresql-15:
    name: PostgreSQL 15 integration test
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:15-alpine
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
        ports:
          - 5432:5432

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:postgresql://localhost:5432/ -Dscalardb.jdbc.username=postgres -Dscalardb.jdbc.password=postgres

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: postgresql_15_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-oracle-18:
    name: Oracle 18 integration test
    runs-on: ubuntu-latest

    services:
      oracle:
        image: ghcr.io/scalar-labs/oracle/db-prebuilt:18
        credentials:
          username: ${{ github.repository_owner }}
          password: ${{ secrets.CR_PAT }}
        env:
          ORACLE_PWD: Oracle
        ports:
          - 1521:1521
        options: >-
          --health-cmd "/opt/oracle/checkDBStatus.sh"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 120
    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:oracle:thin:@//localhost:1521/XEPDB1 -Dscalardb.jdbc.username=SYSTEM -Dscalardb.jdbc.password=Oracle

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: oracle_18_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-oracle-21:
    name: Oracle 21 integration test
    runs-on: ubuntu-latest

    services:
      oracle:
        image: ghcr.io/scalar-labs/oracle/db-prebuilt:21
        credentials:
          username: ${{ github.repository_owner }}
          password: ${{ secrets.CR_PAT }}
        env:
          ORACLE_PWD: Oracle
        ports:
          - 1521:1521
        options: >-
          --health-cmd "/opt/oracle/checkDBStatus.sh"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 120
    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:oracle:thin:@//localhost:1521/XEPDB1 -Dscalardb.jdbc.username=SYSTEM -Dscalardb.jdbc.password=Oracle

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: oracle_21_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-oracle-23:
    name: Oracle 23 integration test
    runs-on: ubuntu-latest

    steps:
      - name: Free up ~14GB of disk space by removing the Android SDK
        run: |
          echo "Storage available before deletion"
          df -h /
          echo
          sudo rm -r /usr/local/lib/android
          echo "Storage available after deletion"
          df -h /

      - name: Login to GitHub Container Registry
        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
          password: ${{ secrets.CR_PAT }}

      - name: Start Oracle 23 container
        run: docker run -d --name oracle-23 -p 1521:1521  ghcr.io/scalar-labs/oracle/db-prebuilt:23

      - name: Wait for the container to be ready
        timeout-minutes: 5
        run : |
          while [ "`docker inspect -f {{.State.Health.Status}} oracle-23`" != "healthy" ]
          do
            sleep 10
            echo "Container is not yet ready"
          done
          echo "Container is ready"

      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:oracle:thin:@//localhost:1521/FREEPDB1 -Dscalardb.jdbc.username=SYSTEM -Dscalardb.jdbc.password=Oracle

      - name: Stop Oracle 23 container
        if: always()
        run: docker stop oracle-23 | xargs docker rm

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: oracle_23_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-sqlserver-2017:
    name: SQL Server 2017 integration test
    runs-on: ubuntu-latest

    services:
      sqlserver:
        image: mcr.microsoft.com/mssql/server:2017-latest
        env:
          MSSQL_PID: "Express"
          SA_PASSWORD: "SqlServer17"
          ACCEPT_EULA: "Y"
        ports:
          - 1433:1433
        options: --name sqlserver17

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Create no superuser
        run: ./ci/no-superuser/create-no-superuser-sqlserver.sh sqlserver17 SqlServer17 10 3
        timeout-minutes: 1

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:sqlserver://localhost:1433;databaseName=test_db;encrypt=true;trustServerCertificate=true -Dscalardb.jdbc.username=no_superuser -Dscalardb.jdbc.password=no_superuser_password

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: sqlserver_2017_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-sqlserver-2019:
    name: SQL Server 2019 integration test
    runs-on: ubuntu-latest

    services:
      sqlserver:
        image: mcr.microsoft.com/mssql/server:2019-latest
        env:
          MSSQL_PID: "Express"
          SA_PASSWORD: "SqlServer19"
          ACCEPT_EULA: "Y"
        ports:
          - 1433:1433
        options: --name sqlserver19

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Create no superuser
        run: ./ci/no-superuser/create-no-superuser-sqlserver.sh sqlserver19 SqlServer19 10 3
        timeout-minutes: 1

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:sqlserver://localhost:1433;databaseName=test_db;encrypt=true;trustServerCertificate=true -Dscalardb.jdbc.username=no_superuser -Dscalardb.jdbc.password=no_superuser_password

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: sqlserver_2019_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-sqlserver-2022:
    name: SQL Server 2022 integration test
    runs-on: ubuntu-latest

    services:
      sqlserver:
        image: mcr.microsoft.com/mssql/server:2022-latest
        env:
          MSSQL_PID: "Express"
          SA_PASSWORD: "SqlServer22"
          ACCEPT_EULA: "Y"
        ports:
          - 1433:1433
        options: --name sqlserver22

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Create no superuser
        run: ./ci/no-superuser/create-no-superuser-sqlserver.sh sqlserver22 SqlServer22 10 3
        timeout-minutes: 1

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:sqlserver://localhost:1433;databaseName=test_db;encrypt=true;trustServerCertificate=true -Dscalardb.jdbc.username=no_superuser -Dscalardb.jdbc.password=no_superuser_password

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: sqlserver_2022_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-sqlite-3:
    name: SQLite 3 integration test
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Set up SQLite3
        run: sudo apt-get install -y sqlite3

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:sqlite:integration.sqlite3?busy_timeout=50000

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: sqlite_3_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-mariadb-10:
    name: MariaDB 10 integration test
    runs-on: ubuntu-latest

    steps:
      - name: Run MariaDB 10.11
        run: |
          docker run -e MYSQL_ROOT_PASSWORD=mysql -p 3306:3306 -d mariadb:10.11 --character-set-server=utf8mb4 --collation-server=utf8mb4_bin

      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: mariadb_10_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-jdbc-yugabytedb-2:
    name: YugabyteDB 2 integration test
    runs-on: ubuntu-latest

    steps:
      - name: Run YugabyteDB 2
        run: |
          docker run -p 5433:5433 -e YSQL_USER=yugabyte -e YSQL_PASSWORD=yugabyte -d yugabytedb/yugabyte:2.21.0.0-b545 bin/yugabyted start --background=false --master_flag="ysql_enable_db_catalog_version_mode=false" --tserver_flags="ysql_enable_db_catalog_version_mode=false"

      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:yugabytedb://localhost:5433/ -Dscalardb.jdbc.username=yugabyte -Dscalardb.jdbc.password=yugabyte -Dscalar.db.jdbc.connection_pool.max_total=12 -Dscalar.db.jdbc.table_metadata.connection_pool.max_total=4 -Dscalar.db.jdbc.admin.connection_pool.max_total=4

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: yugabytedb_2_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc

  integration-test-for-multi-storage:
    name: Multi-storage integration test
    runs-on: ubuntu-latest

    services:
      cassandra:
        image: cassandra:3.11
        env:
          MAX_HEAP_SIZE: 2048m
          HEAP_NEWSIZE: 512m
        ports:
          - 9042:9042

    steps:
      - name: Run MySQL 8
        run: |
          docker run -e MYSQL_ROOT_PASSWORD=mysql -p 3306:3306 -d mysql:8 --character-set-server=utf8mb4 --collation-server=utf8mb4_bin

      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestMultiStorage' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestMultiStorage -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Upload Gradle test reports
        uses: actions/upload-artifact@v4
        if : always()
        with:
          name: multi_storage_integration_test_reports
          path: core/build/reports/tests/integrationTestMultiStorage

  integration-test-for-scalardb-server:
    name: ScalarDB Server integration test
    runs-on: ubuntu-latest

    steps:
      - name: Run MySQL 8
        run: |
          docker run -e MYSQL_ROOT_PASSWORD=mysql -p 3306:3306 -d mysql:8 --character-set-server=utf8mb4 --collation-server=utf8mb4_bin

      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestScalarDbServer' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestScalarDbServer -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Upload Gradle test reports
        uses: actions/upload-artifact@v4
        if : always()
        with:
          name: scalardb_server_integration_test_reports
          path: server/build/reports/tests/integrationTestScalarDbServer

  integration-test-for-group-commit:
    name: Integration test using group commit
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:15-alpine
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
        ports:
          - 5432:5432

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK ${{ env.JAVA_VERSION }} (${{ env.JAVA_VENDOR }}) }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.JAVA_VENDOR }}

      - name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (${{ env.INT_TEST_JAVA_RUNTIME_VENDOR}}) to run integration test
        uses: actions/setup-java@v4
        if: ${{ !(env.INT_TEST_JAVA_RUNTIME_VERSION == env.JAVA_VERSION && env.INT_TEST_JAVA_RUNTIME_VENDOR == env.JAVA_VENDOR) }}
        with:
          java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
          distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

      - name: Setup and execute Gradle 'integrationTestJdbc' task
        uses: gradle/gradle-build-action@v3
        with:
          arguments: integrationTestJdbc -PintegrationTestJavaRuntimeVersion=${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} -PintegrationTestJavaRuntimeVendor=${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }} -Dscalardb.jdbc.url=jdbc:postgresql://localhost:5432/ -Dscalardb.jdbc.username=postgres -Dscalardb.jdbc.password=postgres -Dscalar.db.consensus_commit.coordinator.group_commit.enabled=true -Dscalar.db.consensus_commit.coordinator.group_commit.old_group_abort_timeout_millis=15000 --tests "**ConsensusCommit**"

      - name: Upload Gradle test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: group_commit_integration_test_reports
          path: core/build/reports/tests/integrationTestJdbc