implement ConnectionProvider

build.gradle.kts

@@ -17,38 +17,38 @@
 import net.ltgt.gradle.errorprone.errorprone
 
 plugins {
-    // Apply the java-library plugin for API and implementation separation.
     `java-library`
     alias(libs.plugins.spotless)
     alias(libs.plugins.errorprone)
 }
 
 repositories {
-    // Use Maven Central for resolving dependencies.
     mavenCentral()
 }
 
 dependencies {
-    // Use JUnit Jupiter for testing.
     testImplementation(libs.junit.jupiter)
+    testImplementation(libs.logback.classic)
 
-    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+    testRuntimeOnly(libs.junit.platform.launcher)
 
     errorprone(libs.nullaway)
     api(libs.jspecify)
 
     errorprone(libs.google.errorprone.core)
+
+    implementation(libs.hibernate.core)
+    implementation(libs.mongo.java.driver.sync)
+    implementation(libs.sl4j.api)
 }
 
-// Apply a specific Java toolchain to ease working on different environments.
 java {
     toolchain {
         languageVersion = JavaLanguageVersion.of(17)
     }
 }
 
 tasks.named<Test>("test") {
-    // Use JUnit Platform for unit tests.
     useJUnitPlatform()
 }
 
@@ -57,8 +57,7 @@ tasks.named<Test>("test") {
 
 spotless {
     java {
-        // note: you can use an empty string for all the imports you didn't specify explicitly, '|' to join group without blank line, and '\\#` prefix for static imports
-        importOrder("java|javax", "", "\\#")
+        importOrder()
 
         removeUnusedImports()
 

gradle/libs.versions.toml

@@ -2,19 +2,28 @@
 # https://docs.gradle.org/current/userguide/platforms.html#sub::toml-dependencies-format
 
 [versions]
-junit-jupiter = "5.10.3"
+junit-jupiter = "5.11.3"
 spotless = "6.25.0"
 palantir = "2.50.0"
-errorprone = "4.0.1"
-google-errorprone-core = "2.9.0"
-nullaway = "0.10.26"
-jspecify = "0.3.0"
+errorprone = "4.1.0"
+google-errorprone-core = "2.35.1"
+nullaway = "0.12.1"
+jspecify = "1.0.0"
+hibernate-core = "6.6.1.Final"
+mongo-java-driver-sync = "5.2.0"
+slf4j-api = "2.0.16"
+logback-classic = "1.5.12"
 
 [libraries]
 junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" }
+junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher" }
 nullaway = { module = "com.uber.nullaway:nullaway", version.ref = "nullaway" }
 jspecify = { module = "org.jspecify:jspecify", version.ref = "jspecify" }
 google-errorprone-core = { module = "com.google.errorprone:error_prone_core", version.ref = "google-errorprone-core" }
+hibernate-core = { module = "org.hibernate.orm:hibernate-core", version.ref = "hibernate-core" }
+mongo-java-driver-sync = { module = "org.mongodb:mongodb-driver-sync", version.ref = "mongo-java-driver-sync" }
+sl4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j-api" }
+logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback-classic" }
 
 [plugins]
 spotless = { id = "com.diffplug.spotless", version.ref = "spotless" }

src/main/java/com/mongodb/hibernate/NotYetImplementedException.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2024-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mongodb.hibernate;
+
+/**
+ * A temporary marker exception to denote that the feature in question is in the scope of MongoDB dialect but has not
+ * been implemented yet.
+ *
+ * <p>Ultimately all of its references should be eliminated sooner or later, and then this class is supposed to be
+ * deleted prior to product release.
+ *
+ * <p>It is recommended to provide some message to explain when it will be implemented (e.g. JIRA ticket id is a good
+ * idea), but that is optional.
+ */
+public class NotYetImplementedException extends RuntimeException {
+
+    /**
+     * Default constructor.
+     *
+     * <p>It is recommended to use the other constructor with some explanation.
+     */
+    public NotYetImplementedException() {}
+
+    /**
+     * Constructor with message parameter.
+     *
+     * @param message explanation on when the feature is to be implemented
+     */
+    public NotYetImplementedException(String message) {
+        super(message);
+    }
+}

src/main/java/com/mongodb/hibernate/dialect/MongoDialect.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2024-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mongodb.hibernate.dialect;
+
+import org.hibernate.dialect.DatabaseVersion;
+import org.hibernate.dialect.Dialect;
+
+/**
+ * A MongoDB {@linkplain Dialect} for version 6.0 and above.
+ *
+ * <p>Usually Hibernate dialect represents some SQL RDBMS and speaks SQL with vendor-specific difference. MongoDB is a
+ * document DB and speaks <i>MQL</i> (MongoDB Query Language) in JSON format, but it is still possible to integrate with
+ * Hibernate seamlessly by creating a JDBC adaptor on top of MongoDB's Java client library.
+ *
+ * <p>Some MongoDB-specific customization examples include:
+ *
+ * <ul>
+ *   <li>MQL translation extension point
+ *   <li>SQL {@linkplain java.sql.Types#ARRAY ARRAY} and {@linkplain java.sql.Types#STRUCT STRUCT} extension points to
+ *       support MongoDB's embedding array and document
+ *   <li>MQL parameterization customization
+ * </ul>
+ */
+public class MongoDialect extends Dialect {
+    public static final int MINIMUM_MONGODB_MAJOR_VERSION_SUPPORTED = 6;
+    public static final int MINIMUM_MONGODB_MINOR_VERSION_SUPPORTED = 0;
+
+    private static final DatabaseVersion MINIMUM_VERSION =
+            DatabaseVersion.make(MINIMUM_MONGODB_MAJOR_VERSION_SUPPORTED, MINIMUM_MONGODB_MINOR_VERSION_SUPPORTED);
+
+    /**
+     * Default constructor used when no version info is available.
+     *
+     * <p>Note that {@link Dialect} abstract class has two overloaded constructors accepting sole parameter, and only
+     * one accepts {@code null} value. Explicitly downcast to make the intention clear.
+     */
+    public MongoDialect() {
+        super((DatabaseVersion) null);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected DatabaseVersion getMinimumSupportedVersion() {
+        return MINIMUM_VERSION;
+    }
+}

src/main/java/com/mongodb/hibernate/jdbc/MongoConnectionProvider.java

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2024-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mongodb.hibernate.jdbc;
+
+import static org.hibernate.cfg.JdbcSettings.*;
+
+import com.mongodb.ConnectionString;
+import com.mongodb.MongoClientSettings;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.hibernate.NotYetImplementedException;
+import java.sql.Connection;
+import java.util.Map;
+import org.hibernate.HibernateException;
+import org.hibernate.cfg.JdbcSettings;
+import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
+import org.hibernate.service.UnknownUnwrapTypeException;
+import org.hibernate.service.spi.Configurable;
+import org.hibernate.service.spi.Stoppable;
+import org.jspecify.annotations.Nullable;
+
+/**
+ * MongoDB dialect's customized JDBC {@link ConnectionProvider} SPI implementation, whose class name could be provided
+ * using configuration property {@value org.hibernate.cfg.JdbcSettings#CONNECTION_PROVIDER}.
+ *
+ * <p>The following Hibernate JDBC properties will be relied upon by Hibernate's {@link Configurable} SPI mechanism:
+ *
+ * <ul>
+ *   <li>{@linkplain org.hibernate.cfg.JdbcSettings#JAKARTA_JDBC_URL jakarta.persistence.jdbc.url}
+ *   <li>{@linkplain org.hibernate.cfg.JdbcSettings#JAKARTA_JDBC_USER jakarta.persistence.jdbc.user}
+ *   <li>{@linkplain org.hibernate.cfg.JdbcSettings#JAKARTA_JDBC_PASSWORD jakarta.persistence.jdbc.password}
+ * </ul>
+ *
+ * <p>{@value org.hibernate.cfg.JdbcSettings#JAKARTA_JDBC_URL} property is mandatory and it maps to MongoDB's <a
+ * href="https://www.mongodb.com/docs/manual/reference/connection-string/">connection string</a>, in which database name
+ * must be provided to align with JDBC URL's convention. The other two JDBC properties are optional.
+ *
+ * @see ConnectionProvider
+ * @see JdbcSettings#JAKARTA_JDBC_URL
+ * @see JdbcSettings#JAKARTA_JDBC_USER
+ * @see JdbcSettings#JAKARTA_JDBC_PASSWORD
+ * @see <a href="https://www.mongodb.com/docs/manual/reference/connection-string/">connection string</a>
+ */
+public class MongoConnectionProvider implements ConnectionProvider, Configurable, Stoppable {
+
+    private @Nullable MongoClient mongoClient;
+
+    @Override
+    public Connection getConnection() {
+        throw new NotYetImplementedException(
+                "To be implemented in scope of https://jira.mongodb.org/browse/HIBERNATE-29");
+    }
+
+    @Override
+    public void closeConnection(Connection connection) {
+        throw new NotYetImplementedException(
+                "To be implemented in scope of https://jira.mongodb.org/browse/HIBERNATE-29");
+    }
+
+    @Override
+    public boolean supportsAggressiveRelease() {
+        return false;
+    }
+
+    @Override
+    public boolean isUnwrappableAs(Class<?> unwrapType) {
+        return false;
+    }
+
+    @Override
+    public <T> T unwrap(Class<T> unwrapType) {
+        throw new UnknownUnwrapTypeException(unwrapType);
+    }
+
+    @Override
+    public void configure(Map<String, Object> configValues) {
+        var jdbcUrl = configValues.get(JAKARTA_JDBC_URL);
+        if (jdbcUrl == null) {
+            throw new HibernateException("Configuration is required: " + JAKARTA_JDBC_URL);
+        }
+        if (!(jdbcUrl instanceof String)) {
+            throw new HibernateException(
+                    String.format("Configuration ('%s') value ('%s') not of string type", JAKARTA_JDBC_URL, jdbcUrl));
+        }
+        ConnectionString connectionString;
+        try {
+            connectionString = new ConnectionString((String) jdbcUrl);
+        } catch (IllegalArgumentException iae) {
+            throw new HibernateException("Invalid MongoDB connection string: " + jdbcUrl, iae);
+        }
+        var database = connectionString.getDatabase();
+        if (database == null) {
+            throw new HibernateException("Database must be provided in connection string: " + jdbcUrl);
+        }
+
+        var clientSettingsBuilder = MongoClientSettings.builder().applyConnectionString(connectionString);
+
+        if (configValues.get(JAKARTA_JDBC_USER) != null || configValues.get(JAKARTA_JDBC_PASSWORD) != null) {
+            throw new NotYetImplementedException("To be implemented after auth could be tested in CI");
+        }
+
+        var clientSettings = clientSettingsBuilder.build();
+        this.mongoClient = MongoClients.create(clientSettings);
+    }
+
+    @Override
+    public void stop() {
+        if (this.mongoClient != null) {
+            this.mongoClient.close();
+        }
+    }
+}

src/main/java/com/mongodb/hibernate/package-info.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2024-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The root package for MongoDB Dialect library, whose main sub-packages include:
+ *
+ * <dl>
+ *   <dt>dialect
+ *   <dd>MongoDB Dialect related classes
+ *   <dt>jdbc
+ *   <dd>various JDBC API implementation classes
+ *   <dt>translate
+ *   <dd>MQL translation (from Hibernate's SQL AST) classes
+ * </dl>
+ */
+@NullMarked
+package com.mongodb.hibernate;
+
+import org.jspecify.annotations.NullMarked;