Dialect implementation and support

spring-data-dialect/src/main/java/tech/ydb/data/core/convert/YdbJdbcColumnTypes.java

@@ -0,0 +1,46 @@
+package tech.ydb.data.core.convert;
+
+import java.sql.Date;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.ZonedDateTime;
+import java.time.temporal.Temporal;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.springframework.util.ClassUtils;
+
+/**
+ * @author Madiyar Nurgazin
+ */
+public enum YdbJdbcColumnTypes {
+    INSTANCE {
+
+        @SuppressWarnings({ "unchecked", "rawtypes" })
+        public Class<?> resolvePrimitiveType(Class<?> type) {
+
+            return javaToDbType.entrySet().stream() //
+                    .filter(e -> e.getKey().isAssignableFrom(type)) //
+                    .map(e -> (Class<?>) e.getValue()) //
+                    .findFirst() //
+                    .orElseGet(() -> (Class) ClassUtils.resolvePrimitiveIfNecessary(type));
+        }
+    };
+
+    private static final Map<Class<?>, Class<?>> javaToDbType = new LinkedHashMap<>();
+
+    static {
+
+        javaToDbType.put(Enum.class, String.class);
+        javaToDbType.put(ZonedDateTime.class, String.class);
+        javaToDbType.put(OffsetDateTime.class, OffsetDateTime.class);
+        javaToDbType.put(LocalDateTime.class, Time.class);
+        javaToDbType.put(LocalDate.class, Date.class);
+        javaToDbType.put(Temporal.class, Timestamp.class);
+    }
+
+    public abstract Class<?> resolvePrimitiveType(Class<?> type);
+}

spring-data-dialect/src/main/java/tech/ydb/data/core/convert/YdbMappingJdbcConverter.java

@@ -0,0 +1,73 @@
+package tech.ydb.data.core.convert;
+
+import org.springframework.data.convert.CustomConversions;
+import org.springframework.data.jdbc.core.convert.JdbcTypeFactory;
+import org.springframework.data.jdbc.core.convert.MappingJdbcConverter;
+import org.springframework.data.jdbc.core.convert.RelationResolver;
+import org.springframework.data.relational.core.mapping.RelationalMappingContext;
+import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
+import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
+import org.springframework.data.util.TypeInformation;
+import org.springframework.lang.Nullable;
+
+/**
+ * @author Madiyar Nurgazin
+ */
+public class YdbMappingJdbcConverter extends MappingJdbcConverter {
+    public YdbMappingJdbcConverter(RelationalMappingContext context, RelationResolver relationResolver,
+                                CustomConversions conversions, JdbcTypeFactory typeFactory) {
+        super(context, relationResolver, conversions, typeFactory);
+    }
+
+    @Override
+    public Class<?> getColumnType(RelationalPersistentProperty property) {
+        if (property.isAssociation()) {
+            return getReferenceColumnType(property);
+        }
+
+        if (property.isEntity()) {
+            Class<?> columnType = getEntityColumnType(property.getTypeInformation().getActualType());
+
+            if (columnType != null) {
+                return columnType;
+            }
+        }
+
+        Class<?> componentColumnType = YdbJdbcColumnTypes.INSTANCE.resolvePrimitiveType(property.getActualType());
+
+        while (componentColumnType.isArray()) {
+            componentColumnType = componentColumnType.getComponentType();
+        }
+
+        if (property.isCollectionLike() && !property.isEntity()) {
+            return java.lang.reflect.Array.newInstance(componentColumnType, 0).getClass();
+        }
+
+        return componentColumnType;
+    }
+
+    private Class<?> getReferenceColumnType(RelationalPersistentProperty property) {
+
+        Class<?> componentType = property.getTypeInformation().getRequiredComponentType().getType();
+        RelationalPersistentEntity<?> referencedEntity = getMappingContext().getRequiredPersistentEntity(componentType);
+
+        return getColumnType(referencedEntity.getRequiredIdProperty());
+    }
+
+    @Nullable
+    private Class<?> getEntityColumnType(TypeInformation<?> type) {
+
+        RelationalPersistentEntity<?> persistentEntity = getMappingContext().getPersistentEntity(type);
+
+        if (persistentEntity == null) {
+            return null;
+        }
+
+        RelationalPersistentProperty idProperty = persistentEntity.getIdProperty();
+
+        if (idProperty == null) {
+            return null;
+        }
+        return getColumnType(idProperty);
+    }
+}

spring-data-dialect/src/main/java/tech/ydb/data/repository/YdbRepository.java

@@ -0,0 +1,11 @@
+package tech.ydb.data.repository;
+
+import org.springframework.data.repository.ListCrudRepository;
+import org.springframework.data.repository.NoRepositoryBean;
+
+/**
+ * @author Madiyar Nurgazin
+ */
+@NoRepositoryBean
+public interface YdbRepository<T, ID> extends ListCrudRepository<T, ID> {
+}

spring-data-dialect/src/main/java/tech/ydb/data/repository/config/AbstractYdbJdbcConfiguration.java

@@ -0,0 +1,35 @@
+package tech.ydb.data.repository.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.data.jdbc.core.convert.DefaultJdbcTypeFactory;
+import org.springframework.data.jdbc.core.convert.JdbcArrayColumns;
+import org.springframework.data.jdbc.core.convert.JdbcConverter;
+import org.springframework.data.jdbc.core.convert.JdbcCustomConversions;
+import org.springframework.data.jdbc.core.convert.RelationResolver;
+import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
+import org.springframework.data.jdbc.repository.config.AbstractJdbcConfiguration;
+import org.springframework.data.relational.core.dialect.Dialect;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
+import tech.ydb.data.core.convert.YdbMappingJdbcConverter;
+
+/**
+ * @author Madiyar Nurgazin
+ */
+@Configuration
+public class AbstractYdbJdbcConfiguration extends AbstractJdbcConfiguration {
+    @Override
+    public JdbcConverter jdbcConverter(
+            JdbcMappingContext mappingContext,
+            NamedParameterJdbcOperations operations,
+            @Lazy RelationResolver relationResolver,
+            JdbcCustomConversions conversions,
+            Dialect dialect
+    ) {
+        DefaultJdbcTypeFactory jdbcTypeFactory = new DefaultJdbcTypeFactory(
+                operations.getJdbcOperations(), JdbcArrayColumns.Unsupported.INSTANCE
+        );
+
+        return new YdbMappingJdbcConverter(mappingContext, relationResolver, conversions, jdbcTypeFactory);
+    }
+}

spring-data-dialect/src/main/java/tech/ydb/data/repository/config/YdbDialectProvider.java

@@ -0,0 +1,39 @@
+package tech.ydb.data.repository.config;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Locale;
+import java.util.Optional;
+
+import org.springframework.data.jdbc.repository.config.DialectResolver;
+import org.springframework.data.relational.core.dialect.Dialect;
+import org.springframework.jdbc.core.ConnectionCallback;
+import org.springframework.jdbc.core.JdbcOperations;
+import org.springframework.lang.Nullable;
+import tech.ydb.data.core.dialect.YdbDialect;
+
+/**
+ * @author Madiyar Nurgazin
+ */
+public class YdbDialectProvider extends DialectResolver.DefaultDialectProvider {
+
+    @Override
+    public Optional<Dialect> getDialect(JdbcOperations operations) {
+        Optional<Dialect> ydbDialect = Optional.ofNullable(
+                operations.execute((ConnectionCallback<Dialect>) YdbDialectProvider::getDialect));
+
+        if (ydbDialect.isPresent()) {
+            return ydbDialect;
+        }
+
+        return super.getDialect(operations);
+    }
+
+    @Nullable
+    private static Dialect getDialect(Connection connection) throws SQLException {
+        if ("ydb".contains(connection.getMetaData().getDatabaseProductName().toLowerCase(Locale.ENGLISH))) {
+            return YdbDialect.INSTANCE;
+        }
+        return null;
+    }
+}

spring-data-dialect/src/main/resources/META-INF/spring.factories

@@ -0,0 +1 @@
+org.springframework.data.jdbc.repository.config.DialectResolver$JdbcDialectProvider=tech.ydb.data.repository.config.YdbDialectProvider