Backport to branch(3.12) : Fix GetBuilder and ScanBuilder #5039

Workflow file for this run

	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 }}"
	# Gradle will parse 'ORG_GRADLE_PROJECT_<project_property_name>' environment variables as project properties.
	# The following variables configure the 'com.scalar.db.jdk-configuration' Gradle plugin.
	ORG_GRADLE_PROJECT_javaVersion: '8'
	ORG_GRADLE_PROJECT_javaVendor: 'temurin'
	ORG_GRADLE_PROJECT_integrationTestJavaRuntimeVersion: "${{ github.event_name != 'workflow_dispatch' && '8' \|\| inputs.INT_TEST_JAVA_RUNTIME_VERSION }}"
	ORG_GRADLE_PROJECT_integrationTestJavaRuntimeVendor: "${{ github.event_name != 'workflow_dispatch' && 'temurin' \|\| inputs.INT_TEST_JAVA_RUNTIME_VENDOR }}"
	# This variable evaluates to: if {!(Temurin JDK 8) && !(Oracle JDK)} then {true} else {false}
	SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK: "${{ (github.event_name == 'workflow_dispatch' && !(inputs.INT_TEST_JAVA_RUNTIME_VERSION == '8' && inputs.INT_TEST_JAVA_RUNTIME_VENDOR == 'temurin') && !(inputs.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle')) && 'true' \|\| 'false' }}"

	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 Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'check' task
	run: ./gradlew 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: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Dockerfile Lint for ScalarDB Server
	run: ./gradlew server:dockerfileLint

	- name: Dockerfile Lint for ScalarDB Schema Loader
	run: ./gradlew 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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestCassandra' task
	run: ./gradlew integrationTestCassandra

	- 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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestCassandra' task
	run: ./gradlew integrationTestCassandra

	- 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: windows-latest
	env:
	# This variable evaluates to: if {!(Temurin JDK 8) && !(Oracle JDK 8 or 11)} then {true} else {false}
	SET_UP_INT_TEST_RUNTIME_JDK_WHEN_NOT_ORACLE_8_OR_11: "${{ (github.event_name == 'workflow_dispatch' && !(inputs.INT_TEST_JAVA_RUNTIME_VERSION == '8' && inputs.INT_TEST_JAVA_RUNTIME_VENDOR == 'temurin') && !(inputs.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' && (inputs.INT_TEST_JAVA_RUNTIME_VERSION == '8' \|\| inputs.INT_TEST_JAVA_RUNTIME_VERSION == '11'))) && 'true' \|\| 'false' }}"
	SET_UP_INT_TEST_RUNTIME_ORACLE_JDK_8_OR_11: "${{ (inputs.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' && (inputs.INT_TEST_JAVA_RUNTIME_VERSION == '8' \|\| inputs.INT_TEST_JAVA_RUNTIME_VERSION == '11')) && 'true' \|\| 'false' }}"

	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.SET_UP_INT_TEST_RUNTIME_JDK_WHEN_NOT_ORACLE_8_OR_11 == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

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

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.SET_UP_INT_TEST_RUNTIME_ORACLE_JDK_8_OR_11 == 'true'}}
	run: \|
	$container_id=$(docker create "ghcr.io/scalar-labs/oracle/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}-windows")
	docker cp "${container_id}:oracle-jdk.exe" .
	docker rm "$container_id"
	Write-Host "Install Oracle JDK"
	Start-Process "oracle-jdk.exe" -NoNewWindow -Wait -ArgumentList "/s"
	Write-Host "Oracle JDK installation successful"
	if ( ${env:INT_TEST_JAVA_RUNTIME_VERSION} -eq '8' ) {
	$jdk_root_dir = "jdk-1.8"
	} else {
	$jdk_root_dir = "jdk-11"
	}
	echo "JAVA_HOME=C:\Program Files\Java\${jdk_root_dir}" >> ${env:GITHUB_ENV}

	- name: Start Azure Cosmos DB emulator
	run: \|
	Write-Host "Launching Cosmos DB Emulator"
	Import-Module "$env:ProgramFiles\Azure Cosmos DB Emulator\PSModules\Microsoft.Azure.CosmosDB.Emulator"
	# Set startup timeout to 10min (600s), the default is 4min
	Start-CosmosDbEmulator -Consistency Strong -Timeout 600

	- name: Install TLS/SSL certificate
	run: \|
	$cert = Get-ChildItem Cert:\LocalMachine\My \| where{$_.FriendlyName -eq 'DocumentDbEmulatorCertificate'}
	$params = @{
	Cert = $cert
	Type = "CERT"
	FilePath = "$home/tmp-cert.cer"
	NoClobber = $true
	}
	Export-Certificate @params
	certutil -encode $home/tmp-cert.cer $home/cosmosdbcert.cer
	Remove-Item $home/tmp-cert.cer
	# Setting the keystore option differs between Java 8 and Java 11+
	if ( ${env:INT_TEST_JAVA_RUNTIME_VERSION} -eq '8' ) {
	$keystore = "-keystore", "${env:JAVA_HOME}/jre/lib/security/cacerts"
	} else {
	$keystore = "-cacerts"
	}
	& ${env:JAVA_HOME}/bin/keytool.exe $keystore -storepass 'changeit' -importcert -noprompt -alias cosmos_emulator -file $home/cosmosdbcert.cer
	& ${env:JAVA_HOME}/bin/keytool.exe $keystore -storepass 'changeit' -list -alias cosmos_emulator

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestCosmos' task
	run: ./gradlew.bat integrationTestCosmos "-Dscalardb.cosmos.uri=https://localhost:8081/" "-Dscalardb.cosmos.password=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==" "-Dfile.encoding=UTF-8"

	- 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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestDynamo' task
	run: ./gradlew integrationTestDynamo

	- 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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc

	- 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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc

	- 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-4:
	name: MySQL 8.4 integration test
	runs-on: ubuntu-latest

	steps:
	- name: Run MySQL 8.4
	run: \|
	docker run -e MYSQL_ROOT_PASSWORD=mysql -p 3306:3306 -d mysql:8.4 --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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc

	- name: Upload Gradle test reports
	if: always()
	uses: actions/upload-artifact@v4
	with:
	name: mysql_8.4_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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc -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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc -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_${{ matrix.mode.label }}
	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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc -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-postgresql-16:
	name: PostgreSQL 16 integration test
	runs-on: ubuntu-latest

	services:
	postgres:
	image: postgres:16-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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc -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_16_integration_test_reports
	path: core/build/reports/tests/integrationTestJdbc

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

	services:
	postgres:
	image: postgres:17-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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc -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_17_integration_test_reports
	path: core/build/reports/tests/integrationTestJdbc

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

	services:
	oracle:
	image: ghcr.io/scalar-labs/oracle/db-prebuilt:19
	credentials:
	username: ${{ github.repository_owner }}
	password: ${{ secrets.CR_PAT }}
	ports:
	- 1521:1521

	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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc -Dscalardb.jdbc.url=jdbc:oracle:thin:@//localhost:1521/ORCLPDB1 -Dscalardb.jdbc.username=SYSTEM -Dscalardb.jdbc.password=Oracle

	- name: Upload Gradle test reports
	if: always()
	uses: actions/upload-artifact@v4
	with:
	name: oracle_19_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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc -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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc -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-20.04

	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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

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

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc "-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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

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

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc "-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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

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

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc "-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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

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

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc -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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc

	- 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-mariadb-11-4:
	name: MariaDB 11.4 integration test
	runs-on: ubuntu-latest

	steps:
	- name: Run MariaDB 11.4
	run: \|
	docker run -e MYSQL_ROOT_PASSWORD=mysql -p 3306:3306 -d mariadb:11.4 --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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestJdbc' task
	run: ./gradlew integrationTestJdbc

	- name: Upload Gradle test reports
	if: always()
	uses: actions/upload-artifact@v4
	with:
	name: mariadb_11.4_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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestMultiStorage' task
	run: ./gradlew integrationTestMultiStorage

	- 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.SET_UP_INT_TEST_RUNTIME_NON_ORACLE_JDK == 'true'}}
	with:
	java-version: ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}
	distribution: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR }}

	- name: Login to Oracle container registry
	uses: docker/login-action@v3
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	with:
	registry: container-registry.oracle.com
	username: ${{ secrets.OCR_USERNAME }}
	password: ${{ secrets.OCR_TOKEN }}

	- name: Set up JDK ${{ env.INT_TEST_JAVA_RUNTIME_VERSION }} (oracle) to run the integration test
	if: ${{ env.INT_TEST_JAVA_RUNTIME_VENDOR == 'oracle' }}
	run: \|
	container_id=$(docker create "container-registry.oracle.com/java/jdk:${{ env.INT_TEST_JAVA_RUNTIME_VERSION }}")
	docker cp -L "$container_id:/usr/java/default" /usr/lib/jvm/oracle-jdk && docker rm "$container_id"

	- name: Setup Gradle
	uses: gradle/actions/setup-gradle@v4

	- name: Execute Gradle 'integrationTestScalarDbServer' task
	run: ./gradlew integrationTestScalarDbServer

	- 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

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Backport to branch(3.12) : Fix GetBuilder and ScanBuilder #5039

Workflow file

Backport to branch(3.12) : Fix GetBuilder and ScanBuilder #5039

Jobs

Run details

Workflow file for this run