Fix jsonb support to work with 5.x

pom.xml

@@ -20,11 +20,11 @@
 		</developer>
 	</developers>
 	<properties>
-		<java.version>1.8</java.version>
-		<maven.compiler.target>1.8</maven.compiler.target>
+		<java.version>11</java.version>
+		<maven.compiler.target>11</maven.compiler.target>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<spring-boot.version>2.0.0.RELEASE</spring-boot.version>
-		<spring-data-releasetrain.version>Kay-RELEASE</spring-data-releasetrain.version>
+		<spring-boot.version>2.7.18</spring-boot.version>
+		<spring-data.version>2021.2.18</spring-data.version>
 		<querydsl.version>4.1.4</querydsl.version>
 		<rsql-parser.version>2.1.0</rsql-parser.version>
 		<lombok.version>1.18.10</lombok.version>
@@ -54,8 +54,8 @@
 			</dependency>
 			<dependency>
 				<groupId>org.springframework.data</groupId>
-				<artifactId>spring-data-releasetrain</artifactId>
-				<version>${spring-data-releasetrain.version}</version>
+				<artifactId>spring-data-bom</artifactId>
+				<version>${spring-data.version}</version>
 				<type>pom</type>
 				<scope>import</scope>
 			</dependency>

rsql-common/pom.xml

@@ -37,6 +37,12 @@
 			<artifactId>hamcrest</artifactId>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>io.hypersistence</groupId>
+			<artifactId>hypersistence-utils-hibernate-62</artifactId>
+			<version>3.5.1</version>
+			<scope>test</scope>
+		</dependency>
 		<dependency>
 			<groupId>com.h2database</groupId>
 			<artifactId>h2</artifactId>

rsql-common/src/main/java/io/github/perplexhub/rsql/RSQLVisitorBase.java

@@ -12,7 +12,10 @@
 import javax.persistence.metamodel.ManagedType;
 import javax.persistence.metamodel.PluralAttribute;
 
+import lombok.Getter;
+import org.springframework.core.convert.ConversionFailedException;
 import org.springframework.core.convert.support.ConfigurableConversionService;
+import org.springframework.orm.jpa.vendor.Database;
 import org.springframework.util.StringUtils;
 
 import cz.jirutka.rsql.parser.ast.RSQLVisitor;
@@ -26,6 +29,7 @@ public abstract class RSQLVisitorBase<R, A> implements RSQLVisitor<R, A> {
 
 	protected static volatile @Setter Map<Class, ManagedType> managedTypeMap;
 	protected static volatile @Setter Map<String, EntityManager> entityManagerMap;
+	protected static volatile @Setter @Getter Map<EntityManager, Database> entityManagerDatabase = Map.of();
 	protected static final Map<Class, Class> primitiveToWrapper;
 	protected static volatile @Setter Map<Class<?>, Map<String, String>> propertyRemapping;
 	protected static volatile @Setter Map<Class<?>, List<String>> globalPropertyWhitelist;

rsql-common/src/test/java/io/github/perplexhub/rsql/UnknownPropertyExceptionTest.java

@@ -3,7 +3,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import io.github.perplexhub.rsql.model.User;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class UnknownPropertyExceptionTest {
 

rsql-jpa-spring-boot-starter/src/main/java/io/github/perplexhub/rsql/RSQLJPAAutoConfiguration.java

@@ -1,24 +1,129 @@
 package io.github.perplexhub.rsql;
 
-import java.util.Map;
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.toMap;
 
+import io.github.perplexhub.rsql.RSQLJPAAutoConfiguration.HibernateEntityManagerDatabaseConfiguration;
 import javax.persistence.EntityManager;
-
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Optional;
+import lombok.extern.slf4j.Slf4j;
+import org.hibernate.Session;
+import org.hibernate.dialect.AbstractHANADialect;
+import org.hibernate.dialect.DB2Dialect;
+import org.hibernate.dialect.DerbyDialect;
+import org.hibernate.dialect.Dialect;
+import org.hibernate.dialect.H2Dialect;
+import org.hibernate.dialect.HSQLDialect;
+import org.hibernate.dialect.MySQLDialect;
+import org.hibernate.dialect.OracleDialect;
+import org.hibernate.dialect.PostgreSQLDialect;
+import org.hibernate.dialect.SQLServerDialect;
+import org.hibernate.dialect.SybaseDialect;
+import org.hibernate.engine.spi.SessionImplementor;
+import org.hibernate.internal.SessionFactoryImpl;
+import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-
-import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.annotation.Import;
+import org.springframework.orm.jpa.vendor.Database;
 
 @Slf4j
 @Configuration
 @ConditionalOnClass(EntityManager.class)
+@Import(HibernateEntityManagerDatabaseConfiguration.class)
 public class RSQLJPAAutoConfiguration {
 
-	@Bean
-	public RSQLCommonSupport rsqlCommonSupport(Map<String, EntityManager> entityManagerMap) {
-		log.info("RSQLJPAAutoConfiguration.rsqlCommonSupport(entityManagerMap:{})", entityManagerMap.size());
-		return new RSQLCommonSupport(entityManagerMap);
-	}
+  @Bean
+  public RSQLCommonSupport rsqlCommonSupport(Map<String, EntityManager> entityManagerMap,
+      ObjectProvider<EntityManagerDatabase> entityManagerDatabaseProvider) {
+    log.info("RSQLJPAAutoConfiguration.rsqlCommonSupport(entityManagerMap:{})", entityManagerMap.size());
+    var entityManagerDatabase = entityManagerDatabaseProvider.getIfAvailable(() -> new EntityManagerDatabase(Map.of()));
+
+    return new RSQLJPASupport(entityManagerMap, entityManagerDatabase.value());
+  }
+
+  @Configuration
+  @ConditionalOnClass(SessionImplementor.class)
+  static
+  class HibernateEntityManagerDatabaseConfiguration {
+
+    @Bean
+    public EntityManagerDatabase entityManagerDatabase(ObjectProvider<EntityManager> entityManagers) {
+      return entityManagers.stream()
+          .map(entityManager -> {
+            var sessionFactory = entityManager.unwrap(Session.class).getSessionFactory();
+            var dialect = ((SessionFactoryImpl) sessionFactory).getJdbcServices().getDialect();
+
+            return Optional.ofNullable(toDatabase(dialect))
+                .map(db -> Map.entry(entityManager, db))
+                .orElse(null);
+          })
+          .filter(Objects::nonNull)
+          .collect(collectingAndThen(
+              toMap(Entry::getKey, Entry::getValue, (db1, db2) -> db1, IdentityHashMap::new),
+              m -> new EntityManagerDatabase(m)
+          ));
+    }
+
+    private Database toDatabase(Dialect dialect) {
+      if (dialect instanceof PostgreSQLDialect) {
+        return Database.POSTGRESQL;
+      } else if (dialect instanceof MySQLDialect) {
+        return Database.MYSQL;
+      } else if (dialect instanceof SQLServerDialect) {
+        return Database.SQL_SERVER;
+      } else if (dialect instanceof OracleDialect) {
+        return Database.ORACLE;
+      } else if (dialect instanceof DerbyDialect) {
+        return Database.DERBY;
+      } else if (dialect instanceof DB2Dialect) {
+        return Database.DB2;
+      } else if (dialect instanceof H2Dialect) {
+        return Database.H2;
+      } else if (dialect instanceof AbstractHANADialect) {
+        return Database.HANA;
+      } else if (dialect instanceof HSQLDialect) {
+        return Database.HSQL;
+      } else if (dialect instanceof SybaseDialect) {
+        return Database.SQL_SERVER;
+      }
+
+      return null;
+    }
+  }
+
+  public static final class EntityManagerDatabase {
+      private final Map<EntityManager, Database> value;
+
+      public EntityManagerDatabase(Map<EntityManager, Database> value) {
+          this.value = value;
+      }
+
+      public Map<EntityManager, Database> value() {
+          return value;
+      }
+
+      @Override
+      public boolean equals(Object obj) {
+          if (this == obj) return true;
+          if (obj == null || getClass() != obj.getClass()) return false;
+          EntityManagerDatabase that = (EntityManagerDatabase) obj;
+          return Objects.equals(value, that.value);
+      }
+
+      @Override
+      public int hashCode() {
+          return Objects.hash(value);
+      }
 
+      @Override
+      public String toString() {
+          return "EntityManagerDatabase[value=" + value + "]";
+      }
+  }
 }

rsql-jpa-spring-boot-starter/src/test/java/io/github/perplexhub/rsql/RSQLSpecificationSupportTest.java

@@ -2,12 +2,11 @@
 
 import static io.github.perplexhub.rsql.RSQLJPASupport.*;
 import static org.hamcrest.CoreMatchers.*;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 import java.util.List;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
@@ -20,7 +19,6 @@
 import lombok.extern.slf4j.Slf4j;
 
 @Slf4j
-@RunWith(SpringRunner.class)
 @SpringBootTest(classes = Application.class, webEnvironment = WebEnvironment.NONE)
 public class RSQLSpecificationSupportTest {
 

rsql-jpa/pom.xml

@@ -41,6 +41,23 @@
 			<artifactId>h2</artifactId>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>org.postgresql</groupId>
+			<artifactId>postgresql</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.testcontainers</groupId>
+			<artifactId>postgresql</artifactId>
+			<version>1.19.0</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>io.hypersistence</groupId>
+			<artifactId>hypersistence-utils-hibernate-55</artifactId>
+			<version>3.9.5</version>
+			<scope>test</scope>
+		</dependency>
 		<dependency>
 			<groupId>org.projectlombok</groupId>
 			<artifactId>lombok</artifactId>