change

tests/examples/JDBC/taosdemo/pom.xml

@@ -19,6 +19,33 @@
     </properties>
 
     <dependencies>
+
+        <!-- taos jdbc -->
+        <dependency>
+            <groupId>com.taosdata.jdbc</groupId>
+            <artifactId>taos-jdbcdriver</artifactId>
+            <version>2.0.14</version>
+        </dependency>
+        <!-- mysql -->
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>5.1.47</version>
+        </dependency>
+        <!-- mybatis-plus -->
+        <dependency>
+            <groupId>com.baomidou</groupId>
+            <artifactId>mybatis-plus-boot-starter</artifactId>
+            <version>3.1.2</version>
+        </dependency>
+        <!-- log4j -->
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>1.2.17</version>
+        </dependency>
+
+        <!-- springboot -->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-jdbc</artifactId>
@@ -36,7 +63,12 @@
             <artifactId>mybatis-spring-boot-starter</artifactId>
             <version>2.1.4</version>
         </dependency>
-
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-devtools</artifactId>
@@ -56,6 +88,24 @@
     </dependencies>
 
     <build>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <includes>
+                    <include>**/*.properties</include>
+                    <include>**/*.xml</include>
+                </includes>
+                <filtering>true</filtering>
+            </resource>
+            <resource>
+                <directory>src/main/java</directory>
+                <includes>
+                    <include>**/*.properties</include>
+                    <include>**/*.xml</include>
+                </includes>
+            </resource>
+        </resources>
+
         <plugins>
             <plugin>
                 <groupId>org.springframework.boot</groupId>

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosdemoApplication.java

 package com.taosdata.taosdemo;
 
+import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
+@MapperScan(basePackages = {"com.taosdata.taosdemo.mapper"})
 @SpringBootApplication
 public class TaosdemoApplication {
 

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/components/TaosDemoCommandLineRunner.java

+package com.taosdata.taosdemo.components;
+
+import com.taosdata.taosdemo.domain.*;
+import com.taosdata.taosdemo.service.DatabaseService;
+import com.taosdata.taosdemo.service.SubTableService;
+import com.taosdata.taosdemo.service.SuperTableService;
+import com.taosdata.taosdemo.service.data.SubTableMetaGenerator;
+import com.taosdata.taosdemo.service.data.SubTableValueGenerator;
+import com.taosdata.taosdemo.service.data.SuperTableMetaGenerator;
+import com.taosdata.taosdemo.utils.JdbcTaosdemoConfig;
+import org.apache.log4j.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+
+@Component
+public class TaosDemoCommandLineRunner implements CommandLineRunner {
+
+    private static Logger logger = Logger.getLogger(TaosDemoCommandLineRunner.class);
+    @Autowired
+    private DatabaseService databaseService;
+    @Autowired
+    private SuperTableService superTableService;
+    @Autowired
+    private SubTableService subTableService;
+
+    private SuperTableMeta superTableMeta;
+    private List<SubTableMeta> subTableMetaList;
+    private List<SubTableValue> subTableValueList;
+    private List<List<SubTableValue>> dataList;
+
+
+    @Override
+    public void run(String... args) throws Exception {
+        // 读配置参数
+        JdbcTaosdemoConfig config = new JdbcTaosdemoConfig(args);
+        boolean isHelp = Arrays.asList(args).contains("--help");
+        if (isHelp) {
+            JdbcTaosdemoConfig.printHelp();
+        }
+        // 准备数据
+        prepareData(config);
+
+        // 创建数据库
+        Map<String, String> databaseParam = new HashMap<>();
+        databaseParam.put("database", config.database);
+        databaseParam.put("keep", Integer.toString(config.keep));
+        databaseParam.put("days", Integer.toString(config.days));
+        databaseParam.put("replica", Integer.toString(config.replica));
+        //TODO: other database parameters
+        databaseService.dropDatabase(config.database);
+        databaseService.createDatabase(databaseParam);
+        databaseService.useDatabase(config.database);
+
+        // 建表
+        // 建超级表，三种方式：1. 指定SQL，2. 指定field和tags的个数，3. 默认
+        if (config.doCreateTable) {
+            superTableService.create(superTableMeta);
+            // 批量建子表
+            subTableService.createSubTable(subTableMetaList, config.numOfThreadsForCreate);
+        }
+
+        // 插入
+        int numOfThreadsForInsert = 1;
+        int sleep = 0;
+        if (config.autoCreateTable) {
+            // 批量插入，自动建表
+            dataList.stream().forEach(subTableValues -> {
+                subTableService.insertAutoCreateTable(subTableValues, numOfThreadsForInsert);
+                sleep(sleep);
+            });
+        } else {
+            dataList.stream().forEach(subTableValues -> {
+                subTableService.insert(subTableValues, numOfThreadsForInsert);
+                sleep(sleep);
+            });
+        }
+        // 批量插入,不使用自动建表
+
+        // 查询
+        // 1. 生成查询语句
+        // 2. 执行查询
+
+        // 删除表
+        if (config.dropTable) {
+            superTableService.drop(config.database, config.superTable);
+        }
+
+        System.exit(0);
+    }
+
+    private void prepareData(JdbcTaosdemoConfig config) {
+        // 超级表的meta
+        superTableMeta = createSupertable(config);
+        // 子表的meta
+        subTableMetaList = SubTableMetaGenerator.generate(superTableMeta, config.numOfTables, config.tablePrefix);
+        // 子表的data
+        subTableValueList = SubTableValueGenerator.generate(subTableMetaList, config.numOfRowsPerTable, config.startTime, config.timeGap);
+        // 如果有乱序，给数据搞乱
+        if (config.order != 0) {
+            SubTableValueGenerator.disrupt(subTableValueList, config.rate, config.range);
+        }
+        // 分割数据
+        int numOfTables = config.numOfTables;
+        int numOfTablesPerSQL = config.numOfTablesPerSQL;
+        int numOfRowsPerTable = config.numOfRowsPerTable;
+        int numOfValuesPerSQL = config.numOfValuesPerSQL;
+        dataList = SubTableValueGenerator.split(subTableValueList, numOfTables, numOfTablesPerSQL, numOfRowsPerTable, numOfValuesPerSQL);
+    }
+
+    private SuperTableMeta createSupertable(JdbcTaosdemoConfig config) {
+        SuperTableMeta tableMeta;
+        // create super table
+        logger.info(">>> create super table <<<");
+        if (config.superTableSQL != null) {
+            // use a sql to create super table
+            tableMeta = SuperTableMetaGenerator.generate(config.superTableSQL);
+        } else if (config.numOfFields == 0) {
+            // default sql = "create table test.weather (ts timestamp, temperature float, humidity int) tags(location nchar(64), groupId int)";
+            SuperTableMeta superTableMeta = new SuperTableMeta();
+            superTableMeta.setDatabase(config.database);
+            superTableMeta.setName(config.superTable);
+            List<FieldMeta> fields = new ArrayList<>();
+            fields.add(new FieldMeta("ts", "timestamp"));
+            fields.add(new FieldMeta("temperature", "float"));
+            fields.add(new FieldMeta("humidity", "int"));
+            superTableMeta.setFields(fields);
+            List<TagMeta> tags = new ArrayList<>();
+            tags.add(new TagMeta("location", "nchar(64)"));
+            tags.add(new TagMeta("groupId", "int"));
+            superTableMeta.setTags(tags);
+            return superTableMeta;
+        } else {
+            // create super table with specified field size and tag size
+            tableMeta = SuperTableMetaGenerator.generate(config.database, config.superTable, config.numOfFields, config.prefixOfFields, config.numOfTags, config.prefixOfTags);
+        }
+        return tableMeta;
+    }
+
+    private static void sleep(int sleep) {
+        if (sleep <= 0)
+            return;
+        try {
+            TimeUnit.MILLISECONDS.sleep(sleep);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/DatabaseController.java

+package com.taosdata.taosdemo.controller;
+
+import com.taosdata.taosdemo.service.DatabaseService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping
+public class DatabaseController {
+
+    @Autowired
+    private DatabaseService databaseService;
+
+    /**
+     * create database
+     ***/
+    @PostMapping
+    public int create(@RequestBody Map<String, String> map) {
+        return databaseService.createDatabase(map);
+    }
+
+
+    /**
+     * drop database
+     **/
+    @DeleteMapping("/{dbname}")
+    public int delete(@PathVariable("dbname") String dbname) {
+        return databaseService.dropDatabase(dbname);
+    }
+
+    /**
+     * use database
+     **/
+    @GetMapping("/{dbname}")
+    public int use(@PathVariable("dbname") String dbname) {
+        return databaseService.useDatabase(dbname);
+    }
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/InsertController.java

+package com.taosdata.taosdemo.controller;
+
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class InsertController {
+
+    //TODO：多线程写一张表, thread = 10, table = 1
+    //TODO：一个批次写多张表, insert into t1 using weather values() t2 using weather values()
+    //TODO：插入的频率，
+    //TODO：指定一张表内的records数量
+    //TODO：是否乱序，
+    //TODO：乱序的比例，乱序的范围
+    //TODO：先建表，自动建表
+    //TODO：一个批次写多张表
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/SubTableController.java

+package com.taosdata.taosdemo.controller;
+
+import com.taosdata.taosdemo.domain.TableValue;
+import com.taosdata.taosdemo.service.SuperTableService;
+import com.taosdata.taosdemo.service.TableService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class SubTableController {
+
+    @Autowired
+    private TableService tableService;
+    @Autowired
+    private SuperTableService superTableService;
+
+    //TODO: 使用supertable创建一个子表
+
+    //TODO：使用supertable创建多个子表
+
+    //TODO：使用supertable多线程创建子表
+
+    //TODO：使用supertable多线程创建子表，指定子表的name_prefix，子表的数量，使用线程的个数
+
+    /**
+     * 创建表，超级表或者普通表
+     **/
+
+
+    /**
+     * 创建超级表的子表
+     **/
+    @PostMapping("/{database}/{superTable}")
+    public int createTable(@PathVariable("database") String database,
+                           @PathVariable("superTable") String superTable,
+                           @RequestBody TableValue tableMetadta) {
+        tableMetadta.setDatabase(database);
+        return 0;
+    }
+
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/SuperTableController.java

+package com.taosdata.taosdemo.controller;
+
+import com.taosdata.taosdemo.domain.SuperTableMeta;
+import com.taosdata.taosdemo.service.SuperTableService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+
+public class SuperTableController {
+    @Autowired
+    private SuperTableService superTableService;
+
+
+    @PostMapping("/{database}")
+    public int createTable(@PathVariable("database") String database, @RequestBody SuperTableMeta tableMetadta) {
+        tableMetadta.setDatabase(database);
+        return superTableService.create(tableMetadta);
+    }
+
+    //TODO: 删除超级表
+
+    //TODO：查询超级表
+
+    //TODO：统计查询表
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/controller/TableController.java

+package com.taosdata.taosdemo.controller;
+
+public class TableController {
+
+    //TODO：创建普通表，create table(ts timestamp, temperature float)
+
+    //TODO：创建普通表，指定表的列数，包括第一列timestamp
+
+    //TODO：创建普通表，指定表每列的name和type
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/FieldMeta.java

+package com.taosdata.taosdemo.domain;
+
+import lombok.Data;
+
+@Data
+public class FieldMeta {
+    private String name;
+    private String type;
+
+    public FieldMeta() {
+    }
+
+    public FieldMeta(String name, String type) {
+        this.name = name;
+        this.type = type;
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/FieldValue.java

+package com.taosdata.taosdemo.domain;
+
+import lombok.Data;
+
+@Data
+public class FieldValue<T> {
+    private String name;
+    private T value;
+
+    public FieldValue() {
+    }
+
+    public FieldValue(String name, T value) {
+        this.name = name;
+        this.value = value;
+    }
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/RowValue.java

+package com.taosdata.taosdemo.domain;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class RowValue {
+    private List<FieldValue> fields;
+
+
+    public RowValue(List<FieldValue> fields) {
+        this.fields = fields;
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/SubTableMeta.java

+package com.taosdata.taosdemo.domain;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class SubTableMeta {
+
+    private String database;
+    private String supertable;
+    private String name;
+    private List<TagValue> tags;
+    private List<FieldMeta> fields;
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/SubTableValue.java

+package com.taosdata.taosdemo.domain;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class SubTableValue {
+
+    private String database;
+    private String supertable;
+    private String name;
+    private List<TagValue> tags;
+    private List<RowValue> values;
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/SuperTableMeta.java

+package com.taosdata.taosdemo.domain;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class SuperTableMeta {
+
+    private String database;
+    private String name;
+    private List<FieldMeta> fields;
+    private List<TagMeta> tags;
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TableMeta.java

+package com.taosdata.taosdemo.domain;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class TableMeta {
+
+    private String database;
+    private String name;
+    private List<FieldMeta> fields;
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TableValue.java

+package com.taosdata.taosdemo.domain;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class TableValue {
+
+    private String database;
+    private String name;
+    private List<FieldMeta> columns;
+    private List<RowValue> values;
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TagMeta.java

+package com.taosdata.taosdemo.domain;
+
+import lombok.Data;
+
+@Data
+public class TagMeta {
+    private String name;
+    private String type;
+
+    public TagMeta() {
+
+    }
+
+    public TagMeta(String name, String type) {
+        this.name = name;
+        this.type = type;
+    }
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/domain/TagValue.java

+package com.taosdata.taosdemo.domain;
+
+import lombok.Data;
+
+@Data
+public class TagValue<T> {
+    private String name;
+    private T value;
+
+    public TagValue() {
+    }
+
+    public TagValue(String name, T value) {
+        this.name = name;
+        this.value = value;
+    }
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/DatabaseMapper.java

+package com.taosdata.taosdemo.mapper;
+
+import org.apache.ibatis.annotations.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.Map;
+
+@Repository
+public interface DatabaseMapper {
+
+    // create database if not exists XXX
+    int createDatabase(@Param("dbname") String dbname);
+
+    // drop database if exists XXX
+    int dropDatabase(@Param("dbname") String dbname);
+
+    // create database if not exists XXX keep XX days XX replica XX
+    int createDatabaseWithParameters(Map<String, String> map);
+
+    // use XXX
+    int useDatabase(@Param("dbname") String dbname);
+
+    //TODO: alter database
+
+    //TODO: show database
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/DatabaseMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.taosdata.taosdemo.mapper.DatabaseMapper">
+
+    <!-- create database XXX -->
+    <update id="createDatabase" parameterType="java.lang.String">
+        create database if not exists ${dbname}
+    </update>
+
+    <update id="dropDatabase" parameterType="java.lang.String">
+        DROP database if exists ${dbname}
+    </update>
+
+    <update id="createDatabaseWithParameters" parameterType="map">
+        CREATE database if not exists ${dbname}
+        <if test="keep != null">
+            KEEP ${keep}
+        </if>
+        <if test="days != null">
+            DAYS ${days}
+        </if>
+        <if test="replica != null">
+            REPLICA ${replica}
+        </if>
+        <if test="cache != null">
+            cache ${cache}
+        </if>
+        <if test="blocks != null">
+            blocks ${blocks}
+        </if>
+        <if test="minrows != null">
+            minrows ${minrows}
+        </if>
+        <if test="maxrows != null">
+            maxrows ${maxrows}
+        </if>
+    </update>
+
+    <update id="useDatabase" parameterType="java.lang.String">
+        use ${dbname}
+    </update>
+
+    <!-- TODO: alter database -->
+
+    <!-- TODO: show database -->
+
+</mapper>
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SubTableMapper.java

+package com.taosdata.taosdemo.mapper;
+
+import com.taosdata.taosdemo.domain.SubTableMeta;
+import com.taosdata.taosdemo.domain.SubTableValue;
+import org.apache.ibatis.annotations.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface SubTableMapper {
+
+    // 创建：子表
+    int createUsingSuperTable(SubTableMeta subTableMeta);
+
+    // 插入：一张子表多个values
+    int insertOneTableMultiValues(SubTableValue subTableValue);
+
+    // 插入：一张子表多个values, 自动建表
+    int insertOneTableMultiValuesUsingSuperTable(SubTableValue subTableValue);
+
+    // 插入：多张表多个values
+    int insertMultiTableMultiValues(@Param("tables") List<SubTableValue> tables);
+
+    // 插入：多张表多个values，自动建表
+    int insertMultiTableMultiValuesUsingSuperTable(@Param("tables") List<SubTableValue> tables);
+
+    //<!-- TODO:修改子表标签值 alter table ${tablename} set tag tagName=newTagValue-->
+
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SubTableMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.taosdata.taosdemo.mapper.SubTableMapper">
+
+    <!-- 创建子表 -->
+    <update id="createUsingSuperTable">
+        CREATE table IF NOT EXISTS ${database}.${name} USING ${supertable} TAGS
+        <foreach collection="tags" item="tag" index="index" open="(" close=")" separator=",">
+            ${tag.value}
+        </foreach>
+    </update>
+
+    <!-- 插入：向一张表中插入多张表 -->
+    <insert id="insertOneTableMultiValues">
+        INSERT INTO ${database}.${name}
+        VALUES
+        <foreach collection="values" item="value">
+            <foreach collection="value.fields" item="field" open="(" close=")" separator=",">
+                ${field.value}
+            </foreach>
+        </foreach>
+    </insert>
+
+    <!-- 插入：使用自动建表模式，向一张表中插入多条数据 -->
+    <insert id="insertOneTableMultiValuesUsingSuperTable">
+        INSERT INTO ${database}.${name} USING ${supertable} TAGS
+        <foreach collection="tags" item="tag" index="index" open="(" close=")" separator=",">
+            ${tag.value}
+        </foreach>
+        VALUES
+        <foreach collection="values" item="value">
+            <foreach collection="value.fields" item="field" open="(" close=")" separator=",">
+                ${field.value}
+            </foreach>
+        </foreach>
+    </insert>
+
+    <!-- TODO:插入：向一张表中插入多张表, 指定列 -->
+
+    <!-- TODO:插入：向一张表中插入多张表, 自动建表，指定列 -->
+
+    <!-- 插入：向多张表中插入多条数据 -->
+    <insert id="insertMultiTableMultiValues">
+        INSERT INTO
+        <foreach collection="tables" item="table">
+            ${table.database}.${table.name}
+            VALUES
+            <foreach collection="table.values" item="value">
+                <foreach collection="value.fields" item="field" open="(" close=")" separator=",">
+                    ${field.value}
+                </foreach>
+            </foreach>
+        </foreach>
+    </insert>
+
+    <!-- 插入：向多张表中插入多条数据，自动建表 -->
+    <insert id="insertMultiTableMultiValuesUsingSuperTable">
+        INSERT INTO
+        <foreach collection="tables" item="table">
+            ${table.database}.${table.name} USING ${table.supertable} TAGS
+            <foreach collection="table.tags" item="tag" index="index" open="(" close=")" separator=",">
+                ${tag.value}
+            </foreach>
+            VALUES
+            <foreach collection="table.values" item="value">
+                <foreach collection="value.fields" item="field" open="(" close=")" separator=",">
+                    ${field.value}
+                </foreach>
+            </foreach>
+        </foreach>
+    </insert>
+
+    <!-- TODO:插入：向多张表中插入多张表, 指定列 -->
+
+    <!-- TODO:插入：向多张表中插入多张表, 自动建表，指定列 -->
+
+    <!-- TODO:修改子表标签值 alter table ${tablename} set tag tagName=newTagValue -->
+    <!-- TODO: -->
+
+</mapper>
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SuperTableMapper.java

+package com.taosdata.taosdemo.mapper;
+
+import com.taosdata.taosdemo.domain.SuperTableMeta;
+import org.apache.ibatis.annotations.Param;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface SuperTableMapper {
+
+    // 创建超级表，使用自己定义的SQL语句
+    int createSuperTableUsingSQL(@Param("createSuperTableSQL") String sql);
+
+    // 创建超级表 create table if not exists xxx.xxx (f1 type1, f2 type2, ... ) tags( t1 type1, t2 type2 ...)
+    int createSuperTable(SuperTableMeta tableMetadata);
+
+    // 删除超级表 drop table if exists xxx;
+    int dropSuperTable(@Param("database") String database, @Param("name") String name);
+
+    //<!-- TODO:查询所有超级表信息 show stables -->
+
+    //<!-- TODO:查询表结构 describe stable -->
+
+    //<!-- TODO:增加列 alter table ${tablename} add column fieldName dataType -->
+
+    //<!-- TODO:删除列 alter table ${tablename} drop column fieldName -->
+
+    //<!-- TODO:添加标签 alter table ${tablename} add tag new_tagName tag_type -->
+
+    //<!-- TODO:删除标签 alter table ${tablename} drop tag_name -->
+
+    //<!-- TODO:修改标签名 alter table ${tablename} change tag old_tagName new_tagName -->
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/SuperTableMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.taosdata.taosdemo.mapper.SuperTableMapper">
+
+    <update id="createSuperTableUsingSQL">
+        ${createSuperTableSQL}
+    </update>
+
+    <!-- 创建超级表 -->
+    <update id="createSuperTable">
+        create table if not exists ${database}.${name}
+        <foreach collection="fields" item="field" index="index" open="(" close=")" separator=",">
+            ${field.name} ${field.type}
+        </foreach>
+        tags
+        <foreach collection="tags" item="tag" index="index" open="(" close=")" separator=",">
+            ${tag.name} ${tag.type}
+        </foreach>
+    </update>
+
+    <!-- 删除超级表：drop super table -->
+    <delete id="dropSuperTable">
+        drop table if exists ${database}.${name}
+    </delete>
+
+    <!-- TODO:查询所有超级表信息 show stables -->
+
+    <!-- TODO:查询表结构 describe stable -->
+
+    <!-- TODO:增加列 alter table ${tablename} add column fieldName dataType -->
+
+    <!-- TODO:删除列 alter table ${tablename} drop column fieldName -->
+
+    <!-- TODO:添加标签 alter table ${tablename} add tag new_tagName tag_type -->
+
+    <!-- TODO:删除标签 alter table ${tablename} drop tag_name -->
+
+    <!-- TODO:修改标签名 alter table ${tablename} change tag old_tagName new_tagName -->
+
+</mapper>
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/TableMapper.java

+package com.taosdata.taosdemo.mapper;
+
+import com.taosdata.taosdemo.domain.TableMeta;
+import com.taosdata.taosdemo.domain.TableValue;
+import org.apache.ibatis.annotations.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface TableMapper {
+
+    // 创建：普通表
+    int create(TableMeta tableMeta);
+
+    // 插入：一张表多个value
+    int insertOneTableMultiValues(TableValue values);
+
+    // 插入: 一张表多个value，指定的列
+    int insertOneTableMultiValuesWithColumns(TableValue values);
+
+    // 插入：多个表多个value
+    int insertMultiTableMultiValues(@Param("tables") List<TableValue> tables);
+
+    // 插入：多个表多个value, 指定的列
+    int insertMultiTableMultiValuesWithColumns(@Param("tables") List<TableValue> tables);
+
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/mapper/TableMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.taosdata.taosdemo.mapper.TableMapper">
+
+    <!-- 创建普通表 -->
+    <update id="create" parameterType="com.taosdata.taosdemo.domain.TableMeta">
+        create table if not exists ${database}.${name}
+        <foreach collection="fields" item="field" index="index" open="(" close=")" separator=",">
+            ${field.name} ${field.type}
+        </foreach>
+    </update>
+
+    <!-- 插入：向一张普通表中插入多条数据 -->
+    <insert id="insertOneTableMultiValues" parameterType="com.taosdata.taosdemo.domain.TableValue">
+        insert into ${database}.${name} values
+        <foreach collection="values" item="value">
+            <foreach collection="value.fields" item="field" open="(" close=")" separator=",">
+                ${field.value}
+            </foreach>
+        </foreach>
+    </insert>
+
+    <!-- 向一张表中插入指定列的数据 insert into XXX.xx (f1,f2,f3...) values(v1,v2,v3...) -->
+    <insert id="insertOneTableMultiValuesWithColumns" parameterType="com.taosdata.taosdemo.domain.TableValue">
+        insert into ${database}.${name}
+        <foreach collection="columns" item="column" open="(" close=")" separator=",">
+            ${column.name}
+        </foreach>
+        values
+        <foreach collection="values" item="value">
+            <foreach collection="value.fields" item="field" open="(" close=")" separator=",">
+                ${field.value}
+            </foreach>
+        </foreach>
+    </insert>
+
+    <!-- 向多个表中插入多条数据 -->
+    <insert id="insertMultiTableMultiValues">
+        insert into
+        <foreach collection="tables" item="table">
+            ${table.database}.${table.name} values
+            <foreach collection="table.values" item="value">
+                <foreach collection="value.fields" item="field" open="(" close=")" separator=",">
+                    ${field.value}
+                </foreach>
+            </foreach>
+        </foreach>
+    </insert>
+
+    <!-- 向多张表中指定的列插入多条数据 -->
+    <insert id="insertMultiTableMultiValuesWithColumns">
+        insert into
+        <foreach collection="tables" item="table">
+            ${table.database}.${table.name}
+            <foreach collection="table.columns" item="column" open="(" close=")" separator=",">
+                ${column.name}
+            </foreach>
+            values
+            <foreach collection="table.values" item="value">
+                <foreach collection="value.fields" item="field" open="(" close=")" separator=",">
+                    ${field.value}
+                </foreach>
+            </foreach>
+        </foreach>
+    </insert>
+
+</mapper>
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/AbstractService.java

+package com.taosdata.taosdemo.service;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+public class AbstractService {
+
+    protected int getAffectRows(List<Future<Integer>> futureList) {
+        int count = 0;
+        for (Future<Integer> future : futureList) {
+            try {
+                count += future.get();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } catch (ExecutionException e) {
+                e.printStackTrace();
+            }
+        }
+        return count;
+    }
+
+    protected int getAffectRows(Future<Integer> future) {
+        int count = 0;
+        try {
+            count += future.get();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+        }
+        return count;
+    }
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/DatabaseService.java

+package com.taosdata.taosdemo.service;
+
+import com.taosdata.taosdemo.mapper.DatabaseMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.Map;
+
+@Service
+public class DatabaseService {
+
+    @Autowired
+    private DatabaseMapper databaseMapper;
+
+    // 建库，指定 name
+    public int createDatabase(String database) {
+        return databaseMapper.createDatabase(database);
+    }
+
+    // 建库，指定参数 keep,days,replica等
+    public int createDatabase(Map<String, String> map) {
+        if (map.isEmpty())
+            return 0;
+        if (map.containsKey("database") && map.size() == 1)
+            return databaseMapper.createDatabase(map.get("database"));
+        return databaseMapper.createDatabaseWithParameters(map);
+    }
+
+    // drop database
+    public int dropDatabase(String dbname) {
+        return databaseMapper.dropDatabase(dbname);
+    }
+
+    // use database
+    public int useDatabase(String dbname) {
+        return databaseMapper.useDatabase(dbname);
+    }
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SubTableService.java

+package com.taosdata.taosdemo.service;
+
+import com.taosdata.taosdemo.domain.SubTableMeta;
+import com.taosdata.taosdemo.domain.SubTableValue;
+import com.taosdata.taosdemo.mapper.SubTableMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+@Service
+public class SubTableService extends AbstractService {
+
+    @Autowired
+    private SubTableMapper mapper;
+
+    /**
+     * 1. 选择database，找到所有supertable
+     * 2. 选择supertable，可以拿到表结构，包括field和tag
+     * 3. 指定子表的前缀和个数
+     * 4. 指定创建子表的线程数
+     */
+    //TODO：指定database、supertable、子表前缀、子表个数、线程数
+
+    // 多线程创建表，指定线程个数
+    public int createSubTable(List<SubTableMeta> subTables, int threadSize) {
+        ExecutorService executor = Executors.newFixedThreadPool(threadSize);
+        List<Future<Integer>> futureList = new ArrayList<>();
+        for (SubTableMeta subTableMeta : subTables) {
+            Future<Integer> future = executor.submit(() -> createSubTable(subTableMeta));
+            futureList.add(future);
+        }
+        executor.shutdown();
+        return getAffectRows(futureList);
+    }
+
+
+    // 创建一张子表，可以指定database，supertable，tablename，tag值
+    public int createSubTable(SubTableMeta subTableMeta) {
+        return mapper.createUsingSuperTable(subTableMeta);
+    }
+
+    // 单线程创建多张子表，每张子表分别可以指定自己的database，supertable，tablename，tag值
+    public int createSubTable(List<SubTableMeta> subTables) {
+        return createSubTable(subTables, 1);
+    }
+
+    /*************************************************************************************************************************/
+    // 插入：多线程，多表
+    public int insert(List<SubTableValue> subTableValues, int threadSize) {
+        ExecutorService executor = Executors.newFixedThreadPool(threadSize);
+        Future<Integer> future = executor.submit(() -> insert(subTableValues));
+        executor.shutdown();
+        return getAffectRows(future);
+    }
+
+    // 插入：多线程，多表, 自动建表
+    public int insertAutoCreateTable(List<SubTableValue> subTableValues, int threadSize) {
+        ExecutorService executor = Executors.newFixedThreadPool(threadSize);
+        Future<Integer> future = executor.submit(() -> insertAutoCreateTable(subTableValues));
+        executor.shutdown();
+        return getAffectRows(future);
+    }
+
+    // 插入：单表，insert into xxx values(),()...
+    public int insert(SubTableValue subTableValue) {
+        return mapper.insertOneTableMultiValues(subTableValue);
+    }
+
+    // 插入: 多表，insert into xxx values(),()... xxx values(),()...
+    public int insert(List<SubTableValue> subTableValues) {
+        return mapper.insertMultiTableMultiValuesUsingSuperTable(subTableValues);
+    }
+
+    // 插入：单表，自动建表, insert into xxx using xxx tags(...) values(),()...
+    public int insertAutoCreateTable(SubTableValue subTableValue) {
+        return mapper.insertOneTableMultiValuesUsingSuperTable(subTableValue);
+    }
+
+    // 插入：多表，自动建表, insert into xxx using XXX tags(...) values(),()... xxx using XXX tags(...) values(),()...
+    public int insertAutoCreateTable(List<SubTableValue> subTableValues) {
+        return mapper.insertMultiTableMultiValuesUsingSuperTable(subTableValues);
+    }
+
+
+//        ExecutorService executors = Executors.newFixedThreadPool(threadSize);
+//        int count = 0;
+//
+//        //
+//        List<SubTableValue> subTableValues = new ArrayList<>();
+//        for (int tableIndex = 1; tableIndex <= numOfTablesPerSQL; tableIndex++) {
+//            // each table
+//            SubTableValue subTableValue = new SubTableValue();
+//            subTableValue.setDatabase();
+//            subTableValue.setName();
+//            subTableValue.setSupertable();
+//
+//            List<RowValue> values = new ArrayList<>();
+//            for (int valueCnt = 0; valueCnt < numOfValuesPerSQL; valueCnt++) {
+//                List<FieldValue> fields = new ArrayList<>();
+//                for (int fieldInd = 0; fieldInd <; fieldInd++) {
+//                    FieldValue<Object> field = new FieldValue<>("", "");
+//                    fields.add(field);
+//                }
+//                RowValue row = new RowValue();
+//                row.setFields(fields);
+//                values.add(row);
+//            }
+//            subTableValue.setValues(values);
+//            subTableValues.add(subTableValue);
+//        }
+
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SuperTableService.java

+package com.taosdata.taosdemo.service;
+
+import com.taosdata.taosdemo.domain.SuperTableMeta;
+import com.taosdata.taosdemo.mapper.SuperTableMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class SuperTableService {
+
+    @Autowired
+    private SuperTableMapper superTableMapper;
+
+    // 创建超级表，指定每个field的名称和类型，每个tag的名称和类型
+    public int create(SuperTableMeta superTableMeta) {
+        return superTableMapper.createSuperTable(superTableMeta);
+    }
+
+    public void drop(String database, String name) {
+        superTableMapper.dropSuperTable(database, name);
+    }
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/TableService.java

+package com.taosdata.taosdemo.service;
+
+import com.taosdata.taosdemo.domain.TableMeta;
+import com.taosdata.taosdemo.mapper.TableMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+@Service
+public class TableService extends AbstractService {
+
+    @Autowired
+    private TableMapper tableMapper;
+
+    //创建一张表
+    public int create(TableMeta tableMeta) {
+        return tableMapper.create(tableMeta);
+    }
+
+    //创建多张表
+    public int create(List<TableMeta> tables) {
+        return create(tables, 1);
+    }
+
+    //多线程创建多张表
+    public int create(List<TableMeta> tables, int threadSize) {
+        ExecutorService executors = Executors.newFixedThreadPool(threadSize);
+        List<Future<Integer>> futures = new ArrayList<>();
+        for (TableMeta table : tables) {
+            Future<Integer> future = executors.submit(() -> create(table));
+            futures.add(future);
+        }
+        return getAffectRows(futures);
+    }
+
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/FieldValueGenerator.java

+package com.taosdata.taosdemo.service.data;
+
+import com.taosdata.taosdemo.domain.FieldMeta;
+import com.taosdata.taosdemo.domain.FieldValue;
+import com.taosdata.taosdemo.domain.RowValue;
+import com.taosdata.taosdemo.utils.DataGenerator;
+
+import java.util.*;
+
+public class FieldValueGenerator {
+
+    public static Random random = new Random(System.currentTimeMillis());
+
+    // 生成start到end的时间序列，时间戳为顺序，不含有乱序，field的value为随机生成
+    public static List<RowValue> generate(long start, long end, long timeGap, List<FieldMeta> fieldMetaList) {
+        List<RowValue> values = new ArrayList<>();
+
+        for (long ts = start; ts < end; ts += timeGap) {
+            List<FieldValue> fieldValues = new ArrayList<>();
+            // timestamp
+            fieldValues.add(new FieldValue(fieldMetaList.get(0).getName(), ts));
+            // other values
+            for (int fieldInd = 1; fieldInd < fieldMetaList.size(); fieldInd++) {
+                FieldMeta fieldMeta = fieldMetaList.get(fieldInd);
+                fieldValues.add(new FieldValue(fieldMeta.getName(), DataGenerator.randomValue(fieldMeta.getType())));
+            }
+            values.add(new RowValue(fieldValues));
+        }
+        return values;
+    }
+
+    // 生成start到end的时间序列，时间戳为顺序，含有乱序，rate为乱序的比例，range为乱序前跳范围，field的value为随机生成
+    public static List<RowValue> disrupt(List<RowValue> values, int rate, long range) {
+        long timeGap = (long) (values.get(1).getFields().get(0).getValue()) - (long) (values.get(0).getFields().get(0).getValue());
+        int bugSize = values.size() * rate / 100;
+        Set<Integer> bugIndSet = new HashSet<>();
+        while (bugIndSet.size() < bugSize) {
+            bugIndSet.add(random.nextInt(values.size()));
+        }
+        for (Integer bugInd : bugIndSet) {
+            Long timestamp = (Long) values.get(bugInd).getFields().get(0).getValue();
+            Long newTimestamp = timestamp - timeGap - random.nextInt((int) range);
+            values.get(bugInd).getFields().get(0).setValue(newTimestamp);
+        }
+
+        return values;
+    }
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/SubTableMetaGenerator.java

+package com.taosdata.taosdemo.service.data;
+
+import com.taosdata.taosdemo.domain.SubTableMeta;
+import com.taosdata.taosdemo.domain.SuperTableMeta;
+import com.taosdata.taosdemo.domain.TagValue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SubTableMetaGenerator {
+
+    // 创建tableSize张子表，使用tablePrefix作为子表名的前缀，使用superTableMeta的元数据
+    // create table xxx using XXX tags(XXX)
+    public static List<SubTableMeta> generate(SuperTableMeta superTableMeta, int tableSize, String tablePrefix) {
+        List<SubTableMeta> subTableMetaList = new ArrayList<>();
+        for (int i = 1; i <= tableSize; i++) {
+            SubTableMeta subTableMeta = new SubTableMeta();
+            // create table xxx.xxx using xxx tags(...)
+            subTableMeta.setDatabase(superTableMeta.getDatabase());
+            subTableMeta.setName(tablePrefix + i);
+            subTableMeta.setSupertable(superTableMeta.getName());
+            subTableMeta.setFields(superTableMeta.getFields());
+            List<TagValue> tagValues = TagValueGenerator.generate(superTableMeta.getTags());
+            subTableMeta.setTags(tagValues);
+            subTableMetaList.add(subTableMeta);
+        }
+        return subTableMetaList;
+    }
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/SubTableValueGenerator.java

+package com.taosdata.taosdemo.service.data;
+
+import com.taosdata.taosdemo.domain.RowValue;
+import com.taosdata.taosdemo.domain.SubTableMeta;
+import com.taosdata.taosdemo.domain.SubTableValue;
+import com.taosdata.taosdemo.utils.TimeStampUtil;
+import org.springframework.beans.BeanUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SubTableValueGenerator {
+
+    public static List<SubTableValue> generate(List<SubTableMeta> subTableMetaList, int numOfRowsPerTable, long start, long timeGap) {
+        List<SubTableValue> subTableValueList = new ArrayList<>();
+
+        subTableMetaList.stream().forEach((subTableMeta) -> {
+            // insert into xxx.xxx using xxxx tags(...) values(),()...
+            SubTableValue subTableValue = new SubTableValue();
+            subTableValue.setDatabase(subTableMeta.getDatabase());
+            subTableValue.setName(subTableMeta.getName());
+            subTableValue.setSupertable(subTableMeta.getSupertable());
+            subTableValue.setTags(subTableMeta.getTags());
+            TimeStampUtil.TimeTuple tuple = TimeStampUtil.range(start, timeGap, numOfRowsPerTable);
+            List<RowValue> values = FieldValueGenerator.generate(tuple.start, tuple.end, tuple.timeGap, subTableMeta.getFields());
+            subTableValue.setValues(values);
+            subTableValueList.add(subTableValue);
+        });
+        return subTableValueList;
+    }
+
+    public static void disrupt(List<SubTableValue> subTableValueList, int rate, long range) {
+        subTableValueList.stream().forEach((tableValue) -> {
+            List<RowValue> values = tableValue.getValues();
+            FieldValueGenerator.disrupt(values, rate, range);
+        });
+    }
+
+    public static List<List<SubTableValue>> split(List<SubTableValue> subTableValueList, int numOfTables, int numOfTablesPerSQL, int numOfRowsPerTable, int numOfValuesPerSQL) {
+        List<List<SubTableValue>> dataList = new ArrayList<>();
+
+        if (numOfRowsPerTable < numOfValuesPerSQL)
+            numOfValuesPerSQL = numOfRowsPerTable;
+        if (numOfTables < numOfTablesPerSQL)
+            numOfTablesPerSQL = numOfTables;
+
+        //table
+        for (int tableCnt = 0; tableCnt < numOfTables; ) {
+            int tableSize = numOfTablesPerSQL;
+            if (tableCnt + tableSize > numOfTables) {
+                tableSize = numOfTables - tableCnt;
+            }
+            // row
+            for (int rowCnt = 0; rowCnt < numOfRowsPerTable; ) {
+                int rowSize = numOfValuesPerSQL;
+                if (rowCnt + rowSize > numOfRowsPerTable) {
+                    rowSize = numOfRowsPerTable - rowCnt;
+                }
+                // System.out.println("rowCnt: " + rowCnt + ", rowSize: " + rowSize + ", tableCnt: " + tableCnt + ", tableSize: " + tableSize);
+                // split
+                List<SubTableValue> blocks = subTableValueList.subList(tableCnt, tableCnt + tableSize);
+                List<SubTableValue> newBlocks = new ArrayList<>();
+                for (int i = 0; i < blocks.size(); i++) {
+                    SubTableValue subTableValue = blocks.get(i);
+                    SubTableValue newSubTableValue = new SubTableValue();
+                    BeanUtils.copyProperties(subTableValue, newSubTableValue);
+                    List<RowValue> values = subTableValue.getValues().subList(rowCnt, rowCnt + rowSize);
+                    newSubTableValue.setValues(values);
+                    newBlocks.add(newSubTableValue);
+                }
+                dataList.add(newBlocks);
+
+                rowCnt += rowSize;
+            }
+            tableCnt += tableSize;
+        }
+        return dataList;
+    }
+
+    public static void main(String[] args) {
+        split(null, 99, 10, 99, 10);
+    }
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/SuperTableMetaGenerator.java

+package com.taosdata.taosdemo.service.data;
+
+import com.taosdata.taosdemo.domain.FieldMeta;
+import com.taosdata.taosdemo.domain.SuperTableMeta;
+import com.taosdata.taosdemo.domain.TagMeta;
+import com.taosdata.taosdemo.utils.TaosConstants;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SuperTableMetaGenerator {
+
+    // 创建超级表，使用指定SQL语句
+    public static SuperTableMeta generate(String superTableSQL) {
+        SuperTableMeta tableMeta = new SuperTableMeta();
+        // for example : create table superTable (ts timestamp, temperature float, humidity int) tags(location nchar(64), groupId int)
+        superTableSQL = superTableSQL.trim().toLowerCase();
+        if (!superTableSQL.startsWith("create"))
+            throw new RuntimeException("invalid create super table SQL");
+
+        if (superTableSQL.contains("tags")) {
+            String tagSQL = superTableSQL.substring(superTableSQL.indexOf("tags") + 4).trim();
+            tagSQL = tagSQL.substring(tagSQL.indexOf("(") + 1, tagSQL.lastIndexOf(")"));
+            String[] tagPairs = tagSQL.split(",");
+            List<TagMeta> tagMetaList = new ArrayList<>();
+            for (String tagPair : tagPairs) {
+                String name = tagPair.trim().split("\\s+")[0];
+                String type = tagPair.trim().split("\\s+")[1];
+                tagMetaList.add(new TagMeta(name, type));
+            }
+            tableMeta.setTags(tagMetaList);
+            superTableSQL = superTableSQL.substring(0, superTableSQL.indexOf("tags"));
+        }
+        if (superTableSQL.contains("(")) {
+            String fieldSQL = superTableSQL.substring(superTableSQL.indexOf("(") + 1, superTableSQL.indexOf(")"));
+            String[] fieldPairs = fieldSQL.split(",");
+            List<FieldMeta> fieldList = new ArrayList<>();
+            for (String fieldPair : fieldPairs) {
+                String name = fieldPair.trim().split("\\s+")[0];
+                String type = fieldPair.trim().split("\\s+")[1];
+                fieldList.add(new FieldMeta(name, type));
+            }
+            tableMeta.setFields(fieldList);
+            superTableSQL = superTableSQL.substring(0, superTableSQL.indexOf("("));
+        }
+        superTableSQL = superTableSQL.substring(superTableSQL.indexOf("table") + 5).trim();
+        if (superTableSQL.contains(".")) {
+            String database = superTableSQL.split("\\.")[0];
+            tableMeta.setDatabase(database);
+            superTableSQL = superTableSQL.substring(superTableSQL.indexOf(".") + 1);
+        }
+        tableMeta.setName(superTableSQL.trim());
+
+        return tableMeta;
+    }
+
+    // 创建超级表,指定field和tag的个数
+    public static SuperTableMeta generate(String database, String name, int fieldSize, String fieldPrefix, int tagSize, String tagPrefix) {
+        if (fieldSize < 2 || tagSize < 1) {
+            throw new RuntimeException("create super table but fieldSize less than 2 or tagSize less than 1");
+        }
+        SuperTableMeta tableMetadata = new SuperTableMeta();
+        tableMetadata.setDatabase(database);
+        tableMetadata.setName(name);
+        // fields
+        List<FieldMeta> fields = new ArrayList<>();
+        fields.add(new FieldMeta("ts", "timestamp"));
+        for (int i = 1; i <= fieldSize; i++) {
+            fields.add(new FieldMeta(fieldPrefix + "" + i, TaosConstants.DATA_TYPES[i % TaosConstants.DATA_TYPES.length]));
+        }
+        tableMetadata.setFields(fields);
+        // tags
+        List<TagMeta> tags = new ArrayList<>();
+        for (int i = 1; i <= tagSize; i++) {
+            tags.add(new TagMeta(tagPrefix + "" + i, TaosConstants.DATA_TYPES[i % TaosConstants.DATA_TYPES.length]));
+        }
+        tableMetadata.setTags(tags);
+        return tableMetadata;
+    }
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/data/TagValueGenerator.java

+package com.taosdata.taosdemo.service.data;
+
+import com.taosdata.taosdemo.domain.TagMeta;
+import com.taosdata.taosdemo.domain.TagValue;
+import com.taosdata.taosdemo.utils.DataGenerator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TagValueGenerator {
+
+    // 创建标签值：使用tagMetas
+    public static List<TagValue> generate(List<TagMeta> tagMetas) {
+        List<TagValue> tagValues = new ArrayList<>();
+        for (int i = 0; i < tagMetas.size(); i++) {
+            TagMeta tagMeta = tagMetas.get(i);
+            TagValue tagValue = new TagValue();
+            tagValue.setName(tagMeta.getName());
+            tagValue.setValue(DataGenerator.randomValue(tagMeta.getType()));
+            tagValues.add(tagValue);
+        }
+        return tagValues;
+    }
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/DataGenerator.java

+package com.taosdata.taosdemo.utils;
+
+import java.util.Random;
+
+public class DataGenerator {
+    private static Random random = new Random(System.currentTimeMillis());
+    private static final String alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
+
+    // "timestamp", "int", "bigint", "float", "double", "binary(64)", "smallint", "tinyint", "bool", "nchar(64)",
+
+    public static Object randomValue(String type) {
+        int length = 64;
+        if (type.contains("(")) {
+            length = Integer.parseInt(type.substring(type.indexOf("(") + 1, type.indexOf(")")));
+            type = type.substring(0, type.indexOf("("));
+        }
+        switch (type.trim().toLowerCase()) {
+            case "timestamp":
+                return randomTimestamp();
+            case "int":
+                return randomInt();
+            case "bigint":
+                return randomBigint();
+            case "float":
+                return randomFloat();
+            case "double":
+                return randomDouble();
+            case "binary":
+                return randomBinary(length);
+            case "smallint":
+                return randomSmallint();
+            case "tinyint":
+                return randomTinyint();
+            case "bool":
+                return randomBoolean();
+            case "nchar":
+                return randomNchar(length);
+            default:
+                throw new IllegalArgumentException("Unexpected value: " + type);
+        }
+    }
+
+    public static Long randomTimestamp() {
+        long start = System.currentTimeMillis();
+        return randomTimestamp(start, start + 60l * 60l * 1000l);
+    }
+
+    public static Long randomTimestamp(Long start, Long end) {
+        return start + (long) random.nextInt((int) (end - start));
+    }
+
+    public static String randomNchar(int length) {
+        return randomChinese(length);
+    }
+
+    public static Boolean randomBoolean() {
+        return random.nextBoolean();
+    }
+
+    public static Integer randomTinyint() {
+        return randomInt(-127, 127);
+    }
+
+    public static Integer randomSmallint() {
+        return randomInt(-32767, 32767);
+    }
+
+    public static String randomBinary(int length) {
+        return randomString(length);
+    }
+
+    public static String randomString(int length) {
+        String zh_en = "";
+        for (int i = 0; i < length; i++) {
+            zh_en += alphabet.charAt(random.nextInt(alphabet.length()));
+        }
+        return zh_en;
+    }
+
+    public static String randomChinese(int length) {
+        String zh_cn = "";
+        int bottom = Integer.parseInt("4e00", 16);
+        int top = Integer.parseInt("9fa5", 16);
+
+        for (int i = 0; i < length; i++) {
+            char c = (char) (random.nextInt(top - bottom + 1) + bottom);
+            zh_cn += new String(new char[]{c});
+        }
+        return zh_cn;
+    }
+
+    public static Double randomDouble() {
+        return randomDouble(0, 100);
+    }
+
+    public static Double randomDouble(double bottom, double top) {
+        return bottom + (top - bottom) * random.nextDouble();
+    }
+
+    public static Float randomFloat() {
+        return randomFloat(0, 100);
+    }
+
+    public static Float randomFloat(float bottom, float top) {
+        return bottom + (top - bottom) * random.nextFloat();
+    }
+
+    public static Long randomBigint() {
+        return random.nextLong();
+    }
+
+    public static Integer randomInt(int bottom, int top) {
+        return bottom + random.nextInt((top - bottom));
+    }
+
+    public static Integer randomInt() {
+        return randomInt(0, 100);
+    }
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/JdbcTaosdemoConfig.java

+package com.taosdata.taosdemo.utils;
+
+public final class JdbcTaosdemoConfig {
+    // instance
+    public String host;                     //host
+    public int port = 6030;                 //port
+    public String user = "root";            //user
+    public String password = "taosdata";    //password
+    // database
+    public String database = "test";        //database
+    public int keep = 3650;                 //keep
+    public int days = 30;                   //days
+    public int replica = 1;                 //replica
+    //super table
+    public boolean doCreateTable = true;
+    public String superTable = "weather";   //super table name
+    public String prefixOfFields = "col";
+    public int numOfFields;
+    public String prefixOfTags = "tag";
+    public int numOfTags;
+    public String superTableSQL;
+    //sub table
+    public String tablePrefix = "t";
+    public int numOfTables = 100;
+    public int numOfThreadsForCreate = 1;
+    // insert task
+    public boolean autoCreateTable;
+    public int numOfRowsPerTable = 100;
+    public int numOfThreadsForInsert = 1;
+    public int numOfTablesPerSQL = 10;
+    public int numOfValuesPerSQL = 10;
+    public long startTime;
+    public long timeGap;
+    public int sleep = 0;
+    public int order = 0;
+    public int rate = 10;
+    public long range = 1000l;
+    // select task
+
+    // drop task
+    public boolean dropTable = false;
+
+    public static void printHelp() {
+        System.out.println("Usage: java -jar jdbc-taosdemo-2.0.jar [OPTION...]");
+        // instance
+        System.out.println("-host                       The host to connect to TDengine which you must specify");
+        System.out.println("-port                       The TCP/IP port number to use for the connection. Default is 6030");
+        System.out.println("-user                       The TDengine user name to use when connecting to the server. Default is 'root'");
+        System.out.println("-password                   The password to use when connecting to the server.Default is 'taosdata'");
+        // database
+        System.out.println("-database                   Destination database. Default is 'test'");
+        System.out.println("-keep                       database keep parameter. Default is 3650");
+        System.out.println("-days                       database days parameter. Default is 30");
+        System.out.println("-replica                    database replica parameter. Default 1, min: 1, max: 3");
+        // super table
+        System.out.println("-doCreateTable              do create super table and sub table, true or false, Default true");
+        System.out.println("-superTable                 super table name. Default 'weather'");
+        System.out.println("-prefixOfFields             The prefix of field in super table. Default is 'col'");
+        System.out.println("-numOfFields                The number of field in super table. Default is (ts timestamp, temperature float, humidity int).");
+        System.out.println("-prefixOfTags               The prefix of tag in super table. Default is 'tag'");
+        System.out.println("-numOfTags                  The number of tag in super table. Default is (location nchar(64), groupId int).");
+        System.out.println("-superTableSQL              specify a sql statement for the super table.\n" +
+                "                            Default is 'create table weather(ts timestamp, temperature float, humidity int) tags(location nchar(64), groupId int). \n" +
+                "                            if you use this parameter, the numOfFields and numOfTags will be invalid'");
+        // sub table
+        System.out.println("-tablePrefix                The prefix of sub tables. Default is 't'");
+        System.out.println("-numOfTables                The number of tables. Default is 1");
+        System.out.println("-numOfThreadsForCreate      The number of thread during create sub table. Default is 1");
+        // insert task
+        System.out.println("-autoCreateTable            Use auto Create sub tables SQL. Default is false");
+        System.out.println("-numOfRowsPerTable          The number of records per table. Default is 1");
+        System.out.println("-numOfThreadsForInsert      The number of threads during insert row. Default is 1");
+        System.out.println("-numOfTablesPerSQL          The number of table per SQL. Default is 1");
+        System.out.println("-numOfValuesPerSQL          The number of value per SQL. Default is 1");
+        System.out.println("-startTime                  start time for insert task, The format is \"yyyy-MM-dd HH:mm:ss.SSS\".");
+        System.out.println("-timeGap                    the number of time gap. Default is 1000 ms");
+        System.out.println("-sleep                      The number of milliseconds for sleep after each insert. default is 0");
+        System.out.println("-order                      Insert mode--0: In order, 1: Out of order. Default is in order");
+        System.out.println("-rate                       The proportion of data out of order. effective only if order is 1. min 0, max 100, default is 10");
+        System.out.println("-range                      The range of data out of order. effective only if order is 1. default is 1000 ms");
+
+        // query task
+//        System.out.println("-sqlFile                   The select sql file");
+        // drop task
+        System.out.println("-dropTable                  Drop data before quit. Default is false");
+        System.out.println("--help                      Give this help list");
+        System.out.println("--infinite                  Infinite insert mode");
+    }
+
+    /**
+     * parse args from command line
+     *
+     * @param args command line args
+     * @return JdbcTaosdemoConfig
+     */
+    public JdbcTaosdemoConfig(String[] args) {
+        for (int i = 0; i < args.length; i++) {
+            // instance
+            if ("-host".equals(args[i]) && i < args.length - 1) {
+                host = args[++i];
+            }
+            if ("-port".equals(args[i]) && i < args.length - 1) {
+                port = Integer.parseInt(args[++i]);
+            }
+            if ("-user".equals(args[i]) && i < args.length - 1) {
+                user = args[++i];
+            }
+            if ("-password".equals(args[i]) && i < args.length - 1) {
+                password = args[++i];
+            }
+            // database
+            if ("-database".equals(args[i]) && i < args.length - 1) {
+                database = args[++i];
+            }
+            if ("-keep".equals(args[i]) && i < args.length - 1) {
+                keep = Integer.parseInt(args[++i]);
+            }
+            if ("-days".equals(args[i]) && i < args.length - 1) {
+                days = Integer.parseInt(args[++i]);
+            }
+            if ("-replica".equals(args[i]) && i < args.length - 1) {
+                replica = Integer.parseInt(args[++i]);
+            }
+            // super table
+            if ("-doCreateTable".equals(args[i]) && i < args.length - 1) {
+                doCreateTable = Boolean.parseBoolean(args[++i]);
+            }
+            if ("-superTable".equals(args[i]) && i < args.length - 1) {
+                superTable = args[++i];
+            }
+            if ("-prefixOfFields".equals(args[i]) && i < args.length - 1) {
+                prefixOfFields = args[++i];
+            }
+            if ("-numOfFields".equals(args[i]) && i < args.length - 1) {
+                numOfFields = Integer.parseInt(args[++i]);
+            }
+            if ("-prefixOfTags".equals(args[i]) && i < args.length - 1) {
+                prefixOfTags = args[++i];
+            }
+            if ("-numOfTags".equals(args[i]) && i < args.length - 1) {
+                numOfTags = Integer.parseInt(args[++i]);
+            }
+            if ("-superTableSQL".equals(args[i]) && i < args.length - 1) {
+                superTableSQL = args[++i];
+            }
+            // sub table
+            if ("-tablePrefix".equals(args[i]) && i < args.length - 1) {
+                tablePrefix = args[++i];
+            }
+            if ("-numOfTables".equals(args[i]) && i < args.length - 1) {
+                numOfTables = Integer.parseInt(args[++i]);
+            }
+            if ("-autoCreateTable".equals(args[i]) && i < args.length - 1) {
+                autoCreateTable = Boolean.parseBoolean(args[++i]);
+            }
+            if ("-numOfThreadsForCreate".equals(args[i]) && i < args.length - 1) {
+                numOfThreadsForCreate = Integer.parseInt(args[++i]);
+            }
+            // insert task
+            if ("-numOfRowsPerTable".equals(args[i]) && i < args.length - 1) {
+                numOfRowsPerTable = Integer.parseInt(args[++i]);
+            }
+            if ("-numOfThreadsForInsert".equals(args[i]) && i < args.length - 1) {
+                numOfThreadsForInsert = Integer.parseInt(args[++i]);
+            }
+            if ("-numOfTablesPerSQL".equals(args[i]) && i < args.length - 1) {
+                numOfTablesPerSQL = Integer.parseInt(args[++i]);
+            }
+            if ("-numOfValuesPerSQL".equals(args[i]) && i < args.length - 1) {
+                numOfValuesPerSQL = Integer.parseInt(args[++i]);
+            }
+            if ("-startTime".equals(args[i]) && i < args.length - 1) {
+                startTime = TimeStampUtil.datetimeToLong(args[++i]);
+            }
+            if ("-timeGap".equals(args[i]) && i < args.length - 1) {
+                timeGap = Long.parseLong(args[++i]);
+            }
+            if ("-sleep".equals(args[i]) && i < args.length - 1) {
+                sleep = Integer.parseInt(args[++i]);
+            }
+            if ("-order".equals(args[i]) && i < args.length - 1) {
+                order = Integer.parseInt(args[++i]);
+            }
+            if ("-rate".equals(args[i]) && i < args.length - 1) {
+                rate = Integer.parseInt(args[++i]);
+                if (rate < 0 || rate > 100)
+                    throw new IllegalArgumentException("rate must between 0 and 100");
+            }
+            if ("-range".equals(args[i]) && i < args.length - 1) {
+                range = Integer.parseInt(args[++i]);
+            }
+            // select task
+
+            // drop task
+            if ("-dropTable".equals(args[i]) && i < args.length - 1) {
+                dropTable = Boolean.parseBoolean(args[++i]);
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        JdbcTaosdemoConfig config = new JdbcTaosdemoConfig(args);
+    }
+
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/TaosConstants.java

+package com.taosdata.taosdemo.utils;
+
+public class TaosConstants {
+    public static final String[] DATA_TYPES = {
+            "timestamp", "int", "bigint", "float", "double",
+            "binary(64)", "smallint", "tinyint", "bool", "nchar(64)",
+    };
+}

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/utils/TimeStampUtil.java

+package com.taosdata.taosdemo.utils;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class TimeStampUtil {
+
+    private static final String datetimeFormat = "yyyy-MM-dd HH:mm:ss.SSS";
+
+    public static long datetimeToLong(String dateTime) {
+        SimpleDateFormat sdf = new SimpleDateFormat(datetimeFormat);
+        try {
+            return sdf.parse(dateTime).getTime();
+        } catch (ParseException e) {
+            throw new IllegalArgumentException("invalid datetime string >>> " + dateTime);
+        }
+    }
+
+    public static String longToDatetime(long time) {
+        SimpleDateFormat sdf = new SimpleDateFormat(datetimeFormat);
+        return sdf.format(new Date(time));
+    }
+
+    public static class TimeTuple {
+        public Long start;
+        public Long end;
+        public Long timeGap;
+
+        TimeTuple(long start, long end, long timeGap) {
+            this.start = start;
+            this.end = end;
+            this.timeGap = timeGap;
+        }
+    }
+
+    public static TimeTuple range(long start, long timeGap, long size) {
+        long now = System.currentTimeMillis();
+        if (timeGap < 1)
+            timeGap = 1;
+        if (start == 0)
+            start = now - size * timeGap;
+
+        // 如果size小于1异常
+        if (size < 1)
+            throw new IllegalArgumentException("size less than 1.");
+        // 如果timeGap为1，已经超长，需要前移start
+        if (start + size > now) {
+            start = now - size;
+            return new TimeTuple(start, now, 1);
+        }
+        long end = start + (long) (timeGap * size);
+        if (end > now) {
+            //压缩timeGap
+            end = now;
+            double gap = (end - start) / (size * 1.0f);
+            if (gap < 1.0f) {
+                timeGap = 1;
+                start = end - size;
+            } else {
+                timeGap = (long) gap;
+                end = start + (long) (timeGap * size);
+            }
+        }
+        return new TimeTuple(start, end, timeGap);
+    }
+}

tests/examples/JDBC/taosdemo/src/main/resources/application.properties

+spring.datasource.url=jdbc:mysql://master:3306/?useSSL=false&useUnicode=true&characterEncoding=UTF-8
+spring.datasource.driver-class-name=com.mysql.jdbc.Driver
+spring.datasource.username=root
+spring.datasource.password=123456
 
+spring.datasource.hikari.maximum-pool-size=10
+spring.datasource.hikari.minimum-idle=10
+spring.datasource.hikari.max-lifetime=600000
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/resources/log4j.properties

+### 设置###
+log4j.rootLogger=debug,stdout,DebugLog,ErrorLog
+### 输出信息到控制抬 ###
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.Target=System.out
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=[%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
+### 输出DEBUG 级别以上的日志到=logs/debug.log
+log4j.appender.DebugLog=org.apache.log4j.DailyRollingFileAppender
+log4j.appender.DebugLog.File=logs/debug.log
+log4j.appender.DebugLog.Append=true
+log4j.appender.DebugLog.Threshold=DEBUG 
+log4j.appender.DebugLog.layout=org.apache.log4j.PatternLayout
+log4j.appender.DebugLog.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
+### 输出ERROR 级别以上的日志到=logs/error.log
+log4j.appender.ErrorLog=org.apache.log4j.DailyRollingFileAppender
+log4j.appender.ErrorLog.File=logs/error.log 
+log4j.appender.ErrorLog.Append=true
+log4j.appender.ErrorLog.Threshold=ERROR 
+log4j.appender.ErrorLog.layout=org.apache.log4j.PatternLayout
+log4j.appender.ErrorLog.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/resources/templates/index.html

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Index</title>
+</head>
+<body>
+<h1>Hello~~~</h1>
+</body>
+</html>
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/DatabaseMapperTest.java

+package com.taosdata.taosdemo.mapper;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class DatabaseMapperTest {
+    @Autowired
+    private DatabaseMapper databaseMapper;
+
+    @Test
+    public void createDatabase() {
+        databaseMapper.createDatabase("db_test");
+    }
+
+    @Test
+    public void dropDatabase() {
+        databaseMapper.dropDatabase("db_test");
+    }
+
+    @Test
+    public void creatDatabaseWithParameters() {
+        Map<String, String> map = new HashMap<>();
+        map.put("dbname", "weather");
+        map.put("keep", "3650");
+        map.put("days", "30");
+        map.put("replica", "1");
+        databaseMapper.createDatabaseWithParameters(map);
+    }
+
+    @Test
+    public void useDatabase() {
+        databaseMapper.useDatabase("test");
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/SubTableMapperTest.java

+package com.taosdata.taosdemo.mapper;
+
+import com.taosdata.taosdemo.domain.*;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class SubTableMapperTest {
+    @Autowired
+    private SubTableMapper subTableMapper;
+    private List<SubTableValue> tables;
+
+    @Test
+    public void createUsingSuperTable() {
+        SubTableMeta subTableMeta = new SubTableMeta();
+        subTableMeta.setDatabase("test");
+        subTableMeta.setSupertable("weather");
+        subTableMeta.setName("t1");
+        List<TagValue> tags = new ArrayList<>();
+        for (int i = 0; i < 3; i++) {
+            tags.add(new TagValue("tag" + (i + 1), "nchar(64)"));
+        }
+        subTableMeta.setTags(tags);
+        subTableMapper.createUsingSuperTable(subTableMeta);
+    }
+
+    @Test
+    public void insertOneTableMultiValues() {
+        subTableMapper.insertOneTableMultiValues(tables.get(0));
+    }
+
+    @Test
+    public void insertOneTableMultiValuesUsingSuperTable() {
+        subTableMapper.insertOneTableMultiValuesUsingSuperTable(tables.get(0));
+    }
+
+
+    @Test
+    public void insertMultiTableMultiValues() {
+        subTableMapper.insertMultiTableMultiValues(tables);
+    }
+
+    @Test
+    public void insertMultiTableMultiValuesUsingSuperTable() {
+        subTableMapper.insertMultiTableMultiValuesUsingSuperTable(tables);
+    }
+
+
+    @Before
+    public void before() {
+        tables = new ArrayList<>();
+        for (int ind = 0; ind < 3; ind++) {
+
+            SubTableValue table = new SubTableValue();
+            table.setDatabase("test");
+            // supertable
+            table.setSupertable("weather");
+            table.setName("t" + (ind + 1));
+            // tags
+            List<TagValue> tags = new ArrayList<>();
+            for (int i = 0; i < 3; i++) {
+                tags.add(new TagValue("tag" + (i + 1), "beijing"));
+            }
+            table.setTags(tags);
+            // values
+            List<RowValue> values = new ArrayList<>();
+            for (int i = 0; i < 2; i++) {
+                List<FieldValue> fields = new ArrayList<>();
+                for (int j = 0; j < 4; j++) {
+                    fields.add(new FieldValue("f" + (j + 1), (j + 1) * 10));
+                }
+                values.add(new RowValue(fields));
+            }
+            table.setValues(values);
+
+            tables.add(table);
+        }
+    }
+
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/SuperTableMapperTest.java

+package com.taosdata.taosdemo.mapper;
+
+import com.taosdata.taosdemo.domain.FieldMeta;
+import com.taosdata.taosdemo.domain.SuperTableMeta;
+import com.taosdata.taosdemo.domain.TagMeta;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class SuperTableMapperTest {
+    @Autowired
+    private SuperTableMapper superTableMapper;
+
+    @Test
+    public void testCreateSuperTableUsingSQL() {
+        String sql = "create table test.weather (ts timestamp, temperature float, humidity int) tags(location nchar(64), groupId int)";
+        superTableMapper.createSuperTableUsingSQL(sql);
+    }
+
+    @Test
+    public void createSuperTable() {
+        SuperTableMeta superTableMeta = new SuperTableMeta();
+        superTableMeta.setDatabase("test");
+        superTableMeta.setName("weather");
+        List<FieldMeta> fields = new ArrayList<>();
+        for (int i = 0; i < 5; i++) {
+            fields.add(new FieldMeta("f" + (i + 1), "int"));
+        }
+        superTableMeta.setFields(fields);
+        List<TagMeta> tags = new ArrayList<>();
+        for (int i = 0; i < 3; i++) {
+            tags.add(new TagMeta("t" + (i + 1), "nchar(64)"));
+        }
+        superTableMeta.setTags(tags);
+
+        superTableMapper.createSuperTable(superTableMeta);
+    }
+
+    @Test
+    public void dropSuperTable() {
+        superTableMapper.dropSuperTable("test", "weather");
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/mapper/TableMapperTest.java

+package com.taosdata.taosdemo.mapper;
+
+import com.taosdata.taosdemo.domain.*;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+@SpringBootTest
+@RunWith(SpringRunner.class)
+public class TableMapperTest {
+    @Autowired
+    private TableMapper tableMapper;
+    private static Random random = new Random(System.currentTimeMillis());
+
+    @Test
+    public void create() {
+        TableMeta table = new TableMeta();
+        table.setDatabase("test");
+        table.setName("t1");
+        List<FieldMeta> fields = new ArrayList<>();
+        for (int i = 0; i < 3; i++) {
+            FieldMeta field = new FieldMeta();
+            field.setName("f" + (i + 1));
+            field.setType("nchar(64)");
+            fields.add(field);
+        }
+        table.setFields(fields);
+        tableMapper.create(table);
+    }
+
+    @Test
+    public void insertOneTableMultiValues() {
+        TableValue table = new TableValue();
+        table.setDatabase("test");
+        table.setName("t1");
+        List<RowValue> values = new ArrayList<>();
+        for (int j = 0; j < 5; j++) {
+            List<FieldValue> fields = new ArrayList<>();
+            for (int k = 0; k < 2; k++) {
+                FieldValue field = new FieldValue<>();
+                field.setValue((k + 1) * 100);
+                fields.add(field);
+            }
+            values.add(new RowValue(fields));
+        }
+        table.setValues(values);
+
+        tableMapper.insertOneTableMultiValues(table);
+    }
+
+    @Test
+    public void insertOneTableMultiValuesWithCoulmns() {
+        TableValue tableValue = new TableValue();
+        tableValue.setDatabase("test");
+        tableValue.setName("weather");
+        // columns
+        List<FieldMeta> columns = new ArrayList<>();
+        for (int i = 0; i < 3; i++) {
+            FieldMeta field = new FieldMeta();
+            field.setName("f" + (i + 1));
+            columns.add(field);
+        }
+        tableValue.setColumns(columns);
+        // values
+        List<RowValue> values = new ArrayList<>();
+        for (int i = 0; i < 3; i++) {
+            List<FieldValue> fields = new ArrayList<>();
+            for (int j = 0; j < 3; j++) {
+                FieldValue field = new FieldValue();
+                field.setValue(j);
+                fields.add(field);
+            }
+            values.add(new RowValue(fields));
+        }
+        tableValue.setValues(values);
+        tableMapper.insertOneTableMultiValuesWithColumns(tableValue);
+    }
+
+    @Test
+    public void insertMultiTableMultiValues() {
+        List<TableValue> tables = new ArrayList<>();
+        for (int i = 0; i < 3; i++) {
+            TableValue table = new TableValue();
+            table.setDatabase("test");
+            table.setName("t" + (i + 1));
+            List<RowValue> values = new ArrayList<>();
+            for (int j = 0; j < 5; j++) {
+                List<FieldValue> fields = new ArrayList<>();
+                for (int k = 0; k < 2; k++) {
+                    FieldValue field = new FieldValue<>();
+                    field.setValue((k + 1) * 10);
+                    fields.add(field);
+                }
+                values.add(new RowValue(fields));
+            }
+            table.setValues(values);
+
+            tables.add(table);
+        }
+        tableMapper.insertMultiTableMultiValues(tables);
+    }
+
+    @Test
+    public void insertMultiTableMultiValuesWithCoulumns() {
+        List<TableValue> tables = new ArrayList<>();
+        for (int i = 0; i < 3; i++) {
+            TableValue table = new TableValue();
+            table.setDatabase("test");
+            table.setName("t" + (i + 1));
+            // columns
+            List<FieldMeta> columns = new ArrayList<>();
+            for (int j = 0; j < 3; j++) {
+                FieldMeta field = new FieldMeta();
+                field.setName("f" + (j + 1));
+                columns.add(field);
+            }
+            table.setColumns(columns);
+            // values
+            List<RowValue> values = new ArrayList<>();
+            for (int j = 0; j < 5; j++) {
+                List<FieldValue> fields = new ArrayList<>();
+                for (int k = 0; k < columns.size(); k++) {
+                    FieldValue field = new FieldValue<>();
+                    field.setValue((k + 1) * 10);
+                    fields.add(field);
+                }
+                values.add(new RowValue(fields));
+            }
+            table.setValues(values);
+
+            tables.add(table);
+        }
+        tableMapper.insertMultiTableMultiValuesWithColumns(tables);
+    }
+
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/DatabaseServiceTest.java

+package com.taosdata.taosdemo.service;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class DatabaseServiceTest {
+    @Autowired
+    private DatabaseService service;
+
+    @Test
+    public void testCreateDatabase1() {
+        service.createDatabase("testXXXX");
+    }
+
+    @Test
+    public void dropDatabase() {
+        service.dropDatabase("testXXXX");
+    }
+
+    @Test
+    public void useDatabase() {
+        service.useDatabase("test");
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/SubTableServiceTest.java

+package com.taosdata.taosdemo.service;
+
+import com.taosdata.taosdemo.domain.SubTableMeta;
+import com.taosdata.taosdemo.domain.TagValue;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class SubTableServiceTest {
+    @Autowired
+    private SubTableService service;
+
+    private List<SubTableMeta> subTables;
+
+    @Before
+    public void before() {
+        subTables = new ArrayList<>();
+        for (int i = 1; i <= 1; i++) {
+            SubTableMeta subTableMeta = new SubTableMeta();
+            subTableMeta.setDatabase("test");
+            subTableMeta.setSupertable("weather");
+            subTableMeta.setName("t" + i);
+            List<TagValue> tags = new ArrayList<>();
+            tags.add(new TagValue("location", "beijing"));
+            tags.add(new TagValue("groupId", i));
+            subTableMeta.setTags(tags);
+            subTables.add(subTableMeta);
+        }
+    }
+
+    @Test
+    public void testCreateSubTable() {
+        int count = service.createSubTable(subTables);
+        System.out.println("count >>> " + count);
+    }
+
+    @Test
+    public void testCreateSubTableList() {
+        int count = service.createSubTable(subTables, 10);
+        System.out.println("count >>> " + count);
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/SuperTableServiceTest.java

+package com.taosdata.taosdemo.service;
+
+import com.taosdata.taosdemo.domain.FieldMeta;
+import com.taosdata.taosdemo.domain.SuperTableMeta;
+import com.taosdata.taosdemo.domain.TagMeta;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class SuperTableServiceTest {
+
+    @Autowired
+    private SuperTableService service;
+
+    @Test
+    public void testCreate() {
+        SuperTableMeta superTableMeta = new SuperTableMeta();
+        superTableMeta.setDatabase("test");
+        superTableMeta.setName("weather");
+        List<FieldMeta> fields = new ArrayList<>();
+        fields.add(new FieldMeta("ts", "timestamp"));
+        fields.add(new FieldMeta("temperature", "float"));
+        fields.add(new FieldMeta("humidity", "int"));
+        superTableMeta.setFields(fields);
+        List<TagMeta> tags = new ArrayList<>();
+        tags.add(new TagMeta("location", "nchar(64)"));
+        tags.add(new TagMeta("groupId", "int"));
+        superTableMeta.setTags(tags);
+        service.create(superTableMeta);
+    }
+
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/TableServiceTest.java

+package com.taosdata.taosdemo.service;
+
+import com.taosdata.taosdemo.domain.TableMeta;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class TableServiceTest {
+    @Autowired
+    private TableService tableService;
+
+    private List<TableMeta> tables;
+
+    @Before
+    public void before() {
+        tables = new ArrayList<>();
+        for (int i = 0; i < 1; i++) {
+            TableMeta tableMeta = new TableMeta();
+            tableMeta.setDatabase("test");
+            tableMeta.setName("weather" + (i + 1));
+            tables.add(tableMeta);
+        }
+    }
+
+    @Test
+    public void testCreate() {
+        int count = tableService.create(tables);
+        System.out.println(count);
+    }
+
+    @Test
+    public void testCreateMultiThreads() {
+        System.out.println(tableService.create(tables, 10));
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/FieldValueGeneratorTest.java

+package com.taosdata.taosdemo.service.data;
+
+import com.taosdata.taosdemo.domain.FieldMeta;
+import com.taosdata.taosdemo.domain.RowValue;
+import com.taosdata.taosdemo.utils.TimeStampUtil;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FieldValueGeneratorTest {
+
+    private List<RowValue> rowValues;
+
+    @Test
+    public void generate() {
+        List<FieldMeta> fieldMetas = new ArrayList<>();
+        fieldMetas.add(new FieldMeta("ts", "timestamp"));
+        fieldMetas.add(new FieldMeta("temperature", "float"));
+        fieldMetas.add(new FieldMeta("humidity", "int"));
+
+        long start = TimeStampUtil.datetimeToLong("2020-01-01 00:00:00.000");
+        long end = TimeStampUtil.datetimeToLong("2020-01-01 10:00:00.000");
+
+        rowValues = FieldValueGenerator.generate(start, end, 1000l * 3600, fieldMetas);
+        Assert.assertEquals(10, rowValues.size());
+    }
+
+    @Test
+    public void disrupt() {
+        List<FieldMeta> fieldMetas = new ArrayList<>();
+        fieldMetas.add(new FieldMeta("ts", "timestamp"));
+        fieldMetas.add(new FieldMeta("temperature", "float"));
+        fieldMetas.add(new FieldMeta("humidity", "int"));
+
+        long start = TimeStampUtil.datetimeToLong("2020-01-01 00:00:00.000");
+        long end = TimeStampUtil.datetimeToLong("2020-01-01 10:00:00.000");
+
+        rowValues = FieldValueGenerator.generate(start, end, 1000l * 3600l, fieldMetas);
+
+        FieldValueGenerator.disrupt(rowValues, 20, 1000);
+        Assert.assertEquals(10, rowValues.size());
+    }
+
+    @After
+    public void after() {
+        for (RowValue row : rowValues) {
+            row.getFields().stream().forEach(field -> {
+                if (field.getName().equals("ts")) {
+                    System.out.print(TimeStampUtil.longToDatetime((Long) field.getValue()));
+                } else
+                    System.out.print(" ," + field.getValue());
+            });
+            System.out.println();
+        }
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/SubTableMetaGeneratorTest.java

+package com.taosdata.taosdemo.service.data;
+
+import com.taosdata.taosdemo.domain.FieldMeta;
+import com.taosdata.taosdemo.domain.SubTableMeta;
+import com.taosdata.taosdemo.domain.SuperTableMeta;
+import com.taosdata.taosdemo.domain.TagMeta;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SubTableMetaGeneratorTest {
+    List<SubTableMeta> subTableMetas;
+
+    @Test
+    public void generate() {
+        SuperTableMeta superTableMeta = new SuperTableMeta();
+        superTableMeta.setDatabase("test");
+        superTableMeta.setName("weather");
+        List<FieldMeta> fields = new ArrayList<>();
+        fields.add(new FieldMeta("ts", "timestamp"));
+        fields.add(new FieldMeta("temperature", "float"));
+        fields.add(new FieldMeta("humidity", "int"));
+        superTableMeta.setFields(fields);
+        List<TagMeta> tags = new ArrayList<>();
+        tags.add(new TagMeta("location", "nchar(64)"));
+        tags.add(new TagMeta("groupId", "int"));
+        superTableMeta.setTags(tags);
+
+        subTableMetas = SubTableMetaGenerator.generate(superTableMeta, 10, "t");
+        Assert.assertEquals(10, subTableMetas.size());
+        Assert.assertEquals("t1", subTableMetas.get(0).getName());
+        Assert.assertEquals("t2", subTableMetas.get(1).getName());
+        Assert.assertEquals("t3", subTableMetas.get(2).getName());
+        Assert.assertEquals("t4", subTableMetas.get(3).getName());
+        Assert.assertEquals("t5", subTableMetas.get(4).getName());
+        Assert.assertEquals("t6", subTableMetas.get(5).getName());
+        Assert.assertEquals("t7", subTableMetas.get(6).getName());
+        Assert.assertEquals("t8", subTableMetas.get(7).getName());
+        Assert.assertEquals("t9", subTableMetas.get(8).getName());
+        Assert.assertEquals("t10", subTableMetas.get(9).getName());
+    }
+
+    @After
+    public void after() {
+        for (SubTableMeta subTableMeta : subTableMetas) {
+            System.out.println(subTableMeta);
+        }
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/SuperTableMetaGeneratorImplTest.java

+package com.taosdata.taosdemo.service.data;
+
+import com.taosdata.taosdemo.domain.FieldMeta;
+import com.taosdata.taosdemo.domain.SuperTableMeta;
+import com.taosdata.taosdemo.domain.TagMeta;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SuperTableMetaGeneratorImplTest {
+    private SuperTableMeta meta;
+
+    @Test
+    public void generate() {
+        String sql = "create table test.weather (ts timestamp, temperature float, humidity int) tags(location nchar(64), groupId int)";
+        meta = SuperTableMetaGenerator.generate(sql);
+        Assert.assertEquals("test", meta.getDatabase());
+        Assert.assertEquals("weather", meta.getName());
+        Assert.assertEquals(3, meta.getFields().size());
+        Assert.assertEquals("ts", meta.getFields().get(0).getName());
+        Assert.assertEquals("timestamp", meta.getFields().get(0).getType());
+        Assert.assertEquals("temperature", meta.getFields().get(1).getName());
+        Assert.assertEquals("float", meta.getFields().get(1).getType());
+        Assert.assertEquals("humidity", meta.getFields().get(2).getName());
+        Assert.assertEquals("int", meta.getFields().get(2).getType());
+
+        Assert.assertEquals("location", meta.getTags().get(0).getName());
+        Assert.assertEquals("nchar(64)", meta.getTags().get(0).getType());
+        Assert.assertEquals("groupid", meta.getTags().get(1).getName());
+        Assert.assertEquals("int", meta.getTags().get(1).getType());
+    }
+
+    @Test
+    public void generate2() {
+        meta = SuperTableMetaGenerator.generate("test", "weather", 10, "col", 10, "tag");
+        Assert.assertEquals("test", meta.getDatabase());
+        Assert.assertEquals("weather", meta.getName());
+        Assert.assertEquals(11, meta.getFields().size());
+        for (FieldMeta fieldMeta : meta.getFields()) {
+            Assert.assertNotNull(fieldMeta.getName());
+            Assert.assertNotNull(fieldMeta.getType());
+        }
+        for (TagMeta tagMeta : meta.getTags()) {
+            Assert.assertNotNull(tagMeta.getName());
+            Assert.assertNotNull(tagMeta.getType());
+        }
+    }
+
+    @After
+    public void after() {
+        System.out.println(meta.getDatabase());
+        System.out.println(meta.getName());
+        for (FieldMeta fieldMeta : meta.getFields()) {
+            System.out.println(fieldMeta);
+        }
+        for (TagMeta tagMeta : meta.getTags()) {
+            System.out.println(tagMeta);
+        }
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/service/data/TagValueGeneratorTest.java

+package com.taosdata.taosdemo.service.data;
+
+import com.taosdata.taosdemo.domain.TagMeta;
+import com.taosdata.taosdemo.domain.TagValue;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TagValueGeneratorTest {
+    List<TagValue> tagvalues;
+
+    @Test
+    public void generate() {
+        List<TagMeta> tagMetaList = new ArrayList<>();
+        tagMetaList.add(new TagMeta("location", "nchar(10)"));
+        tagMetaList.add(new TagMeta("groupId", "int"));
+        tagMetaList.add(new TagMeta("ts", "timestamp"));
+        tagMetaList.add(new TagMeta("temperature", "float"));
+        tagMetaList.add(new TagMeta("humidity", "double"));
+        tagMetaList.add(new TagMeta("text", "binary(10)"));
+        tagvalues = TagValueGenerator.generate(tagMetaList);
+        Assert.assertEquals("location", tagvalues.get(0).getName());
+        Assert.assertEquals("groupId", tagvalues.get(1).getName());
+        Assert.assertEquals("ts", tagvalues.get(2).getName());
+        Assert.assertEquals("temperature", tagvalues.get(3).getName());
+        Assert.assertEquals("humidity", tagvalues.get(4).getName());
+        Assert.assertEquals("text", tagvalues.get(5).getName());
+    }
+
+    @After
+    public void after() {
+        tagvalues.stream().forEach(System.out::println);
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/utils/DataGeneratorTest.java

+package com.taosdata.taosdemo.utils;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DataGeneratorTest {
+
+    @Test
+    public void randomValue() {
+        for (int i = 0; i < TaosConstants.DATA_TYPES.length; i++) {
+            System.out.println(TaosConstants.DATA_TYPES[i] + " >>> " + DataGenerator.randomValue(TaosConstants.DATA_TYPES[i]));
+        }
+    }
+
+    @Test
+    public void randomNchar() {
+        String s = DataGenerator.randomNchar(10);
+        Assert.assertEquals(10, s.length());
+    }
+}
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/test/java/com/taosdata/taosdemo/utils/TimeStampUtilTest.java

+package com.taosdata.taosdemo.utils;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class TimeStampUtilTest {
+
+    @Test
+    public void datetimeToLong() {
+        final String startTime = "2005-01-01 00:00:00.000";
+        long start = TimeStampUtil.datetimeToLong(startTime);
+        assertEquals(1104508800000l, start);
+        String dateTimeStr = TimeStampUtil.longToDatetime(start);
+        assertEquals("2005-01-01 00:00:00.000", dateTimeStr);
+    }
+
+    @Test
+    public void longToDatetime() {
+        String datetime = TimeStampUtil.longToDatetime(1510000000000L);
+        assertEquals("2017-11-07 04:26:40.000", datetime);
+        long timestamp = TimeStampUtil.datetimeToLong(datetime);
+        assertEquals(1510000000000L, timestamp);
+    }
+
+    @Test
+    public void range() {
+        long start = TimeStampUtil.datetimeToLong("2020-10-01 00:00:00.000");
+        long timeGap = 1000;
+        long numOfRowsPerTable = 1000l * 3600l * 24l * 90l;
+        TimeStampUtil.TimeTuple timeTuple = TimeStampUtil.range(start, timeGap, numOfRowsPerTable);
+        System.out.println(TimeStampUtil.longToDatetime(timeTuple.start));
+        System.out.println(TimeStampUtil.longToDatetime(timeTuple.end));
+        System.out.println(timeTuple.timeGap);
+
+    }
+
+}
\ No newline at end of file