add: 新增easy-orm对clickhouse支持

pom.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.hswebframework</groupId>
+    <artifactId>hsweb-incubator-easyorm-clickhouse</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <hsweb.framework.version>4.0.17-SNAPSHOT</hsweb.framework.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.hswebframework.web</groupId>
+            <artifactId>hsweb-commons-crud</artifactId>
+            <version>${hsweb.framework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webflux</artifactId>
+            <version>5.3.25</version>
+        </dependency>
+    </dependencies>
+
+</project>

src/main/java/org/hswebframework/ezorm/rdb/metadata/dialect/Dialect.java

@@ -0,0 +1,69 @@
+package org.hswebframework.ezorm.rdb.metadata.dialect;
+
+import org.hswebframework.ezorm.core.meta.Feature;
+import org.hswebframework.ezorm.core.utils.StringUtils;
+import org.hswebframework.ezorm.rdb.metadata.DataType;
+import org.hswebframework.ezorm.rdb.metadata.RDBColumnMetadata;
+import org.hswebframework.ezorm.rdb.metadata.RDBFeatureType;
+import org.hswebframework.ezorm.rdb.metadata.dialect.DataTypeBuilder;
+import org.hswebframework.ezorm.rdb.supports.clickhouse.ClickhouseDialect;
+
+import java.sql.SQLType;
+import java.util.Optional;
+
+/**
+ * @author dengpengyu
+ * @date 2023/9/18 16:14
+ */
+public interface Dialect extends Feature {
+
+    @Override
+    default RDBFeatureType getType() {
+        return RDBFeatureType.dialect;
+    }
+
+    void addDataTypeBuilder(String typeId, DataTypeBuilder mapper);
+
+    String buildColumnDataType(RDBColumnMetadata columnMetaData);
+
+    String getQuoteStart();
+
+    String getQuoteEnd();
+
+    String clearQuote(String string);
+
+    boolean isColumnToUpperCase();
+
+    Optional<SQLType> convertSqlType(Class<?> type);
+
+    DataType convertDataType(String dataType);
+
+    default String quote(String keyword, boolean changeCase) {
+        if (keyword.startsWith(getQuoteStart()) && keyword.endsWith(getQuoteEnd())) {
+            return keyword;
+        }
+        return StringUtils.concat(
+                getQuoteStart(),
+                isColumnToUpperCase() && changeCase ? keyword.toUpperCase() : keyword,
+                getQuoteEnd()
+        );
+    }
+
+    default String quote(String keyword) {
+        return quote(keyword, true);
+    }
+
+    default String buildColumnFullName(String tableName, String columnName) {
+        if (columnName.contains(".")) {
+            return columnName;
+        }
+        if (StringUtils.isNullOrEmpty(tableName)) {
+            return StringUtils.concat(getQuoteStart(), isColumnToUpperCase() ? columnName.toUpperCase() : columnName, getQuoteEnd());
+        }
+        return StringUtils.concat(tableName, ".", getQuoteStart(), isColumnToUpperCase() ? columnName.toUpperCase() : columnName, getQuoteEnd());
+    }
+
+    ClickhouseDialect CLICKHOUSE = new ClickhouseDialect();
+
+}
+

src/main/java/org/hswebframework/ezorm/rdb/supports/clickhouse/ClickhouseDialect.java

@@ -0,0 +1,84 @@
+package org.hswebframework.ezorm.rdb.supports.clickhouse;
+
+import org.hswebframework.ezorm.core.utils.StringUtils;
+import org.hswebframework.ezorm.rdb.metadata.DataType;
+import org.hswebframework.ezorm.rdb.metadata.JdbcDataType;
+import org.hswebframework.ezorm.rdb.metadata.dialect.DefaultDialect;
+
+import java.sql.Date;
+import java.sql.JDBCType;
+
+/**
+ * @className ClickhouseDire
+ * @Description TODO
+ * @Author dengpengyu
+ * @Date 2023/9/4 14:53
+ * @Vesion 1.0
+ */
+public class ClickhouseDialect extends DefaultDialect {
+
+    public ClickhouseDialect() {
+        super();
+        addDataTypeBuilder(JDBCType.CHAR, (meta) -> StringUtils.concat("char(", meta.getLength(), ")"));
+        addDataTypeBuilder(JDBCType.VARCHAR, (meta) -> StringUtils.concat("varchar(", meta.getLength(), ")"));
+        addDataTypeBuilder(JDBCType.NVARCHAR, (meta) -> StringUtils.concat("nvarchar(", meta.getLength(), ")"));
+
+        addDataTypeBuilder(JDBCType.TIMESTAMP, (meta) -> "datetime(" + Math.min(6, meta.getLength()) + ")");
+        addDataTypeBuilder(JDBCType.TIME, (meta) -> "time");
+        addDataTypeBuilder(JDBCType.DATE, (meta) -> "date");
+        addDataTypeBuilder(JDBCType.CLOB, (meta) -> "text");
+        addDataTypeBuilder(JDBCType.LONGVARBINARY, (meta) -> "blob");
+        addDataTypeBuilder(JDBCType.LONGVARCHAR, (meta) -> "longtext");
+        addDataTypeBuilder(JDBCType.BLOB, (meta) -> "blob");
+        addDataTypeBuilder(JDBCType.BIGINT, (meta) -> "bigint");
+        addDataTypeBuilder(JDBCType.DOUBLE, (meta) -> "double");
+        addDataTypeBuilder(JDBCType.INTEGER, (meta) -> "int");
+        addDataTypeBuilder(JDBCType.NUMERIC, (meta) -> StringUtils.concat("decimal(", meta.getPrecision(32), ",", meta.getScale(), ")"));
+        addDataTypeBuilder(JDBCType.DECIMAL, (meta) -> StringUtils.concat("decimal(", meta.getPrecision(32), ",", meta.getScale(), ")"));
+        addDataTypeBuilder(JDBCType.TINYINT, (meta) -> "tinyint");
+        addDataTypeBuilder(JDBCType.BOOLEAN, (meta) -> "tinyint");
+        addDataTypeBuilder(JDBCType.BIGINT, (meta) -> "bigint");
+        addDataTypeBuilder(JDBCType.OTHER, (meta) -> "other");
+        addDataTypeBuilder(JDBCType.LONGNVARCHAR, (meta) -> "text");
+
+        addDataTypeBuilder("int", (meta) -> "int");
+        addDataTypeBuilder("json", meta -> "json");
+
+        registerDataType("clob", DataType.builder(JdbcDataType.of(JDBCType.CLOB, String.class), c -> "text"));
+        registerDataType("longnvarchar", DataType.builder(JdbcDataType.of(JDBCType.LONGNVARCHAR, String.class), c -> "longtext"));
+        registerDataType("longvarchar", DataType.builder(JdbcDataType.of(JDBCType.LONGVARCHAR, String.class), c -> "longtext"));
+
+        registerDataType("int", JdbcDataType.of(JDBCType.INTEGER, Integer.class));
+        registerDataType("text", JdbcDataType.of(JDBCType.CLOB, String.class));
+        registerDataType("longtext", JdbcDataType.of(JDBCType.LONGVARCHAR, String.class));
+        registerDataType("year", JdbcDataType.of(JDBCType.DATE, Date.class));
+        registerDataType("text", JdbcDataType.of(JDBCType.CLOB, Date.class));
+        registerDataType("datetime", JdbcDataType.of(JDBCType.TIMESTAMP, Date.class));
+
+    }
+
+    @Override
+    public String getQuoteStart() {
+        return "`";
+    }
+
+    @Override
+    public String getQuoteEnd() {
+        return "`";
+    }
+
+    @Override
+    public boolean isColumnToUpperCase() {
+        return false;
+    }
+
+    @Override
+    public String getId() {
+        return "clickhouse";
+    }
+
+    @Override
+    public String getName() {
+        return "Clickhouse";
+    }
+}

src/main/java/org/hswebframework/ezorm/rdb/supports/clickhouse/ClickhouseRestfulSqlExecutor.java

@@ -0,0 +1,140 @@
+package org.hswebframework.ezorm.rdb.supports.clickhouse;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import org.hswebframework.ezorm.rdb.executor.BatchSqlRequest;
+import org.hswebframework.ezorm.rdb.executor.DefaultColumnWrapperContext;
+import org.hswebframework.ezorm.rdb.executor.SqlRequest;
+import org.hswebframework.ezorm.rdb.executor.reactive.ReactiveSqlExecutor;
+import org.hswebframework.ezorm.rdb.executor.wrapper.ResultWrapper;
+import org.reactivestreams.Publisher;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.util.CollectionUtils;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @className ClickhouseRestfulSqlExecutor
+ * @Description TODO
+ * @Author dengpengyu
+ * @Date 2023/9/4 14:40
+ * @Vesion 1.0
+ */
+public class ClickhouseRestfulSqlExecutor implements ReactiveSqlExecutor {
+    private Logger log = LoggerFactory.getLogger(ClickhouseRestfulSqlExecutor.class);
+    private WebClient client;
+
+    public ClickhouseRestfulSqlExecutor(WebClient client) {
+        this.client = client;
+    }
+
+    @Override
+    public Mono<Integer> update(Publisher<SqlRequest> request) {
+        return this
+                .doExecute(request)
+                .then(Mono.just(1));
+    }
+
+    @Override
+    public Mono<Void> execute(Publisher<SqlRequest> request) {
+        return this
+                .doExecute(request)
+                .then();
+    }
+
+    @Override
+    public <E> Flux<E> select(Publisher<SqlRequest> request, ResultWrapper<E, ?> wrapper) {
+
+        return this
+                .doExecute(request)
+                .flatMap(response -> convertQueryResult(response, wrapper));
+    }
+
+    private Flux<JSONObject> doExecute(Publisher<SqlRequest> requests) {
+        return Flux
+                .from(requests)
+                .expand(request -> {
+                    if (request instanceof BatchSqlRequest) {
+                        return Flux.fromIterable(((BatchSqlRequest) request).getBatch());
+                    }
+                    return Flux.empty();
+                })
+
+                .filter(SqlRequest::isNotEmpty)
+                .concatMap(request -> {
+                    String sql;
+                    if (request.toNativeSql().toUpperCase().startsWith("INSERT")
+                            || request.toNativeSql().toUpperCase().startsWith("ALTER")) {
+                        sql = request.toNativeSql();
+                    } else {
+                        sql = request.toNativeSql() + " FORMAT JSON";
+                    }
+                    log.info("Execute ==> {}", sql);
+                    return client
+                            .post()
+                            .bodyValue(sql)
+                            .exchangeToMono(response -> response
+                                    .bodyToMono(String.class)
+                                    .map(json -> {
+                                        checkExecuteResult(sql, json);
+                                        JSONObject result = JSON.parseObject(json);
+
+                                        return result;
+                                    }));
+                });
+    }
+
+    private void checkExecuteResult(String sql, String code) {
+        if (code.startsWith("Code")) {
+            throw new RuntimeException(code);
+        }
+    }
+
+    protected <E> Flux<E> convertQueryResult(JSONObject result, ResultWrapper<E, ?> wrapper) {
+
+        JSONArray head = result.getJSONArray("meta");
+        JSONArray data = result.getJSONArray("data");
+
+        if (CollectionUtils.isEmpty(head) || CollectionUtils.isEmpty(data)) {
+            return Flux.empty();
+        }
+        List<String> columns = head.stream()
+                .map(v -> ((JSONObject) v).get("name").toString())
+                .collect(Collectors.toList());
+
+        return Flux.create(sink -> {
+            wrapper.beforeWrap(() -> columns);
+
+            for (Object rowo : data) {
+                E rowInstance = wrapper.newRowInstance();
+                JSONObject row = (JSONObject) rowo;
+                for (int i = 0; i < columns.size(); i++) {
+                    String property = columns.get(i);
+                    Object value = row.get(property);
+                    if ("total".equals(property)) {
+                        value = Long.valueOf(row.get(property).toString());
+                    } else {
+                        value = row.get(property);
+                    }
+                    DefaultColumnWrapperContext<E> context = new DefaultColumnWrapperContext<>(i, property, value, rowInstance);
+                    wrapper.wrapColumn(context);
+                    rowInstance = context.getRowInstance();
+                }
+                if (!wrapper.completedWrapRow(rowInstance)) {
+                    break;
+                }
+                if (rowInstance != null) {
+                    sink.next(rowInstance);
+                }
+            }
+            wrapper.completedWrap();
+            sink.complete();
+        });
+    }
+}

src/main/java/org/hswebframework/ezorm/rdb/supports/clickhouse/ClickhouseSchemaMetadata.java

@@ -0,0 +1,53 @@
+package org.hswebframework.ezorm.rdb.supports.clickhouse;
+
+import org.hswebframework.ezorm.rdb.codec.EnumValueCodec;
+import org.hswebframework.ezorm.rdb.metadata.RDBSchemaMetadata;
+import org.hswebframework.ezorm.rdb.metadata.RDBTableMetadata;
+import org.hswebframework.ezorm.rdb.operator.CompositeExceptionTranslation;
+
+import org.hswebframework.ezorm.rdb.supports.clickhouse.sqlBuilder.ClickhouseDeleteSqlBuilder;
+import org.hswebframework.ezorm.rdb.supports.clickhouse.sqlBuilder.ClickhouseUpdateSqlBuilder;
+import org.hswebframework.ezorm.rdb.supports.mysql.*;
+import org.hswebframework.ezorm.rdb.utils.FeatureUtils;
+
+/**
+ * @className ClickhouseSchemaMetadata
+ * @Description TODO
+ * @Author dengpengyu
+ * @Date 2023/9/5 9:36
+ * @Vesion 1.0
+ */
+public class ClickhouseSchemaMetadata extends RDBSchemaMetadata {
+    public ClickhouseSchemaMetadata(String name) {
+        super(name);
+        addFeature(new MysqlPaginator());
+        // TODO 后续增加建表
+        //读取表元数据
+        addFeature(new ClickhouseTableMetadataParser(this));
+        addFeature(new ClickhouseDialect());
+        addFeature(new CompositeExceptionTranslation()
+                .add(FeatureUtils.r2dbcIsAlive(), () -> MysqlR2DBCExceptionTranslation.of(this))
+                .add(MysqlJDBCExceptionTranslation.of(this))
+        );
+    }
+
+    @Override
+    public RDBTableMetadata newTable(String name) {
+        RDBTableMetadata metadata = super.newTable(name);
+        metadata.addFeature(ClickhouseUpdateSqlBuilder.of(metadata));
+        metadata.addFeature(ClickhouseDeleteSqlBuilder.of(metadata));
+        metadata.setOnColumnAdded(column -> {
+            if (column.getValueCodec() instanceof EnumValueCodec && ((EnumValueCodec) column.getValueCodec()).isToMask()) {
+                column.addFeature(MysqlEnumInFragmentBuilder.in);
+                column.addFeature(MysqlEnumInFragmentBuilder.notIn);
+            }
+        });
+        return metadata;
+    }
+
+    @Override
+    public void addTable(RDBTableMetadata metadata) {
+        metadata.addFeature(new MysqlBatchUpsertOperator(metadata));
+        super.addTable(metadata);
+    }
+}