feat: support automatic database and retention policy creation (openGemini#144)

Signed-off-by: weiping-code <[email protected]>

Author: weiping-code

opengemini-client-common/src/main/java/io/opengemini/client/common/ResultMapper.java

@@ -18,22 +18,25 @@
 
 import io.opengemini.client.api.QueryResult;
 import io.opengemini.client.api.RetentionPolicy;
+import io.opengemini.client.api.Series;
+import io.opengemini.client.api.SeriesResult;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 public class ResultMapper {
 
     public static List<String> toDatabases(QueryResult result) {
-        return result.getResults()
-                .get(0)
-                .getSeries()
-                .get(0)
-                .getValues()
-                .stream()
-                .map(x -> String.valueOf(x.get(0)))
-                .collect(Collectors.toList());
+        return Optional.ofNullable(result.getResults())
+                .map(list -> list.get(0))
+                .map(SeriesResult::getSeries)
+                .map(list -> list.get(0))
+                .map(Series::getValues)
+                .map(list -> list.stream().map(x -> String.valueOf(x.get(0))).collect(Collectors.toList()))
+                .orElse(Collections.emptyList());
     }
 
     public static List<RetentionPolicy> toRetentionPolicies(QueryResult result) {

spring/opengemini-spring-boot-starter/src/main/java/io/opengemini/client/spring/data/config/OpenGeminiAutoConfiguration.java

@@ -21,6 +21,8 @@
 import io.opengemini.client.impl.OpenGeminiClientFactory;
 import io.opengemini.client.spring.data.core.ClientConfigurationBuilderCustomizer;
 import io.opengemini.client.spring.data.core.DefaultOpenGeminiSerializerFactory;
+import io.opengemini.client.spring.data.core.MeasurementScanConfigurer;
+import io.opengemini.client.spring.data.core.MeasurementScanInitializer;
 import io.opengemini.client.spring.data.core.OpenGeminiProperties;
 import io.opengemini.client.spring.data.core.OpenGeminiPropertiesConverter;
 import io.opengemini.client.spring.data.core.OpenGeminiSerializerFactory;
@@ -31,6 +33,7 @@
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
+import org.springframework.lang.Nullable;
 
 @AutoConfiguration
 @ConditionalOnClass(OpenGeminiTemplate.class)
@@ -59,4 +62,10 @@ public OpenGeminiSerializerFactory openGeminiSerializerFactory() {
         return new DefaultOpenGeminiSerializerFactory();
     }
 
+    @Bean
+    public MeasurementScanInitializer measurementScanInitializer(OpenGeminiTemplate openGeminiTemplate,
+                                                                 @Nullable MeasurementScanConfigurer configurer) {
+        return new MeasurementScanInitializer(openGeminiTemplate, configurer);
+    }
+
 }

spring/opengemini-spring-boot-starter/src/test/java/io/opengemini/client/spring/data/config/OpenGeminiTemplateTest.java

@@ -22,6 +22,7 @@
 import io.opengemini.client.spring.data.core.MeasurementOperations;
 import io.opengemini.client.spring.data.core.OpenGeminiTemplate;
 import io.opengemini.client.spring.data.sample.TestApplication;
+import io.opengemini.client.spring.data.sample.measurement.WeatherFixNameAutoCreate;
 import io.opengemini.client.spring.data.sample.measurement.WeatherFixNameNoCreate;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -74,4 +75,35 @@ public void write_with_measurement_operations() throws Exception {
         Assertions.assertEquals(weatherForWrite.getTime(), weather1.getTime());
     }
 
+    @Test
+    void database_should_auto_created() throws Exception {
+        String databaseName = "weather_db_auto_create";
+        String rpName = "weather_rp_auto_create";
+
+        Assertions.assertTrue(openGeminiTemplate.isDatabaseExists(databaseName));
+        Assertions.assertTrue(openGeminiTemplate.isRetentionPolicyExists(databaseName, rpName));
+
+        MeasurementOperations<WeatherFixNameAutoCreate> measurementOperations = openGeminiTemplate.opsForMeasurement(
+                WeatherFixNameAutoCreate.class);
+        WeatherFixNameAutoCreate weatherForWrite = new WeatherFixNameAutoCreate();
+        weatherForWrite.setLocation("shenzhen");
+        weatherForWrite.setTemperature(28.5D);
+        weatherForWrite.setTime(System.currentTimeMillis());
+        measurementOperations.write(weatherForWrite);
+
+        Thread.sleep(5000);
+
+        String measurementName = "weather_ms";
+        Query selectQuery = new Query("select * from " + measurementName, databaseName, rpName);
+        List<WeatherFixNameAutoCreate> weatherList = measurementOperations.query(selectQuery);
+
+        openGeminiTemplate.dropRetentionPolicy(databaseName, rpName);
+        openGeminiTemplate.dropDatabase(databaseName);
+
+        Assertions.assertEquals(weatherList.size(), 1);
+        WeatherFixNameAutoCreate weather1 = weatherList.get(0);
+        Assertions.assertEquals(weatherForWrite.getLocation(), weather1.getLocation());
+        Assertions.assertEquals(weatherForWrite.getTemperature(), weather1.getTemperature());
+        Assertions.assertEquals(weatherForWrite.getTime(), weather1.getTime());
+    }
 }

spring/opengemini-spring-boot-starter/src/test/java/io/opengemini/client/spring/data/sample/TestApplication.java

@@ -16,10 +16,12 @@
 
 package io.opengemini.client.spring.data.sample;
 
+import io.opengemini.client.spring.data.annotation.MeasurementScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication
+@MeasurementScan("io.opengemini.client.spring.data.sample.measurement")
 public class TestApplication {
 
     public static void main(String[] args) {

spring/opengemini-spring-boot-starter/src/test/java/io/opengemini/client/spring/data/sample/measurement/WeatherFixNameAutoCreate.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2024 openGemini Authors
+ *
+ * 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 io.opengemini.client.spring.data.sample.measurement;
+
+import io.opengemini.client.api.Precision;
+import io.opengemini.client.spring.data.annotation.Database;
+import io.opengemini.client.spring.data.annotation.Field;
+import io.opengemini.client.spring.data.annotation.Measurement;
+import io.opengemini.client.spring.data.annotation.RetentionPolicy;
+import io.opengemini.client.spring.data.annotation.Tag;
+import io.opengemini.client.spring.data.annotation.Time;
+import lombok.Getter;
+import lombok.Setter;
+
+@Database(name = "weather_db_auto_create")
+@RetentionPolicy(name = "weather_rp_auto_create", duration = "3d", shardGroupDuration = "1h", indexDuration = "7h")
+@Measurement(name = "weather_ms")
+@Getter
+@Setter
+public class WeatherFixNameAutoCreate {
+
+    @Tag(name = "Location")
+    private String location;
+
+    @Field(name = "Temperature")
+    private Double temperature;
+
+    @Time(precision = Precision.PRECISIONMILLISECOND)
+    private Long time;
+
+}

spring/opengemini-spring/src/main/java/io/opengemini/client/spring/data/annotation/MeasurementScan.java

@@ -16,6 +16,8 @@
 
 package io.opengemini.client.spring.data.annotation;
 
+import io.opengemini.client.spring.data.core.MeasurementScanRegistrar;
+import org.springframework.context.annotation.Import;
 import org.springframework.core.annotation.AliasFor;
 
 import java.lang.annotation.ElementType;
@@ -25,6 +27,7 @@
 
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
+@Import(MeasurementScanRegistrar.class)
 public @interface MeasurementScan {
 
     /**

spring/opengemini-spring/src/main/java/io/opengemini/client/spring/data/core/MeasurementScanConfigurer.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 openGemini Authors
+ *
+ * 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 io.opengemini.client.spring.data.core;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.util.Assert;
+
+import java.util.List;
+
+@Setter
+@Getter
+public class MeasurementScanConfigurer implements InitializingBean {
+
+    private List<String> basePackages;
+
+    @Override
+    public void afterPropertiesSet() {
+        Assert.notEmpty(basePackages, "Property 'basePackage' is required");
+    }
+}

spring/opengemini-spring/src/main/java/io/opengemini/client/spring/data/core/MeasurementScanInitializer.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2024 openGemini Authors
+ *
+ * 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 io.opengemini.client.spring.data.core;
+
+import io.opengemini.client.api.RpConfig;
+import io.opengemini.client.spring.data.annotation.Database;
+import io.opengemini.client.spring.data.annotation.Measurement;
+import io.opengemini.client.spring.data.annotation.RetentionPolicy;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
+import org.springframework.core.type.filter.AnnotationTypeFilter;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.StringUtils;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class MeasurementScanInitializer implements InitializingBean {
+
+    private final OpenGeminiTemplate openGeminiTemplate;
+    private final MeasurementScanConfigurer measurementScanConfigurer;
+
+    public MeasurementScanInitializer(OpenGeminiTemplate openGeminiTemplate, MeasurementScanConfigurer configurer) {
+        this.openGeminiTemplate = openGeminiTemplate;
+        this.measurementScanConfigurer = configurer;
+    }
+
+    @Override
+    public void afterPropertiesSet() {
+        Set<Class<?>> measurementClassSet = new HashSet<>();
+        if (measurementScanConfigurer != null) {
+            for (String basePackage : measurementScanConfigurer.getBasePackages()) {
+                scanForMeasurementClass(basePackage, measurementClassSet);
+            }
+        }
+        initDatabase(measurementClassSet);
+    }
+
+    private void scanForMeasurementClass(String basePackage, Set<Class<?>> measurementClassSet) {
+        if (!StringUtils.hasText(basePackage)) {
+            return;
+        }
+
+        ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
+        provider.addIncludeFilter(new AnnotationTypeFilter(Measurement.class));
+        ClassLoader classLoader = this.getClass().getClassLoader();
+        for (BeanDefinition candidate : provider.findCandidateComponents(basePackage)) {
+            String beanClassName = candidate.getBeanClassName();
+            if (beanClassName != null) {
+                try {
+                    measurementClassSet.add(ClassUtils.forName(beanClassName, classLoader));
+                } catch (ClassNotFoundException | LinkageError ignored) {
+                }
+            }
+        }
+    }
+
+    private void initDatabase(Set<Class<?>> measurementClassSet) {
+        for (Class<?> clazz : measurementClassSet) {
+            Database dbAnnotation = clazz.getAnnotation(Database.class);
+            if (dbAnnotation == null || !dbAnnotation.create()) {
+                continue;
+            }
+            String database = dbAnnotation.name();
+            openGeminiTemplate.createDatabaseIfAbsent(database);
+
+            RetentionPolicy rpAnnotation = clazz.getAnnotation(RetentionPolicy.class);
+            if (rpAnnotation == null || !rpAnnotation.create()) {
+                continue;
+            }
+
+            RpConfig rpConfig = new RpConfig(rpAnnotation.name(), rpAnnotation.duration(),
+                    rpAnnotation.shardGroupDuration(), rpAnnotation.indexDuration());
+            openGeminiTemplate.createRetentionPolicyIfAbsent(database, rpConfig, rpAnnotation.isDefault());
+        }
+    }
+
+}

spring/opengemini-spring/src/main/java/io/opengemini/client/spring/data/core/MeasurementScanRegistrar.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2024 openGemini Authors
+ *
+ * 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 io.opengemini.client.spring.data.core;
+
+import io.opengemini.client.spring.data.annotation.MeasurementScan;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
+import org.springframework.core.annotation.AnnotationAttributes;
+import org.springframework.core.type.AnnotationMetadata;
+import org.springframework.util.StringUtils;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class MeasurementScanRegistrar implements ImportBeanDefinitionRegistrar {
+
+    @Override
+    public void registerBeanDefinitions(@NotNull AnnotationMetadata importingClassMetadata,
+                                        @NotNull BeanDefinitionRegistry registry) {
+        AnnotationAttributes mapperScanAttrs = AnnotationAttributes.fromMap(
+                importingClassMetadata.getAnnotationAttributes(MeasurementScan.class.getName()));
+        if (mapperScanAttrs != null) {
+            String beanName = generateBaseBeanName(importingClassMetadata);
+            registerBeanDefinitions(mapperScanAttrs, registry, beanName);
+        }
+    }
+
+    private String generateBaseBeanName(AnnotationMetadata importingClassMetadata) {
+        return importingClassMetadata.getClassName() + "#" + MeasurementScanRegistrar.class.getSimpleName();
+    }
+
+    private void registerBeanDefinitions(AnnotationAttributes annoAttrs,
+                                         BeanDefinitionRegistry registry,
+                                         String beanName) {
+        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MeasurementScanConfigurer.class);
+
+        List<String> basePackages = Arrays.stream(annoAttrs.getStringArray("basePackages"))
+                .filter(StringUtils::hasText)
+                .collect(Collectors.toList());
+        builder.addPropertyValue("basePackages", basePackages);
+
+        registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
+    }
+
+}