From ff1a186134e0d5ae1f5c7227c06fd32930ab246b Mon Sep 17 00:00:00 2001 From: vran Date: Wed, 6 Apr 2022 18:19:07 +0800 Subject: [PATCH] feat:support generate mock sql --- .../com/databasir/api/DocumentController.java | 10 +- .../com/databasir/api/MockDataController.java | 49 ++ .../main/java/com/databasir/api/Routes.java | 12 + build.gradle | 2 +- core/build.gradle | 1 + .../databasir/core/domain/DomainErrors.java | 8 + .../converter/TableResponseConverter.java | 25 + .../DocumentTemplatePropertiesResponse.java | 4 + .../domain/document/data/TableResponse.java | 27 + .../document/service/DocumentService.java | 31 +- .../core/domain/mock/MockDataService.java | 96 ++++ .../converter/MockDataRulePojoConverter.java | 20 + .../MockDataRuleResponseConverter.java | 19 + .../mock/data/ColumnMockRuleSaveRequest.java | 27 + .../mock/data/MockDataGenerateCondition.java | 11 + .../mock/data/MockDataRuleListCondition.java | 11 + .../mock/data/MockDataRuleResponse.java | 23 + .../mock/factory/AutoMockDataFactory.java | 74 +++ .../mock/factory/FakerMockDataFactory.java | 48 ++ .../domain/mock/factory/MockColumnRule.java | 36 ++ .../domain/mock/factory/MockDataFactory.java | 9 + .../mock/factory/ScriptMockDataFactory.java | 26 + .../domain/mock/generator/ColumnMockData.java | 16 + .../mock/generator/MockDataContext.java | 173 +++++++ .../mock/generator/MockDataGenerator.java | 129 +++++ .../domain/mock/generator/TableMockData.java | 34 ++ .../mock/script/MockScriptEvaluator.java | 14 + .../mock/script/SpelScriptEvaluator.java | 21 + .../mock/validator/MockDataSaveValidator.java | 127 +++++ .../mock/validator/MockDataValidator.java | 52 ++ .../mock/service/MockDataServiceTest.java | 24 + dao/build.gradle | 6 + .../java/com/databasir/dao/Databasir.java | 7 + .../main/java/com/databasir/dao/Keys.java | 4 + .../main/java/com/databasir/dao/Tables.java | 6 + .../databasir/dao/tables/MockDataRule.java | 191 +++++++ .../dao/tables/TableColumnDocument.java | 13 +- .../dao/tables/pojos/MockDataRulePojo.java | 229 +++++++++ .../tables/pojos/TableColumnDocumentPojo.java | 19 + .../tables/records/MockDataRuleRecord.java | 464 ++++++++++++++++++ .../records/TableColumnDocumentRecord.java | 154 +++--- .../dao/converter/MockDataTypeConverter.java | 12 + .../com/databasir/dao/enums/MockDataType.java | 25 + .../databasir/dao/impl/MockDataRuleDao.java | 61 +++ .../dao/impl/TableColumnDocumentDao.java | 13 + .../databasir/dao/impl/TableDocumentDao.java | 26 +- .../db/migration/V1.2__mock_data.sql | 18 + .../databasir/core/meta/data/ColumnMeta.java | 2 + .../impl/jdbc/JdbcColumnMetaRepository.java | 3 +- 49 files changed, 2330 insertions(+), 82 deletions(-) create mode 100644 api/src/main/java/com/databasir/api/MockDataController.java create mode 100644 core/src/main/java/com/databasir/core/domain/document/converter/TableResponseConverter.java create mode 100644 core/src/main/java/com/databasir/core/domain/document/data/TableResponse.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/MockDataService.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/converter/MockDataRulePojoConverter.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/converter/MockDataRuleResponseConverter.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/data/ColumnMockRuleSaveRequest.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/data/MockDataGenerateCondition.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/data/MockDataRuleListCondition.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/data/MockDataRuleResponse.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/factory/AutoMockDataFactory.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/factory/FakerMockDataFactory.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/factory/MockColumnRule.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/factory/MockDataFactory.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/factory/ScriptMockDataFactory.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/generator/ColumnMockData.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/generator/MockDataContext.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/generator/MockDataGenerator.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/generator/TableMockData.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/script/MockScriptEvaluator.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/script/SpelScriptEvaluator.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/validator/MockDataSaveValidator.java create mode 100644 core/src/main/java/com/databasir/core/domain/mock/validator/MockDataValidator.java create mode 100644 core/src/test/java/com/databasir/core/domain/mock/service/MockDataServiceTest.java create mode 100644 dao/generated-src/jooq/main/java/com/databasir/dao/tables/MockDataRule.java create mode 100644 dao/generated-src/jooq/main/java/com/databasir/dao/tables/pojos/MockDataRulePojo.java create mode 100644 dao/generated-src/jooq/main/java/com/databasir/dao/tables/records/MockDataRuleRecord.java create mode 100644 dao/src/main/java/com/databasir/dao/converter/MockDataTypeConverter.java create mode 100644 dao/src/main/java/com/databasir/dao/enums/MockDataType.java create mode 100644 dao/src/main/java/com/databasir/dao/impl/MockDataRuleDao.java create mode 100644 dao/src/main/resources/db/migration/V1.2__mock_data.sql diff --git a/api/src/main/java/com/databasir/api/DocumentController.java b/api/src/main/java/com/databasir/api/DocumentController.java index a050d39..c3d24fd 100644 --- a/api/src/main/java/com/databasir/api/DocumentController.java +++ b/api/src/main/java/com/databasir/api/DocumentController.java @@ -2,10 +2,7 @@ package com.databasir.api; import com.databasir.common.JsonData; import com.databasir.core.diff.data.RootDiff; -import com.databasir.core.domain.document.data.DatabaseDocumentResponse; -import com.databasir.core.domain.document.data.DatabaseDocumentSimpleResponse; -import com.databasir.core.domain.document.data.DatabaseDocumentVersionResponse; -import com.databasir.core.domain.document.data.TableDocumentResponse; +import com.databasir.core.domain.document.data.*; import com.databasir.core.domain.document.generator.DocumentFileType; import com.databasir.core.domain.document.service.DocumentService; import com.databasir.core.domain.log.annotation.Operation; @@ -94,4 +91,9 @@ public class DocumentController { return JsonData.ok(documentService.getTableDetails(projectId, documentId, tableIds)); } + @GetMapping(Routes.Document.LIST_TABLES) + public JsonData> listTables(@PathVariable Integer projectId, + @RequestParam(required = false) Long version) { + return JsonData.ok(documentService.getTableAndColumns(projectId, version)); + } } diff --git a/api/src/main/java/com/databasir/api/MockDataController.java b/api/src/main/java/com/databasir/api/MockDataController.java new file mode 100644 index 0000000..ac395fe --- /dev/null +++ b/api/src/main/java/com/databasir/api/MockDataController.java @@ -0,0 +1,49 @@ +package com.databasir.api; + +import com.databasir.common.JsonData; +import com.databasir.core.domain.mock.MockDataService; +import com.databasir.core.domain.mock.data.ColumnMockRuleSaveRequest; +import com.databasir.core.domain.mock.data.MockDataGenerateCondition; +import com.databasir.core.domain.mock.data.MockDataRuleListCondition; +import com.databasir.core.domain.mock.data.MockDataRuleResponse; +import lombok.RequiredArgsConstructor; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import javax.validation.Valid; +import java.util.List; + +@RestController +@RequiredArgsConstructor +@Validated +public class MockDataController { + + private final MockDataService mockDataService; + + @GetMapping(Routes.MockData.GET_SQL_MOCK_DATA) + public JsonData getMockSql(@PathVariable("groupId") Integer groupId, + @PathVariable("projectId") Integer projectId, + @Valid MockDataGenerateCondition condition) { + String sql = mockDataService.generateMockInsertSql(projectId, condition); + return JsonData.ok(sql); + } + + @GetMapping(Routes.MockData.GET_MOCK_RULE) + public JsonData> getMockRules(@PathVariable("groupId") Integer groupId, + @PathVariable("projectId") Integer projectId, + @Valid MockDataRuleListCondition condition) { + List rules = mockDataService.listRules(projectId, condition); + return JsonData.ok(rules); + } + + @PostMapping(Routes.MockData.SAVE_MOCK_RULE) + @PreAuthorize("hasAnyAuthority('SYS_OWNER', 'GROUP_OWNER?groupId='+#groupId, 'GROUP_MEMBER?groupId='+#groupId)") + public JsonData saveMockRules(@PathVariable Integer groupId, + @PathVariable Integer projectId, + @PathVariable Integer tableId, + @RequestBody @Valid List rules) { + mockDataService.saveMockRules(projectId, tableId, rules); + return JsonData.ok(); + } +} diff --git a/api/src/main/java/com/databasir/api/Routes.java b/api/src/main/java/com/databasir/api/Routes.java index 3e62988..4aaa5ef 100644 --- a/api/src/main/java/com/databasir/api/Routes.java +++ b/api/src/main/java/com/databasir/api/Routes.java @@ -85,6 +85,8 @@ public interface Routes { String DIFF = BASE + "/projects/{projectId}/diff_documents"; String EXPORT = BASE + "/projects/{projectId}/document_files"; + + String LIST_TABLES = BASE + "/projects/{projectId}/tables"; } interface DocumentDiscussion { @@ -160,4 +162,14 @@ public interface Routes { String CREATE = BASE + "/database_types"; } + + interface MockData { + + String SAVE_MOCK_RULE = BASE + "/groups/{groupId}/projects/{projectId}/tables/{tableId}/mock_rules"; + + String GET_MOCK_RULE = BASE + "/groups/{groupId}/projects/{projectId}/mock_rules"; + + String GET_SQL_MOCK_DATA = BASE + "/groups/{groupId}/projects/{projectId}/mock_data/sql"; + + } } \ No newline at end of file diff --git a/build.gradle b/build.gradle index b1b8e4e..2686784 100644 --- a/build.gradle +++ b/build.gradle @@ -2,7 +2,7 @@ plugins { id 'java' id 'idea' id 'io.spring.dependency-management' version '1.0.11.RELEASE' - id 'org.springframework.boot' version '2.5.8' apply false + id 'org.springframework.boot' version '2.5.11' apply false id 'nu.studer.jooq' version '6.0.1' apply false } diff --git a/core/build.gradle b/core/build.gradle index 7c3a4b6..21ee76f 100644 --- a/core/build.gradle +++ b/core/build.gradle @@ -29,6 +29,7 @@ dependencies { // others implementation 'com.auth0:java-jwt:3.18.3' implementation 'org.commonmark:commonmark:0.18.1' + implementation 'com.github.javafaker:javafaker:1.0.2' implementation 'com.alibaba:easyexcel' implementation "org.freemarker:freemarker" diff --git a/core/src/main/java/com/databasir/core/domain/DomainErrors.java b/core/src/main/java/com/databasir/core/domain/DomainErrors.java index e41efaa..1ce7c88 100644 --- a/core/src/main/java/com/databasir/core/domain/DomainErrors.java +++ b/core/src/main/java/com/databasir/core/domain/DomainErrors.java @@ -34,6 +34,14 @@ public enum DomainErrors implements DatabasirErrors { INVALID_DATABASE_TYPE_URL_PATTERN("A_10019", "不合法的 url pattern"), DOCUMENT_VERSION_IS_INVALID("A_10020", "文档版本不合法"), CANNOT_UPDATE_SELF_ENABLED_STATUS("A_10021", "无法对自己执行启用禁用操作"), + MOCK_DATA_SCRIPT_MUST_NOT_BE_BLANK("A_10022", "脚本内容不能为空"), + TABLE_META_NOT_FOUND("A_10023", "不存在的数据库表"), + DEPENDENT_COLUMN_NAME_MUST_NOT_BE_BLANK("A_10024", "必须指定依赖的字段"), + DEPENDENT_REF_MUST_NOT_BE_BLANK("A_10025", "请选择关联表和字段"), + MUST_NOT_REF_SELF("A_10026", "不能引用自身"), + CIRCLE_REFERENCE("A_10027", "检查到循环引用"), + DUPLICATE_COLUMN("A_10028", "重复的列"), + INVALID_MOCK_DATA_SCRIPT("A_10029", "不合法的表达式"), ; private final String errCode; diff --git a/core/src/main/java/com/databasir/core/domain/document/converter/TableResponseConverter.java b/core/src/main/java/com/databasir/core/domain/document/converter/TableResponseConverter.java new file mode 100644 index 0000000..553e3dc --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/document/converter/TableResponseConverter.java @@ -0,0 +1,25 @@ +package com.databasir.core.domain.document.converter; + +import com.databasir.core.domain.document.data.TableResponse; +import com.databasir.dao.tables.pojos.TableColumnDocumentPojo; +import com.databasir.dao.tables.pojos.TableDocumentPojo; +import org.mapstruct.Mapper; + +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +@Mapper(componentModel = "spring") +public interface TableResponseConverter { + + default List from(List tables, + Map> columnMapByTableId) { + return tables.stream() + .map(table -> from(table, columnMapByTableId.get(table.getId()))) + .collect(Collectors.toList()); + } + + TableResponse from(TableDocumentPojo table, List columns); + + TableResponse.ColumnResponse from(TableColumnDocumentPojo column); +} diff --git a/core/src/main/java/com/databasir/core/domain/document/data/DocumentTemplatePropertiesResponse.java b/core/src/main/java/com/databasir/core/domain/document/data/DocumentTemplatePropertiesResponse.java index 6be6521..49073d5 100644 --- a/core/src/main/java/com/databasir/core/domain/document/data/DocumentTemplatePropertiesResponse.java +++ b/core/src/main/java/com/databasir/core/domain/document/data/DocumentTemplatePropertiesResponse.java @@ -16,12 +16,16 @@ import java.util.List; @AllArgsConstructor public class DocumentTemplatePropertiesResponse { + @Builder.Default private List columnFieldNameProperties = Collections.emptyList(); + @Builder.Default private List indexFieldNameProperties = Collections.emptyList(); + @Builder.Default private List triggerFieldNameProperties = Collections.emptyList(); + @Builder.Default private List foreignKeyFieldNameProperties = Collections.emptyList(); @Data diff --git a/core/src/main/java/com/databasir/core/domain/document/data/TableResponse.java b/core/src/main/java/com/databasir/core/domain/document/data/TableResponse.java new file mode 100644 index 0000000..107464d --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/document/data/TableResponse.java @@ -0,0 +1,27 @@ +package com.databasir.core.domain.document.data; + +import lombok.Data; + +import java.util.Collections; +import java.util.List; + +@Data +public class TableResponse { + + private Integer id; + + private String name; + + private List columns = Collections.emptyList(); + + @Data + public static class ColumnResponse { + + private Integer id; + + private String name; + + private String type; + + } +} diff --git a/core/src/main/java/com/databasir/core/domain/document/service/DocumentService.java b/core/src/main/java/com/databasir/core/domain/document/service/DocumentService.java index 2021a36..4013b9f 100644 --- a/core/src/main/java/com/databasir/core/domain/document/service/DocumentService.java +++ b/core/src/main/java/com/databasir/core/domain/document/service/DocumentService.java @@ -6,14 +6,8 @@ import com.databasir.core.diff.Diffs; import com.databasir.core.diff.data.DiffType; import com.databasir.core.diff.data.RootDiff; import com.databasir.core.domain.DomainErrors; -import com.databasir.core.domain.document.converter.DatabaseMetaConverter; -import com.databasir.core.domain.document.converter.DocumentPojoConverter; -import com.databasir.core.domain.document.converter.DocumentResponseConverter; -import com.databasir.core.domain.document.converter.DocumentSimpleResponseConverter; -import com.databasir.core.domain.document.data.DatabaseDocumentResponse; -import com.databasir.core.domain.document.data.DatabaseDocumentSimpleResponse; -import com.databasir.core.domain.document.data.DatabaseDocumentVersionResponse; -import com.databasir.core.domain.document.data.TableDocumentResponse; +import com.databasir.core.domain.document.converter.*; +import com.databasir.core.domain.document.data.*; import com.databasir.core.domain.document.event.DocumentUpdated; import com.databasir.core.domain.document.generator.DocumentFileGenerator; import com.databasir.core.domain.document.generator.DocumentFileType; @@ -82,6 +76,8 @@ public class DocumentService { private final DatabaseMetaConverter databaseMetaConverter; + private final TableResponseConverter tableResponseConverter; + private final JsonConverter jsonConverter; private final List documentFileGenerators; @@ -373,4 +369,23 @@ public class DocumentService { DatabaseMeta originalMeta = retrieveOriginalDatabaseMeta(original); return Diffs.diff(originalMeta, currMeta); } + + public List getTableAndColumns(Integer projectId, Long version) { + Optional documentOption; + if (version == null) { + documentOption = databaseDocumentDao.selectNotArchivedByProjectId(projectId); + } else { + documentOption = databaseDocumentDao.selectOptionalByProjectIdAndVersion(projectId, version); + } + if (documentOption.isEmpty()) { + return Collections.emptyList(); + } else { + DatabaseDocumentPojo databaseDoc = documentOption.get(); + var tables = tableDocumentDao.selectByDatabaseDocumentId(databaseDoc.getId()); + var columns = tableColumnDocumentDao.selectByDatabaseDocumentId(databaseDoc.getId()); + var columnMapByTableId = columns.stream() + .collect(Collectors.groupingBy(TableColumnDocumentPojo::getTableDocumentId)); + return tableResponseConverter.from(tables, columnMapByTableId); + } + } } diff --git a/core/src/main/java/com/databasir/core/domain/mock/MockDataService.java b/core/src/main/java/com/databasir/core/domain/mock/MockDataService.java new file mode 100644 index 0000000..37d0a08 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/MockDataService.java @@ -0,0 +1,96 @@ +package com.databasir.core.domain.mock; + +import com.databasir.core.domain.mock.converter.MockDataRulePojoConverter; +import com.databasir.core.domain.mock.converter.MockDataRuleResponseConverter; +import com.databasir.core.domain.mock.data.ColumnMockRuleSaveRequest; +import com.databasir.core.domain.mock.data.MockDataGenerateCondition; +import com.databasir.core.domain.mock.data.MockDataRuleListCondition; +import com.databasir.core.domain.mock.data.MockDataRuleResponse; +import com.databasir.core.domain.mock.generator.MockDataGenerator; +import com.databasir.core.domain.mock.validator.MockDataSaveValidator; +import com.databasir.core.domain.mock.validator.MockDataValidator; +import com.databasir.dao.enums.MockDataType; +import com.databasir.dao.impl.MockDataRuleDao; +import com.databasir.dao.impl.TableColumnDocumentDao; +import com.databasir.dao.tables.pojos.DatabaseDocumentPojo; +import com.databasir.dao.tables.pojos.MockDataRulePojo; +import com.databasir.dao.tables.pojos.TableColumnDocumentPojo; +import com.databasir.dao.tables.pojos.TableDocumentPojo; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.function.Function; +import java.util.stream.Collectors; + +@Service +@RequiredArgsConstructor +public class MockDataService { + + private final MockDataGenerator mockDataGenerator; + + private final MockDataRuleDao mockDataRuleDao; + + private final TableColumnDocumentDao tableColumnDocumentDao; + + private final MockDataRulePojoConverter mockDataRulePojoConverter; + + private final MockDataRuleResponseConverter mockDataRuleResponseConverter; + + private final MockDataSaveValidator mockDataSaveValidator; + + private final MockDataValidator mockDataValidator; + + public String generateMockInsertSql(Integer projectId, MockDataGenerateCondition condition) { + mockDataValidator.validProject(projectId); + DatabaseDocumentPojo databaseDoc = + mockDataValidator.validAndGetDatabaseDocumentPojo(projectId, condition.getVersion()); + TableDocumentPojo tableDoc = + mockDataValidator.validAndGetTableDocumentPojo(databaseDoc.getId(), condition.getTableId()); + return mockDataGenerator.createInsertSql(projectId, databaseDoc.getId(), tableDoc.getName()); + } + + public void saveMockRules(Integer projectId, + Integer tableId, + List rules) { + mockDataValidator.validProject(projectId); + DatabaseDocumentPojo doc = + mockDataValidator.validAndGetDatabaseDocumentPojo(projectId, null); + TableDocumentPojo tableDoc = + mockDataValidator.validAndGetTableDocumentPojo(doc.getId(), tableId); + List columnNames = rules.stream() + .map(ColumnMockRuleSaveRequest::getColumnName) + .collect(Collectors.toList()); + mockDataSaveValidator.validTableColumn(tableDoc.getId(), columnNames); + mockDataSaveValidator.validScriptMockType(rules); + mockDataSaveValidator.validRefMockType(doc.getId(), rules); + // verify + mockDataGenerator.createInsertSql(projectId, doc.getId(), tableDoc.getName()); + + List pojo = mockDataRulePojoConverter.from(projectId, rules); + mockDataRuleDao.batchSave(pojo); + } + + public List listRules(Integer projectId, MockDataRuleListCondition condition) { + mockDataValidator.validProject(projectId); + DatabaseDocumentPojo databaseDoc = + mockDataValidator.validAndGetDatabaseDocumentPojo(projectId, condition.getVersion()); + TableDocumentPojo tableDoc = + mockDataValidator.validAndGetTableDocumentPojo(databaseDoc.getId(), condition.getTableId()); + List columns = + tableColumnDocumentDao.selectByTableDocumentId(condition.getTableId()); + var ruleMapByColumnName = mockDataRuleDao.selectByProjectIdAndTableName(projectId, tableDoc.getName()) + .stream() + .collect(Collectors.toMap(MockDataRulePojo::getColumnName, Function.identity())); + return columns.stream() + .map(col -> { + if (ruleMapByColumnName.containsKey(col.getName())) { + return mockDataRuleResponseConverter.from(ruleMapByColumnName.get(col.getName()), col); + } else { + return mockDataRuleResponseConverter.from(tableDoc.getName(), MockDataType.AUTO, col); + } + }) + .collect(Collectors.toList()); + } + +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/converter/MockDataRulePojoConverter.java b/core/src/main/java/com/databasir/core/domain/mock/converter/MockDataRulePojoConverter.java new file mode 100644 index 0000000..c898f8e --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/converter/MockDataRulePojoConverter.java @@ -0,0 +1,20 @@ +package com.databasir.core.domain.mock.converter; + +import com.databasir.core.domain.mock.data.ColumnMockRuleSaveRequest; +import com.databasir.dao.tables.pojos.MockDataRulePojo; +import org.mapstruct.Mapper; + +import java.util.List; +import java.util.stream.Collectors; + +@Mapper(componentModel = "spring") +public interface MockDataRulePojoConverter { + + MockDataRulePojo from(Integer projectId, ColumnMockRuleSaveRequest request); + + default List from(Integer projectId, List request) { + return request.stream() + .map(rule -> from(projectId, rule)) + .collect(Collectors.toList()); + } +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/converter/MockDataRuleResponseConverter.java b/core/src/main/java/com/databasir/core/domain/mock/converter/MockDataRuleResponseConverter.java new file mode 100644 index 0000000..577f9ff --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/converter/MockDataRuleResponseConverter.java @@ -0,0 +1,19 @@ +package com.databasir.core.domain.mock.converter; + +import com.databasir.core.domain.mock.data.MockDataRuleResponse; +import com.databasir.dao.enums.MockDataType; +import com.databasir.dao.tables.pojos.MockDataRulePojo; +import com.databasir.dao.tables.pojos.TableColumnDocumentPojo; +import org.mapstruct.Mapper; +import org.mapstruct.Mapping; + +@Mapper(componentModel = "spring") +public interface MockDataRuleResponseConverter { + + @Mapping(target = "columnType", source = "column.type") + MockDataRuleResponse from(MockDataRulePojo pojo, TableColumnDocumentPojo column); + + @Mapping(target = "columnName", source = "pojo.name") + @Mapping(target = "columnType", source = "pojo.type") + MockDataRuleResponse from(String tableName, MockDataType mockDataType, TableColumnDocumentPojo pojo); +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/data/ColumnMockRuleSaveRequest.java b/core/src/main/java/com/databasir/core/domain/mock/data/ColumnMockRuleSaveRequest.java new file mode 100644 index 0000000..cad5e9e --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/data/ColumnMockRuleSaveRequest.java @@ -0,0 +1,27 @@ +package com.databasir.core.domain.mock.data; + +import com.databasir.dao.enums.MockDataType; +import lombok.Data; + +import javax.validation.constraints.NotBlank; +import javax.validation.constraints.NotNull; + +@Data +public class ColumnMockRuleSaveRequest { + + @NotBlank + private String tableName; + + @NotBlank + private String columnName; + + private String dependentTableName; + + private String dependentColumnName; + + @NotNull + private MockDataType mockDataType; + + private String mockDataScript; + +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/data/MockDataGenerateCondition.java b/core/src/main/java/com/databasir/core/domain/mock/data/MockDataGenerateCondition.java new file mode 100644 index 0000000..2f81b09 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/data/MockDataGenerateCondition.java @@ -0,0 +1,11 @@ +package com.databasir.core.domain.mock.data; + +import lombok.Data; + +@Data +public class MockDataGenerateCondition { + + private Long version; + + private Integer tableId; +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/data/MockDataRuleListCondition.java b/core/src/main/java/com/databasir/core/domain/mock/data/MockDataRuleListCondition.java new file mode 100644 index 0000000..b7d61e2 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/data/MockDataRuleListCondition.java @@ -0,0 +1,11 @@ +package com.databasir.core.domain.mock.data; + +import lombok.Data; + +@Data +public class MockDataRuleListCondition { + + private Long version; + + private Integer tableId; +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/data/MockDataRuleResponse.java b/core/src/main/java/com/databasir/core/domain/mock/data/MockDataRuleResponse.java new file mode 100644 index 0000000..7fdf7e2 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/data/MockDataRuleResponse.java @@ -0,0 +1,23 @@ +package com.databasir.core.domain.mock.data; + +import com.databasir.dao.enums.MockDataType; +import lombok.Data; + +@Data +public class MockDataRuleResponse { + + private String tableName; + + private String columnName; + + private String columnType; + + private String dependentTableName; + + private String dependentColumnName; + + private MockDataType mockDataType; + + private String mockDataScript; + +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/factory/AutoMockDataFactory.java b/core/src/main/java/com/databasir/core/domain/mock/factory/AutoMockDataFactory.java new file mode 100644 index 0000000..19521b0 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/factory/AutoMockDataFactory.java @@ -0,0 +1,74 @@ +package com.databasir.core.domain.mock.factory; + +import com.databasir.dao.enums.MockDataType; +import com.databasir.dao.impl.TableColumnDocumentDao; +import lombok.RequiredArgsConstructor; +import org.springframework.core.annotation.Order; +import org.springframework.stereotype.Component; + +import java.sql.Types; +import java.util.HashMap; +import java.util.Map; + +@Component +@Order +@RequiredArgsConstructor +public class AutoMockDataFactory implements MockDataFactory { + + private final TableColumnDocumentDao tableColumnDocumentDao; + + public static final Map DATA_TYPE_VALUE_MAP = new HashMap<>(); + + static { + DATA_TYPE_VALUE_MAP.put(9999, "''"); + DATA_TYPE_VALUE_MAP.put(Types.BIT, "1"); + DATA_TYPE_VALUE_MAP.put(Types.TINYINT, "1"); + DATA_TYPE_VALUE_MAP.put(Types.SMALLINT, "1"); + DATA_TYPE_VALUE_MAP.put(Types.INTEGER, "1"); + DATA_TYPE_VALUE_MAP.put(Types.BIGINT, "1"); + DATA_TYPE_VALUE_MAP.put(Types.FLOAT, "1.1"); + DATA_TYPE_VALUE_MAP.put(Types.REAL, "''"); + DATA_TYPE_VALUE_MAP.put(Types.DOUBLE, "1.2"); + DATA_TYPE_VALUE_MAP.put(Types.NUMERIC, "1"); + DATA_TYPE_VALUE_MAP.put(Types.DECIMAL, "1.1"); + DATA_TYPE_VALUE_MAP.put(Types.CHAR, "''"); + DATA_TYPE_VALUE_MAP.put(Types.VARCHAR, "''"); + DATA_TYPE_VALUE_MAP.put(Types.LONGVARCHAR, "''"); + DATA_TYPE_VALUE_MAP.put(Types.DATE, "'1970-12-31'"); + DATA_TYPE_VALUE_MAP.put(Types.TIME, "'00:00:00'"); + DATA_TYPE_VALUE_MAP.put(Types.TIMESTAMP, "'2001-01-01 00:00:00'"); + DATA_TYPE_VALUE_MAP.put(Types.BINARY, "''"); + DATA_TYPE_VALUE_MAP.put(Types.VARBINARY, "''"); + DATA_TYPE_VALUE_MAP.put(Types.LONGVARBINARY, "''"); + DATA_TYPE_VALUE_MAP.put(Types.NULL, "null"); + DATA_TYPE_VALUE_MAP.put(Types.OTHER, "''"); + DATA_TYPE_VALUE_MAP.put(Types.JAVA_OBJECT, "''"); + DATA_TYPE_VALUE_MAP.put(Types.DISTINCT, "''"); + DATA_TYPE_VALUE_MAP.put(Types.STRUCT, "''"); + DATA_TYPE_VALUE_MAP.put(Types.ARRAY, "'{}'"); + DATA_TYPE_VALUE_MAP.put(Types.BLOB, "''"); + DATA_TYPE_VALUE_MAP.put(Types.CLOB, "''"); + DATA_TYPE_VALUE_MAP.put(Types.REF, "''"); + DATA_TYPE_VALUE_MAP.put(Types.DATALINK, "''"); + DATA_TYPE_VALUE_MAP.put(Types.BOOLEAN, "true"); + DATA_TYPE_VALUE_MAP.put(Types.ROWID, "''"); + DATA_TYPE_VALUE_MAP.put(Types.NCHAR, "''"); + DATA_TYPE_VALUE_MAP.put(Types.NVARCHAR, "''"); + DATA_TYPE_VALUE_MAP.put(Types.LONGNVARCHAR, "''"); + DATA_TYPE_VALUE_MAP.put(Types.NCLOB, "''"); + DATA_TYPE_VALUE_MAP.put(Types.SQLXML, "''"); + DATA_TYPE_VALUE_MAP.put(Types.REF_CURSOR, "''"); + DATA_TYPE_VALUE_MAP.put(Types.TIME_WITH_TIMEZONE, "''"); + DATA_TYPE_VALUE_MAP.put(Types.TIMESTAMP_WITH_TIMEZONE, "''"); + } + + @Override + public boolean accept(MockColumnRule rule) { + return rule == null || rule.getMockDataType() == MockDataType.AUTO; + } + + @Override + public String create(MockColumnRule rule) { + return DATA_TYPE_VALUE_MAP.getOrDefault(rule.getDataType(), "''"); + } +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/factory/FakerMockDataFactory.java b/core/src/main/java/com/databasir/core/domain/mock/factory/FakerMockDataFactory.java new file mode 100644 index 0000000..089c7a1 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/factory/FakerMockDataFactory.java @@ -0,0 +1,48 @@ +package com.databasir.core.domain.mock.factory; + +import com.databasir.dao.enums.MockDataType; +import com.github.javafaker.Faker; +import org.springframework.core.annotation.Order; +import org.springframework.stereotype.Component; + +import java.util.StringJoiner; +import java.util.UUID; + +@Component +@Order(0) +public class FakerMockDataFactory implements MockDataFactory { + + @Override + public boolean accept(MockColumnRule rule) { + return MockDataType.fakerTypes().contains(rule.getMockDataType()); + } + + @Override + public String create(MockColumnRule rule) { + Faker faker = new Faker(); + StringJoiner joiner = new StringJoiner("", "'", "'"); + switch (rule.getMockDataType()) { + case FULL_NAME: + joiner.add(faker.name().username()); + return joiner.toString(); + case PHONE: + joiner.add(faker.phoneNumber().cellPhone()); + return joiner.toString(); + case FULL_ADDRESS: + joiner.add(faker.address().fullAddress()); + return joiner.toString(); + case AVATAR_URL: + joiner.add(faker.avatar().image()); + return joiner.toString(); + case UUID: + joiner.add(UUID.randomUUID().toString()); + return joiner.toString(); + case EMAIL: + joiner.add(faker.name().username() + "@generated" + UUID.randomUUID().toString() + .replace("-", "").toString()); + return joiner.toString(); + default: + return "''"; + } + } +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/factory/MockColumnRule.java b/core/src/main/java/com/databasir/core/domain/mock/factory/MockColumnRule.java new file mode 100644 index 0000000..2341c83 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/factory/MockColumnRule.java @@ -0,0 +1,36 @@ +package com.databasir.core.domain.mock.factory; + +import com.databasir.dao.enums.MockDataType; +import lombok.Builder; +import lombok.Getter; + +import java.util.Optional; + +@Getter +@Builder +public class MockColumnRule { + + private String tableName; + + private String columnName; + + private String columnType; + + private Integer dataType; + + private MockDataType mockDataType; + + private String mockDataScript; + + public static MockColumnRule auto(String tableName, String columnName) { + return MockColumnRule.builder() + .tableName(tableName) + .columnName(columnName) + .mockDataType(MockDataType.AUTO) + .build(); + } + + public Optional getMockDataScript() { + return Optional.ofNullable(mockDataScript); + } +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/factory/MockDataFactory.java b/core/src/main/java/com/databasir/core/domain/mock/factory/MockDataFactory.java new file mode 100644 index 0000000..9b00410 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/factory/MockDataFactory.java @@ -0,0 +1,9 @@ +package com.databasir.core.domain.mock.factory; + +public interface MockDataFactory { + + boolean accept(MockColumnRule rule); + + String create(MockColumnRule rule); + +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/factory/ScriptMockDataFactory.java b/core/src/main/java/com/databasir/core/domain/mock/factory/ScriptMockDataFactory.java new file mode 100644 index 0000000..a0399c3 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/factory/ScriptMockDataFactory.java @@ -0,0 +1,26 @@ +package com.databasir.core.domain.mock.factory; + +import com.databasir.core.domain.mock.script.MockScriptEvaluator; +import com.databasir.dao.enums.MockDataType; +import lombok.RequiredArgsConstructor; +import org.springframework.core.annotation.Order; +import org.springframework.stereotype.Component; + +@Component +@Order(0) +@RequiredArgsConstructor +public class ScriptMockDataFactory implements MockDataFactory { + + private final MockScriptEvaluator mockScriptEvaluator; + + @Override + public boolean accept(MockColumnRule rule) { + return rule.getMockDataType() == MockDataType.SCRIPT; + } + + @Override + public String create(MockColumnRule rule) { + return mockScriptEvaluator.evaluate(rule.getMockDataScript().get(), new MockScriptEvaluator.ScriptContext()); + } + +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/generator/ColumnMockData.java b/core/src/main/java/com/databasir/core/domain/mock/generator/ColumnMockData.java new file mode 100644 index 0000000..d846947 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/generator/ColumnMockData.java @@ -0,0 +1,16 @@ +package com.databasir.core.domain.mock.generator; + +import lombok.Builder; +import lombok.Getter; + +@Getter +@Builder +public class ColumnMockData { + + private String columnName; + + private String columnType; + + private String mockData; + +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/generator/MockDataContext.java b/core/src/main/java/com/databasir/core/domain/mock/generator/MockDataContext.java new file mode 100644 index 0000000..6f6daaa --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/generator/MockDataContext.java @@ -0,0 +1,173 @@ +package com.databasir.core.domain.mock.generator; + +import com.databasir.core.domain.DomainErrors; +import com.databasir.dao.exception.DataNotExistsException; +import com.databasir.dao.tables.pojos.MockDataRulePojo; +import com.databasir.dao.tables.pojos.TableColumnDocumentPojo; +import lombok.Builder; +import lombok.Getter; + +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; + +@Getter +@Builder +public class MockDataContext { + + private Integer projectId; + + private Integer databaseDocumentId; + + @Builder.Default + private Map tableMockDataMap = new LinkedHashMap<>(); + + @Builder.Default + private Map> fromReference = new LinkedHashMap<>(); + + @Builder.Default + private Map> toReference = new LinkedHashMap<>(); + + @Builder.Default + private Map> ruleMap = new LinkedHashMap<>(16); + + @Builder.Default + private Map> tableColumnMap = new LinkedHashMap<>(16); + + @Builder.Default + private Map> mockInProgress = new HashMap<>(); + + public void addTableMockRules(String tableName, List rules) { + var columnRuleMap = rules.stream() + .collect(Collectors.toMap(MockDataRulePojo::getColumnName, Function.identity())); + this.ruleMap.put(tableName, columnRuleMap); + } + + public boolean containMockRule(String tableName) { + return ruleMap.containsKey(tableName); + } + + public boolean containMockRule(String tableName, String columnName) { + if (!ruleMap.containsKey(tableName)) { + return false; + } + return ruleMap.get(tableName).containsKey(columnName); + } + + public Optional getMockRule(String tableName, String columnName) { + if (!ruleMap.containsKey(tableName)) { + return Optional.empty(); + } + return Optional.ofNullable(ruleMap.get(tableName).get(columnName)); + } + + public void addTableColumns(String tableName, List columns) { + Map columnMap = new LinkedHashMap<>(); + for (TableColumnDocumentPojo column : columns) { + columnMap.put(column.getName(), column); + } + this.tableColumnMap.put(tableName, columnMap); + } + + public boolean containsTable(String tableName) { + return tableColumnMap.containsKey(tableName); + } + + public boolean containsTableColumn(String tableName, String columnName) { + if (!tableColumnMap.containsKey(tableName)) { + return false; + } + return tableColumnMap.get(tableName).containsKey(columnName); + } + + public TableColumnDocumentPojo getTableColumn(String tableName, String columnName) { + if (!tableColumnMap.containsKey(tableName)) { + return null; + } + return tableColumnMap.get(tableName).get(columnName); + } + + public boolean containsTableMockData(String tableName) { + return tableMockDataMap.containsKey(tableName); + } + + public boolean containsColumnMockData(String tableName, String columName) { + return tableMockDataMap.containsKey(tableName) && tableMockDataMap.get(tableName).containsColumn(columName); + } + + public void addTableMockData(TableMockData tableMockData) { + this.tableMockDataMap.put(tableMockData.getTableName(), tableMockData); + } + + public TableMockData getTableMockData(String tableName) { + return this.tableMockDataMap.get(tableName); + } + + public void addColumnMockData(String tableName, ColumnMockData columnMockData) { + TableMockData mock = + tableMockDataMap.computeIfAbsent(tableName, key -> TableMockData.of(tableName, new ArrayList<>())); + mock.addColumnIfNotExists(columnMockData); + // sort to last + tableMockDataMap.remove(tableName); + tableMockDataMap.put(tableName, mock); + } + + public String getRawColumnMockData(String tableName, String columnName) { + if (!this.containsTableMockData(tableName)) { + throw new DataNotExistsException("can't find table mock data by " + tableName); + } + return getTableMockData(tableName) + .getColumnMockData() + .stream() + .filter(t -> t.getColumnName().equals(columnName)) + .findFirst() + .map(ColumnMockData::getMockData) + .orElseThrow(DataNotExistsException::new); + } + + public boolean isMockInProgress(String tableName, String columnName) { + return this.mockInProgress.containsKey(tableName) && this.mockInProgress.get(tableName).contains(columnName); + } + + public void addMockInProgress(String tableName, String columnName) { + Set inProgress = this.mockInProgress.computeIfAbsent(tableName, key -> new HashSet<>()); + inProgress.add(columnName); + } + + public void removeMockInProgress(String tableName, String columnName) { + Set inProgress = this.mockInProgress.computeIfAbsent(tableName, key -> new HashSet<>()); + inProgress.remove(columnName); + } + + public String toInsertSql() { + return tableMockDataMap.entrySet() + .stream() + .map(entry -> { + String tableName = entry.getKey(); + List columns = entry.getValue().getColumnMockData(); + String format = "insert into %s (%s)\nvalues\n(%s);"; + String columnNames = columns.stream() + .map(c -> "" + c.getColumnName() + "") + .collect(Collectors.joining(", ")); + String columnValues = columns.stream() + .map(ColumnMockData::getMockData) + .collect(Collectors.joining(", ")); + return String.format(format, tableName, columnNames, columnValues); + }) + .collect(Collectors.joining("\n\n")); + } + + public void saveReference(String fromTable, String fromColumn, String toTable, String toColumn) { + if (toReference.containsKey(fromTable) && toReference.get(fromTable).contains(fromColumn)) { + if (fromReference.containsKey(toTable) && fromReference.get(toTable).contains(toColumn)) { + String format = "%s 和 %s 出现了循环引用"; + String message = String.format(format, fromTable + "." + fromColumn, toTable + "." + toColumn); + throw DomainErrors.CIRCLE_REFERENCE.exception(message); + } + } + Set fromColumns = this.fromReference.computeIfAbsent(fromTable, key -> new HashSet<>()); + fromColumns.add(fromColumn); + Set toColumns = this.toReference.computeIfAbsent(toTable, key -> new HashSet<>()); + toColumns.add(toColumn); + } +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/generator/MockDataGenerator.java b/core/src/main/java/com/databasir/core/domain/mock/generator/MockDataGenerator.java new file mode 100644 index 0000000..6cc4279 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/generator/MockDataGenerator.java @@ -0,0 +1,129 @@ +package com.databasir.core.domain.mock.generator; + +import com.databasir.core.domain.DomainErrors; +import com.databasir.core.domain.mock.factory.MockColumnRule; +import com.databasir.core.domain.mock.factory.MockDataFactory; +import com.databasir.dao.enums.MockDataType; +import com.databasir.dao.impl.MockDataRuleDao; +import com.databasir.dao.impl.ProjectDao; +import com.databasir.dao.impl.TableColumnDocumentDao; +import com.databasir.dao.impl.TableDocumentDao; +import com.databasir.dao.tables.pojos.MockDataRulePojo; +import com.databasir.dao.tables.pojos.TableColumnDocumentPojo; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Component; + +import java.util.List; +import java.util.Optional; + +@Component +@RequiredArgsConstructor +@Slf4j +public class MockDataGenerator { + + private final List mockDataFactories; + + private final MockDataRuleDao mockDataRuleDao; + + private final TableDocumentDao tableDocumentDao; + + private final TableColumnDocumentDao tableColumnDocumentDao; + + private final ProjectDao projectDao; + + public String createInsertSql(Integer projectId, + Integer databaseDocId, + String tableName) { + if (!projectDao.existsById(projectId)) { + throw DomainErrors.PROJECT_NOT_FOUND.exception(); + } + MockDataContext context = MockDataContext.builder() + .databaseDocumentId(databaseDocId) + .projectId(projectId) + .build(); + create(context, tableName); + return context.toInsertSql(); + } + + private void create(MockDataContext context, String tableName) { + if (!context.containsTable(tableName)) { + var tableOption = + tableDocumentDao.selectByDatabaseDocumentIdAndTableName(context.getDatabaseDocumentId(), tableName); + if (tableOption.isEmpty()) { + log.warn("can not find table => " + tableName); + return; + } + var table = tableOption.get(); + var columns = tableColumnDocumentDao.selectByTableDocumentId(table.getId()); + context.addTableColumns(tableName, columns); + } + if (!context.containMockRule(tableName)) { + var columnRules = mockDataRuleDao.selectByProjectIdAndTableName(context.getProjectId(), tableName); + context.addTableMockRules(tableName, columnRules); + } + + for (TableColumnDocumentPojo column : context.getTableColumnMap().get(tableName).values()) { + if (context.containsColumnMockData(tableName, column.getName()) + || context.isMockInProgress(tableName, column.getName())) { + continue; + } + create(context, tableName, column.getName()); + } + } + + private void create(MockDataContext context, String tableName, String columnName) { + if (context.containsColumnMockData(tableName, columnName)) { + return; + } + TableColumnDocumentPojo column = context.getTableColumn(tableName, columnName); + Optional ruleOption = context.getMockRule(tableName, columnName); + String rawData; + if (ruleOption.isPresent()) { + MockDataRulePojo rule = ruleOption.get(); + if (rule.getMockDataType() == MockDataType.REF) { + context.addMockInProgress(tableName, columnName); + context.saveReference( + rule.getTableName(), rule.getColumnName(), + rule.getDependentTableName(), rule.getDependentColumnName() + ); + if (context.containsTable(rule.getDependentTableName())) { + create(context, rule.getDependentTableName(), rule.getDependentColumnName()); + } else { + create(context, rule.getDependentTableName()); + } + context.removeMockInProgress(tableName, columnName); + rawData = context.getRawColumnMockData(rule.getDependentTableName(), rule.getDependentColumnName()); + } else { + rawData = createByFactory(column, rule); + } + } else { + rawData = createByFactory(column, null); + } + context.addColumnMockData(tableName, toData(rawData, column)); + } + + private String createByFactory(TableColumnDocumentPojo column, MockDataRulePojo rule) { + MockDataType mockType = rule == null ? MockDataType.AUTO : rule.getMockDataType(); + MockColumnRule colRule = MockColumnRule.builder() + .dataType(column.getDataType()) + .mockDataType(mockType) + .mockDataScript(null == rule ? null : rule.getMockDataScript()) + .columnName(column.getName()) + .columnType(column.getType()) + .build(); + return mockDataFactories.stream() + .filter(factory -> factory.accept(colRule)) + .findFirst() + .map(factory -> factory.create(colRule)) + .orElseThrow(); + } + + private ColumnMockData toData(String data, TableColumnDocumentPojo column) { + return ColumnMockData.builder() + .columnName(column.getName()) + .columnType(column.getType()) + .mockData(data) + .build(); + } +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/generator/TableMockData.java b/core/src/main/java/com/databasir/core/domain/mock/generator/TableMockData.java new file mode 100644 index 0000000..ecd6ee1 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/generator/TableMockData.java @@ -0,0 +1,34 @@ +package com.databasir.core.domain.mock.generator; + +import lombok.AllArgsConstructor; +import lombok.Getter; + +import java.util.List; +import java.util.Objects; + +@Getter +@AllArgsConstructor +public class TableMockData { + + private String tableName; + + private List columnMockData; + + public static TableMockData of(String tableName, List columnMockData) { + return new TableMockData(tableName, columnMockData); + } + + public void addColumnIfNotExists(ColumnMockData data) { + boolean present = columnMockData.stream() + .anyMatch(col -> Objects.equals(col.getColumnName(), data.getColumnName())); + if (present) { + return; + } + this.columnMockData.add(data); + } + + public boolean containsColumn(String columnName) { + return columnMockData.stream() + .anyMatch(col -> Objects.equals(col.getColumnName(), columnName)); + } +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/script/MockScriptEvaluator.java b/core/src/main/java/com/databasir/core/domain/mock/script/MockScriptEvaluator.java new file mode 100644 index 0000000..48921a0 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/script/MockScriptEvaluator.java @@ -0,0 +1,14 @@ +package com.databasir.core.domain.mock.script; + +import lombok.Data; + +public interface MockScriptEvaluator { + + String evaluate(String script, ScriptContext context); + + @Data + class ScriptContext { + + } + +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/script/SpelScriptEvaluator.java b/core/src/main/java/com/databasir/core/domain/mock/script/SpelScriptEvaluator.java new file mode 100644 index 0000000..d1c40c7 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/script/SpelScriptEvaluator.java @@ -0,0 +1,21 @@ +package com.databasir.core.domain.mock.script; + +import lombok.RequiredArgsConstructor; +import org.springframework.expression.Expression; +import org.springframework.expression.spel.standard.SpelExpressionParser; +import org.springframework.expression.spel.support.StandardEvaluationContext; +import org.springframework.stereotype.Component; + +@Component +@RequiredArgsConstructor +public class SpelScriptEvaluator implements MockScriptEvaluator { + + private final SpelExpressionParser spelExpressionParser = new SpelExpressionParser(); + + @Override + public String evaluate(String script, ScriptContext context) { + Expression expression = spelExpressionParser.parseExpression(script); + StandardEvaluationContext spelContext = new StandardEvaluationContext(context); + return expression.getValue(spelContext, String.class); + } +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/validator/MockDataSaveValidator.java b/core/src/main/java/com/databasir/core/domain/mock/validator/MockDataSaveValidator.java new file mode 100644 index 0000000..2a92206 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/validator/MockDataSaveValidator.java @@ -0,0 +1,127 @@ +package com.databasir.core.domain.mock.validator; + +import com.alibaba.excel.util.StringUtils; +import com.databasir.core.domain.DomainErrors; +import com.databasir.core.domain.mock.data.ColumnMockRuleSaveRequest; +import com.databasir.core.domain.mock.script.MockScriptEvaluator; +import com.databasir.core.domain.mock.script.SpelScriptEvaluator; +import com.databasir.dao.enums.MockDataType; +import com.databasir.dao.impl.TableColumnDocumentDao; +import com.databasir.dao.impl.TableDocumentDao; +import com.databasir.dao.tables.pojos.TableColumnDocumentPojo; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Component; + +import java.util.*; +import java.util.stream.Collectors; + +@Component +@RequiredArgsConstructor +public class MockDataSaveValidator { + + private final TableDocumentDao tableDocumentDao; + + private final TableColumnDocumentDao tableColumnDocumentDao; + + private final SpelScriptEvaluator spelScriptEvaluator; + + public void validScriptMockType(List rules) { + for (ColumnMockRuleSaveRequest request : rules) { + if (request.getMockDataType() != MockDataType.SCRIPT) { + continue; + } + if (StringUtils.isBlank(request.getMockDataScript())) { + throw DomainErrors.MOCK_DATA_SCRIPT_MUST_NOT_BE_BLANK.exception(); + } + try { + spelScriptEvaluator.evaluate(request.getMockDataScript(), new MockScriptEvaluator.ScriptContext()); + } catch (Exception e) { + throw DomainErrors.INVALID_MOCK_DATA_SCRIPT.exception(e.getMessage()); + } + } + } + + public void validTableColumn(Integer tableDocId, List requestColumnNames) { + var existsColumnNames = tableColumnDocumentDao.selectByTableDocumentId(tableDocId) + .stream() + .map(TableColumnDocumentPojo::getName) + .collect(Collectors.toSet()); + for (String colName : requestColumnNames) { + if (!existsColumnNames.contains(colName)) { + throw DomainErrors.TABLE_META_NOT_FOUND.exception("column " + + colName + + " not exists in " + + tableDocId); + } + } + } + + public void validRefMockType(Integer databaseDocId, + List rules) { + Map> fromTableAndColumn = new HashMap<>(); + Map> toTableAndColumn = new HashMap<>(); + for (ColumnMockRuleSaveRequest request : rules) { + if (request.getMockDataType() != MockDataType.REF) { + continue; + } + forbiddenIfMissRequireParams(request); + forbiddenIfSelfReference(request); + forbiddenIfCircleReference(request, fromTableAndColumn, toTableAndColumn); + forbiddenIfIsInvalidTableOrColumn(databaseDocId, request); + } + } + + private void forbiddenIfSelfReference(ColumnMockRuleSaveRequest request) { + if (!Objects.equals(request.getTableName(), request.getDependentTableName())) { + return; + } + if (!Objects.equals(request.getColumnName(), request.getDependentColumnName())) { + return; + } + throw DomainErrors.MUST_NOT_REF_SELF.exception(); + } + + private void forbiddenIfMissRequireParams(ColumnMockRuleSaveRequest request) { + if (StringUtils.isBlank(request.getDependentTableName())) { + throw DomainErrors.DEPENDENT_COLUMN_NAME_MUST_NOT_BE_BLANK.exception(); + } + if (StringUtils.isBlank(request.getDependentColumnName())) { + throw DomainErrors.DEPENDENT_COLUMN_NAME_MUST_NOT_BE_BLANK.exception(); + } + } + + private void forbiddenIfIsInvalidTableOrColumn(Integer docId, ColumnMockRuleSaveRequest request) { + String dependentTableName = request.getDependentTableName(); + var dependentTable = tableDocumentDao.selectByDatabaseDocumentIdAndTableName(docId, dependentTableName) + .orElseThrow(DomainErrors.TABLE_META_NOT_FOUND::exception); + if (!tableColumnDocumentDao.exists(dependentTable.getId(), request.getDependentColumnName())) { + throw DomainErrors.TABLE_META_NOT_FOUND.exception("列字段 " + + request.getDependentColumnName() + + "不存在"); + } + } + + private void forbiddenIfCircleReference(ColumnMockRuleSaveRequest request, + Map> fromTableAndColumn, + Map> toTableAndColumn) { + if (toTableAndColumn.containsKey(request.getTableName()) + && toTableAndColumn.get(request.getTableName()).contains(request.getColumnName())) { + if (fromTableAndColumn.containsKey(request.getDependentTableName()) + && fromTableAndColumn.get(request.getDependentTableName()) + .contains(request.getDependentColumnName())) { + String format = "%s 和 %s 出现了循环引用"; + String from = request.getTableName() + "." + request.getColumnName(); + String to = request.getDependentTableName() + "." + request.getDependentColumnName(); + String message = String.format(format, from, to); + throw DomainErrors.CIRCLE_REFERENCE.exception(message); + } + } + + Set fromColumns = + fromTableAndColumn.computeIfAbsent(request.getTableName(), key -> new HashSet()); + fromColumns.add(request.getColumnName()); + Set toColumns = + toTableAndColumn.computeIfAbsent(request.getDependentTableName(), key -> new HashSet()); + toColumns.add(request.getDependentColumnName()); + } +} diff --git a/core/src/main/java/com/databasir/core/domain/mock/validator/MockDataValidator.java b/core/src/main/java/com/databasir/core/domain/mock/validator/MockDataValidator.java new file mode 100644 index 0000000..1a01253 --- /dev/null +++ b/core/src/main/java/com/databasir/core/domain/mock/validator/MockDataValidator.java @@ -0,0 +1,52 @@ +package com.databasir.core.domain.mock.validator; + +import com.databasir.core.domain.DomainErrors; +import com.databasir.dao.impl.DatabaseDocumentDao; +import com.databasir.dao.impl.ProjectDao; +import com.databasir.dao.impl.TableDocumentDao; +import com.databasir.dao.tables.pojos.DatabaseDocumentPojo; +import com.databasir.dao.tables.pojos.TableDocumentPojo; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Component; + +import java.util.Optional; + +@Component +@RequiredArgsConstructor +public class MockDataValidator { + + private final ProjectDao projectDao; + + private final DatabaseDocumentDao databaseDocumentDao; + + private final TableDocumentDao tableDocumentDao; + + public void validProject(Integer projectId) { + if (!projectDao.existsById(projectId)) { + throw DomainErrors.PROJECT_NOT_FOUND.exception(); + } + } + + public DatabaseDocumentPojo validAndGetDatabaseDocumentPojo(Integer projectId, Long version) { + Optional databaseDoc; + if (version == null) { + databaseDoc = databaseDocumentDao.selectNotArchivedByProjectId(projectId); + } else { + databaseDoc = databaseDocumentDao.selectOptionalByProjectIdAndVersion(projectId, version); + } + if (databaseDoc.isEmpty()) { + throw DomainErrors.DATABASE_META_NOT_FOUND.exception(); + } + return databaseDoc.get(); + } + + public TableDocumentPojo validAndGetTableDocumentPojo(Integer databaseDocId, Integer tableId) { + Optional tableOption = + tableDocumentDao.selectByDatabaseDocumentIdAndId(databaseDocId, tableId); + if (tableOption.isEmpty()) { + throw DomainErrors.DATABASE_META_NOT_FOUND.exception("表数据不存在"); + } + return tableOption.get(); + } + +} diff --git a/core/src/test/java/com/databasir/core/domain/mock/service/MockDataServiceTest.java b/core/src/test/java/com/databasir/core/domain/mock/service/MockDataServiceTest.java new file mode 100644 index 0000000..3668084 --- /dev/null +++ b/core/src/test/java/com/databasir/core/domain/mock/service/MockDataServiceTest.java @@ -0,0 +1,24 @@ +package com.databasir.core.domain.mock.service; + +import com.databasir.core.BaseTest; +import com.databasir.core.domain.mock.MockDataService; +import com.databasir.core.domain.mock.generator.MockDataGenerator; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.transaction.annotation.Transactional; + +@Transactional +public class MockDataServiceTest extends BaseTest { + + @Autowired + private MockDataService mockDataService; + + @Autowired + private MockDataGenerator mockDataGenerator; + + @Test + public void test() { + String sql = mockDataGenerator.createInsertSql(15,3L, "event_reward_history"); + System.out.println(sql); + } +} diff --git a/dao/build.gradle b/dao/build.gradle index 938ab5e..737ac89 100644 --- a/dao/build.gradle +++ b/dao/build.gradle @@ -72,6 +72,12 @@ jooq { includeExpression = 'document_template_property.type' includeTypes = '.*' } + forcedType { + userType = 'com.databasir.dao.enums.MockDataType' + converter = 'com.databasir.dao.converter.MockDataTypeConverter' + includeExpression = 'mock_data_rule.mock_data_type' + includeTypes = '.*' + } } } generate { diff --git a/dao/generated-src/jooq/main/java/com/databasir/dao/Databasir.java b/dao/generated-src/jooq/main/java/com/databasir/dao/Databasir.java index 7623c38..9ead5d5 100644 --- a/dao/generated-src/jooq/main/java/com/databasir/dao/Databasir.java +++ b/dao/generated-src/jooq/main/java/com/databasir/dao/Databasir.java @@ -13,6 +13,7 @@ import com.databasir.dao.tables.DocumentDiscussion; import com.databasir.dao.tables.DocumentTemplateProperty; import com.databasir.dao.tables.Group; import com.databasir.dao.tables.Login; +import com.databasir.dao.tables.MockDataRule; import com.databasir.dao.tables.OauthApp; import com.databasir.dao.tables.OperationLog; import com.databasir.dao.tables.Project; @@ -94,6 +95,11 @@ public class Databasir extends SchemaImpl { */ public final Login LOGIN = Login.LOGIN; + /** + * The table databasir.mock_data_rule. + */ + public final MockDataRule MOCK_DATA_RULE = MockDataRule.MOCK_DATA_RULE; + /** * oauth app info */ @@ -189,6 +195,7 @@ public class Databasir extends SchemaImpl { DocumentTemplateProperty.DOCUMENT_TEMPLATE_PROPERTY, Group.GROUP, Login.LOGIN, + MockDataRule.MOCK_DATA_RULE, OauthApp.OAUTH_APP, OperationLog.OPERATION_LOG, Project.PROJECT, diff --git a/dao/generated-src/jooq/main/java/com/databasir/dao/Keys.java b/dao/generated-src/jooq/main/java/com/databasir/dao/Keys.java index 5853b13..d4c61ea 100644 --- a/dao/generated-src/jooq/main/java/com/databasir/dao/Keys.java +++ b/dao/generated-src/jooq/main/java/com/databasir/dao/Keys.java @@ -13,6 +13,7 @@ import com.databasir.dao.tables.DocumentDiscussion; import com.databasir.dao.tables.DocumentTemplateProperty; import com.databasir.dao.tables.Group; import com.databasir.dao.tables.Login; +import com.databasir.dao.tables.MockDataRule; import com.databasir.dao.tables.OauthApp; import com.databasir.dao.tables.OperationLog; import com.databasir.dao.tables.Project; @@ -36,6 +37,7 @@ import com.databasir.dao.tables.records.DocumentDiscussionRecord; import com.databasir.dao.tables.records.DocumentTemplatePropertyRecord; import com.databasir.dao.tables.records.GroupRecord; import com.databasir.dao.tables.records.LoginRecord; +import com.databasir.dao.tables.records.MockDataRuleRecord; import com.databasir.dao.tables.records.OauthAppRecord; import com.databasir.dao.tables.records.OperationLogRecord; import com.databasir.dao.tables.records.ProjectRecord; @@ -82,6 +84,8 @@ public class Keys { public static final UniqueKey KEY_GROUP_PRIMARY = Internal.createUniqueKey(Group.GROUP, DSL.name("KEY_group_PRIMARY"), new TableField[] { Group.GROUP.ID }, true); public static final UniqueKey KEY_LOGIN_PRIMARY = Internal.createUniqueKey(Login.LOGIN, DSL.name("KEY_login_PRIMARY"), new TableField[] { Login.LOGIN.ID }, true); public static final UniqueKey KEY_LOGIN_UK_USER_ID = Internal.createUniqueKey(Login.LOGIN, DSL.name("KEY_login_uk_user_id"), new TableField[] { Login.LOGIN.USER_ID }, true); + public static final UniqueKey KEY_MOCK_DATA_RULE_PRIMARY = Internal.createUniqueKey(MockDataRule.MOCK_DATA_RULE, DSL.name("KEY_mock_data_rule_PRIMARY"), new TableField[] { MockDataRule.MOCK_DATA_RULE.ID }, true); + public static final UniqueKey KEY_MOCK_DATA_RULE_UK_PROJECT_ID_TABLE_NAME_COLUMN_NAME = Internal.createUniqueKey(MockDataRule.MOCK_DATA_RULE, DSL.name("KEY_mock_data_rule_uk_project_id_table_name_column_name"), new TableField[] { MockDataRule.MOCK_DATA_RULE.PROJECT_ID, MockDataRule.MOCK_DATA_RULE.TABLE_NAME, MockDataRule.MOCK_DATA_RULE.COLUMN_NAME }, true); public static final UniqueKey KEY_OAUTH_APP_PRIMARY = Internal.createUniqueKey(OauthApp.OAUTH_APP, DSL.name("KEY_oauth_app_PRIMARY"), new TableField[] { OauthApp.OAUTH_APP.ID }, true); public static final UniqueKey KEY_OAUTH_APP_UK_REGISTRATION_ID = Internal.createUniqueKey(OauthApp.OAUTH_APP, DSL.name("KEY_oauth_app_uk_registration_id"), new TableField[] { OauthApp.OAUTH_APP.REGISTRATION_ID }, true); public static final UniqueKey KEY_OPERATION_LOG_PRIMARY = Internal.createUniqueKey(OperationLog.OPERATION_LOG, DSL.name("KEY_operation_log_PRIMARY"), new TableField[] { OperationLog.OPERATION_LOG.ID }, true); diff --git a/dao/generated-src/jooq/main/java/com/databasir/dao/Tables.java b/dao/generated-src/jooq/main/java/com/databasir/dao/Tables.java index 865b0d4..b7e080b 100644 --- a/dao/generated-src/jooq/main/java/com/databasir/dao/Tables.java +++ b/dao/generated-src/jooq/main/java/com/databasir/dao/Tables.java @@ -13,6 +13,7 @@ import com.databasir.dao.tables.DocumentDiscussion; import com.databasir.dao.tables.DocumentTemplateProperty; import com.databasir.dao.tables.Group; import com.databasir.dao.tables.Login; +import com.databasir.dao.tables.MockDataRule; import com.databasir.dao.tables.OauthApp; import com.databasir.dao.tables.OperationLog; import com.databasir.dao.tables.Project; @@ -80,6 +81,11 @@ public class Tables { */ public static final Login LOGIN = Login.LOGIN; + /** + * The table databasir.mock_data_rule. + */ + public static final MockDataRule MOCK_DATA_RULE = MockDataRule.MOCK_DATA_RULE; + /** * oauth app info */ diff --git a/dao/generated-src/jooq/main/java/com/databasir/dao/tables/MockDataRule.java b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/MockDataRule.java new file mode 100644 index 0000000..bd9df00 --- /dev/null +++ b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/MockDataRule.java @@ -0,0 +1,191 @@ +/* + * This file is generated by jOOQ. + */ +package com.databasir.dao.tables; + + +import com.databasir.dao.Databasir; +import com.databasir.dao.Keys; +import com.databasir.dao.converter.MockDataTypeConverter; +import com.databasir.dao.enums.MockDataType; +import com.databasir.dao.tables.records.MockDataRuleRecord; + +import java.time.LocalDateTime; +import java.util.Arrays; +import java.util.List; + +import org.jooq.Field; +import org.jooq.ForeignKey; +import org.jooq.Identity; +import org.jooq.Name; +import org.jooq.Record; +import org.jooq.Row10; +import org.jooq.Schema; +import org.jooq.Table; +import org.jooq.TableField; +import org.jooq.TableOptions; +import org.jooq.UniqueKey; +import org.jooq.impl.DSL; +import org.jooq.impl.SQLDataType; +import org.jooq.impl.TableImpl; + + +/** + * This class is generated by jOOQ. + */ +@SuppressWarnings({ "all", "unchecked", "rawtypes" }) +public class MockDataRule extends TableImpl { + + private static final long serialVersionUID = 1L; + + /** + * The reference instance of databasir.mock_data_rule + */ + public static final MockDataRule MOCK_DATA_RULE = new MockDataRule(); + + /** + * The class holding records for this type + */ + @Override + public Class getRecordType() { + return MockDataRuleRecord.class; + } + + /** + * The column databasir.mock_data_rule.id. + */ + public final TableField ID = createField(DSL.name("id"), SQLDataType.INTEGER.nullable(false).identity(true), this, ""); + + /** + * The column databasir.mock_data_rule.project_id. + */ + public final TableField PROJECT_ID = createField(DSL.name("project_id"), SQLDataType.INTEGER.nullable(false), this, ""); + + /** + * The column databasir.mock_data_rule.table_name. + */ + public final TableField TABLE_NAME = createField(DSL.name("table_name"), SQLDataType.VARCHAR(255).nullable(false), this, ""); + + /** + * The column databasir.mock_data_rule.column_name. + */ + public final TableField COLUMN_NAME = createField(DSL.name("column_name"), SQLDataType.VARCHAR(255).nullable(false), this, ""); + + /** + * The column databasir.mock_data_rule.dependent_table_name. + */ + public final TableField DEPENDENT_TABLE_NAME = createField(DSL.name("dependent_table_name"), SQLDataType.VARCHAR(255), this, ""); + + /** + * The column databasir.mock_data_rule.dependent_column_name. + */ + public final TableField DEPENDENT_COLUMN_NAME = createField(DSL.name("dependent_column_name"), SQLDataType.VARCHAR(255), this, ""); + + /** + * The column databasir.mock_data_rule.mock_data_type. + */ + public final TableField MOCK_DATA_TYPE = createField(DSL.name("mock_data_type"), SQLDataType.VARCHAR(255).nullable(false).defaultValue(DSL.inline("AUTO / REF / SCRIPT / PHONE / DATE / TIMESTAMP / ...", SQLDataType.VARCHAR)), this, "", new MockDataTypeConverter()); + + /** + * The column databasir.mock_data_rule.mock_data_script. + */ + public final TableField MOCK_DATA_SCRIPT = createField(DSL.name("mock_data_script"), SQLDataType.CLOB, this, ""); + + /** + * The column databasir.mock_data_rule.update_at. + */ + public final TableField UPDATE_AT = createField(DSL.name("update_at"), SQLDataType.LOCALDATETIME(0).nullable(false).defaultValue(DSL.field("CURRENT_TIMESTAMP", SQLDataType.LOCALDATETIME)), this, ""); + + /** + * The column databasir.mock_data_rule.create_at. + */ + public final TableField CREATE_AT = createField(DSL.name("create_at"), SQLDataType.LOCALDATETIME(0).nullable(false).defaultValue(DSL.field("CURRENT_TIMESTAMP", SQLDataType.LOCALDATETIME)), this, ""); + + private MockDataRule(Name alias, Table aliased) { + this(alias, aliased, null); + } + + private MockDataRule(Name alias, Table aliased, Field[] parameters) { + super(alias, null, aliased, parameters, DSL.comment(""), TableOptions.table()); + } + + /** + * Create an aliased databasir.mock_data_rule table reference + */ + public MockDataRule(String alias) { + this(DSL.name(alias), MOCK_DATA_RULE); + } + + /** + * Create an aliased databasir.mock_data_rule table reference + */ + public MockDataRule(Name alias) { + this(alias, MOCK_DATA_RULE); + } + + /** + * Create a databasir.mock_data_rule table reference + */ + public MockDataRule() { + this(DSL.name("mock_data_rule"), null); + } + + public MockDataRule(Table child, ForeignKey key) { + super(child, key, MOCK_DATA_RULE); + } + + @Override + public Schema getSchema() { + return aliased() ? null : Databasir.DATABASIR; + } + + @Override + public Identity getIdentity() { + return (Identity) super.getIdentity(); + } + + @Override + public UniqueKey getPrimaryKey() { + return Keys.KEY_MOCK_DATA_RULE_PRIMARY; + } + + @Override + public List> getUniqueKeys() { + return Arrays.asList(Keys.KEY_MOCK_DATA_RULE_UK_PROJECT_ID_TABLE_NAME_COLUMN_NAME); + } + + @Override + public MockDataRule as(String alias) { + return new MockDataRule(DSL.name(alias), this); + } + + @Override + public MockDataRule as(Name alias) { + return new MockDataRule(alias, this); + } + + /** + * Rename this table + */ + @Override + public MockDataRule rename(String name) { + return new MockDataRule(DSL.name(name), null); + } + + /** + * Rename this table + */ + @Override + public MockDataRule rename(Name name) { + return new MockDataRule(name, null); + } + + // ------------------------------------------------------------------------- + // Row10 type methods + // ------------------------------------------------------------------------- + + @Override + public Row10 fieldsRow() { + return (Row10) super.fieldsRow(); + } +} diff --git a/dao/generated-src/jooq/main/java/com/databasir/dao/tables/TableColumnDocument.java b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/TableColumnDocument.java index dfb3cfc..1901b91 100644 --- a/dao/generated-src/jooq/main/java/com/databasir/dao/tables/TableColumnDocument.java +++ b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/TableColumnDocument.java @@ -19,7 +19,7 @@ import org.jooq.Identity; import org.jooq.Index; import org.jooq.Name; import org.jooq.Record; -import org.jooq.Row13; +import org.jooq.Row14; import org.jooq.Schema; import org.jooq.Table; import org.jooq.TableField; @@ -78,6 +78,11 @@ public class TableColumnDocument extends TableImpl { */ public final TableField TYPE = createField(DSL.name("type"), SQLDataType.VARCHAR(255).nullable(false), this, ""); + /** + * The column databasir.table_column_document.data_type. + */ + public final TableField DATA_TYPE = createField(DSL.name("data_type"), SQLDataType.INTEGER.nullable(false).defaultValue(DSL.inline("99999", SQLDataType.INTEGER)), this, ""); + /** * The column databasir.table_column_document.comment. */ @@ -202,11 +207,11 @@ public class TableColumnDocument extends TableImpl { } // ------------------------------------------------------------------------- - // Row13 type methods + // Row14 type methods // ------------------------------------------------------------------------- @Override - public Row13 fieldsRow() { - return (Row13) super.fieldsRow(); + public Row14 fieldsRow() { + return (Row14) super.fieldsRow(); } } diff --git a/dao/generated-src/jooq/main/java/com/databasir/dao/tables/pojos/MockDataRulePojo.java b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/pojos/MockDataRulePojo.java new file mode 100644 index 0000000..713059d --- /dev/null +++ b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/pojos/MockDataRulePojo.java @@ -0,0 +1,229 @@ +/* + * This file is generated by jOOQ. + */ +package com.databasir.dao.tables.pojos; + + +import com.databasir.dao.enums.MockDataType; + +import java.io.Serializable; +import java.time.LocalDateTime; + + +/** + * This class is generated by jOOQ. + */ +@SuppressWarnings({ "all", "unchecked", "rawtypes" }) +public class MockDataRulePojo implements Serializable { + + private static final long serialVersionUID = 1L; + + private Integer id; + private Integer projectId; + private String tableName; + private String columnName; + private String dependentTableName; + private String dependentColumnName; + private MockDataType mockDataType; + private String mockDataScript; + private LocalDateTime updateAt; + private LocalDateTime createAt; + + public MockDataRulePojo() {} + + public MockDataRulePojo(MockDataRulePojo value) { + this.id = value.id; + this.projectId = value.projectId; + this.tableName = value.tableName; + this.columnName = value.columnName; + this.dependentTableName = value.dependentTableName; + this.dependentColumnName = value.dependentColumnName; + this.mockDataType = value.mockDataType; + this.mockDataScript = value.mockDataScript; + this.updateAt = value.updateAt; + this.createAt = value.createAt; + } + + public MockDataRulePojo( + Integer id, + Integer projectId, + String tableName, + String columnName, + String dependentTableName, + String dependentColumnName, + MockDataType mockDataType, + String mockDataScript, + LocalDateTime updateAt, + LocalDateTime createAt + ) { + this.id = id; + this.projectId = projectId; + this.tableName = tableName; + this.columnName = columnName; + this.dependentTableName = dependentTableName; + this.dependentColumnName = dependentColumnName; + this.mockDataType = mockDataType; + this.mockDataScript = mockDataScript; + this.updateAt = updateAt; + this.createAt = createAt; + } + + /** + * Getter for databasir.mock_data_rule.id. + */ + public Integer getId() { + return this.id; + } + + /** + * Setter for databasir.mock_data_rule.id. + */ + public void setId(Integer id) { + this.id = id; + } + + /** + * Getter for databasir.mock_data_rule.project_id. + */ + public Integer getProjectId() { + return this.projectId; + } + + /** + * Setter for databasir.mock_data_rule.project_id. + */ + public void setProjectId(Integer projectId) { + this.projectId = projectId; + } + + /** + * Getter for databasir.mock_data_rule.table_name. + */ + public String getTableName() { + return this.tableName; + } + + /** + * Setter for databasir.mock_data_rule.table_name. + */ + public void setTableName(String tableName) { + this.tableName = tableName; + } + + /** + * Getter for databasir.mock_data_rule.column_name. + */ + public String getColumnName() { + return this.columnName; + } + + /** + * Setter for databasir.mock_data_rule.column_name. + */ + public void setColumnName(String columnName) { + this.columnName = columnName; + } + + /** + * Getter for databasir.mock_data_rule.dependent_table_name. + */ + public String getDependentTableName() { + return this.dependentTableName; + } + + /** + * Setter for databasir.mock_data_rule.dependent_table_name. + */ + public void setDependentTableName(String dependentTableName) { + this.dependentTableName = dependentTableName; + } + + /** + * Getter for databasir.mock_data_rule.dependent_column_name. + */ + public String getDependentColumnName() { + return this.dependentColumnName; + } + + /** + * Setter for databasir.mock_data_rule.dependent_column_name. + */ + public void setDependentColumnName(String dependentColumnName) { + this.dependentColumnName = dependentColumnName; + } + + /** + * Getter for databasir.mock_data_rule.mock_data_type. + */ + public MockDataType getMockDataType() { + return this.mockDataType; + } + + /** + * Setter for databasir.mock_data_rule.mock_data_type. + */ + public void setMockDataType(MockDataType mockDataType) { + this.mockDataType = mockDataType; + } + + /** + * Getter for databasir.mock_data_rule.mock_data_script. + */ + public String getMockDataScript() { + return this.mockDataScript; + } + + /** + * Setter for databasir.mock_data_rule.mock_data_script. + */ + public void setMockDataScript(String mockDataScript) { + this.mockDataScript = mockDataScript; + } + + /** + * Getter for databasir.mock_data_rule.update_at. + */ + public LocalDateTime getUpdateAt() { + return this.updateAt; + } + + /** + * Setter for databasir.mock_data_rule.update_at. + */ + public void setUpdateAt(LocalDateTime updateAt) { + this.updateAt = updateAt; + } + + /** + * Getter for databasir.mock_data_rule.create_at. + */ + public LocalDateTime getCreateAt() { + return this.createAt; + } + + /** + * Setter for databasir.mock_data_rule.create_at. + */ + public void setCreateAt(LocalDateTime createAt) { + this.createAt = createAt; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("MockDataRulePojo ("); + + sb.append(id); + sb.append(", ").append(projectId); + sb.append(", ").append(tableName); + sb.append(", ").append(columnName); + sb.append(", ").append(dependentTableName); + sb.append(", ").append(dependentColumnName); + sb.append(", ").append(mockDataType); + sb.append(", ").append(mockDataScript); + sb.append(", ").append(updateAt); + sb.append(", ").append(createAt); + + sb.append(")"); + return sb.toString(); + } +} diff --git a/dao/generated-src/jooq/main/java/com/databasir/dao/tables/pojos/TableColumnDocumentPojo.java b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/pojos/TableColumnDocumentPojo.java index 23881c7..207233e 100644 --- a/dao/generated-src/jooq/main/java/com/databasir/dao/tables/pojos/TableColumnDocumentPojo.java +++ b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/pojos/TableColumnDocumentPojo.java @@ -21,6 +21,7 @@ public class TableColumnDocumentPojo implements Serializable { private Integer databaseDocumentId; private String name; private String type; + private Integer dataType; private String comment; private String defaultValue; private Integer size; @@ -38,6 +39,7 @@ public class TableColumnDocumentPojo implements Serializable { this.databaseDocumentId = value.databaseDocumentId; this.name = value.name; this.type = value.type; + this.dataType = value.dataType; this.comment = value.comment; this.defaultValue = value.defaultValue; this.size = value.size; @@ -54,6 +56,7 @@ public class TableColumnDocumentPojo implements Serializable { Integer databaseDocumentId, String name, String type, + Integer dataType, String comment, String defaultValue, Integer size, @@ -68,6 +71,7 @@ public class TableColumnDocumentPojo implements Serializable { this.databaseDocumentId = databaseDocumentId; this.name = name; this.type = type; + this.dataType = dataType; this.comment = comment; this.defaultValue = defaultValue; this.size = size; @@ -152,6 +156,20 @@ public class TableColumnDocumentPojo implements Serializable { this.type = type; } + /** + * Getter for databasir.table_column_document.data_type. + */ + public Integer getDataType() { + return this.dataType; + } + + /** + * Setter for databasir.table_column_document.data_type. + */ + public void setDataType(Integer dataType) { + this.dataType = dataType; + } + /** * Getter for databasir.table_column_document.comment. */ @@ -277,6 +295,7 @@ public class TableColumnDocumentPojo implements Serializable { sb.append(", ").append(databaseDocumentId); sb.append(", ").append(name); sb.append(", ").append(type); + sb.append(", ").append(dataType); sb.append(", ").append(comment); sb.append(", ").append(defaultValue); sb.append(", ").append(size); diff --git a/dao/generated-src/jooq/main/java/com/databasir/dao/tables/records/MockDataRuleRecord.java b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/records/MockDataRuleRecord.java new file mode 100644 index 0000000..498ba9b --- /dev/null +++ b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/records/MockDataRuleRecord.java @@ -0,0 +1,464 @@ +/* + * This file is generated by jOOQ. + */ +package com.databasir.dao.tables.records; + + +import com.databasir.dao.enums.MockDataType; +import com.databasir.dao.tables.MockDataRule; +import com.databasir.dao.tables.pojos.MockDataRulePojo; + +import java.time.LocalDateTime; + +import org.jooq.Field; +import org.jooq.Record1; +import org.jooq.Record10; +import org.jooq.Row10; +import org.jooq.impl.UpdatableRecordImpl; + + +/** + * This class is generated by jOOQ. + */ +@SuppressWarnings({ "all", "unchecked", "rawtypes" }) +public class MockDataRuleRecord extends UpdatableRecordImpl implements Record10 { + + private static final long serialVersionUID = 1L; + + /** + * Setter for databasir.mock_data_rule.id. + */ + public void setId(Integer value) { + set(0, value); + } + + /** + * Getter for databasir.mock_data_rule.id. + */ + public Integer getId() { + return (Integer) get(0); + } + + /** + * Setter for databasir.mock_data_rule.project_id. + */ + public void setProjectId(Integer value) { + set(1, value); + } + + /** + * Getter for databasir.mock_data_rule.project_id. + */ + public Integer getProjectId() { + return (Integer) get(1); + } + + /** + * Setter for databasir.mock_data_rule.table_name. + */ + public void setTableName(String value) { + set(2, value); + } + + /** + * Getter for databasir.mock_data_rule.table_name. + */ + public String getTableName() { + return (String) get(2); + } + + /** + * Setter for databasir.mock_data_rule.column_name. + */ + public void setColumnName(String value) { + set(3, value); + } + + /** + * Getter for databasir.mock_data_rule.column_name. + */ + public String getColumnName() { + return (String) get(3); + } + + /** + * Setter for databasir.mock_data_rule.dependent_table_name. + */ + public void setDependentTableName(String value) { + set(4, value); + } + + /** + * Getter for databasir.mock_data_rule.dependent_table_name. + */ + public String getDependentTableName() { + return (String) get(4); + } + + /** + * Setter for databasir.mock_data_rule.dependent_column_name. + */ + public void setDependentColumnName(String value) { + set(5, value); + } + + /** + * Getter for databasir.mock_data_rule.dependent_column_name. + */ + public String getDependentColumnName() { + return (String) get(5); + } + + /** + * Setter for databasir.mock_data_rule.mock_data_type. + */ + public void setMockDataType(MockDataType value) { + set(6, value); + } + + /** + * Getter for databasir.mock_data_rule.mock_data_type. + */ + public MockDataType getMockDataType() { + return (MockDataType) get(6); + } + + /** + * Setter for databasir.mock_data_rule.mock_data_script. + */ + public void setMockDataScript(String value) { + set(7, value); + } + + /** + * Getter for databasir.mock_data_rule.mock_data_script. + */ + public String getMockDataScript() { + return (String) get(7); + } + + /** + * Setter for databasir.mock_data_rule.update_at. + */ + public void setUpdateAt(LocalDateTime value) { + set(8, value); + } + + /** + * Getter for databasir.mock_data_rule.update_at. + */ + public LocalDateTime getUpdateAt() { + return (LocalDateTime) get(8); + } + + /** + * Setter for databasir.mock_data_rule.create_at. + */ + public void setCreateAt(LocalDateTime value) { + set(9, value); + } + + /** + * Getter for databasir.mock_data_rule.create_at. + */ + public LocalDateTime getCreateAt() { + return (LocalDateTime) get(9); + } + + // ------------------------------------------------------------------------- + // Primary key information + // ------------------------------------------------------------------------- + + @Override + public Record1 key() { + return (Record1) super.key(); + } + + // ------------------------------------------------------------------------- + // Record10 type implementation + // ------------------------------------------------------------------------- + + @Override + public Row10 fieldsRow() { + return (Row10) super.fieldsRow(); + } + + @Override + public Row10 valuesRow() { + return (Row10) super.valuesRow(); + } + + @Override + public Field field1() { + return MockDataRule.MOCK_DATA_RULE.ID; + } + + @Override + public Field field2() { + return MockDataRule.MOCK_DATA_RULE.PROJECT_ID; + } + + @Override + public Field field3() { + return MockDataRule.MOCK_DATA_RULE.TABLE_NAME; + } + + @Override + public Field field4() { + return MockDataRule.MOCK_DATA_RULE.COLUMN_NAME; + } + + @Override + public Field field5() { + return MockDataRule.MOCK_DATA_RULE.DEPENDENT_TABLE_NAME; + } + + @Override + public Field field6() { + return MockDataRule.MOCK_DATA_RULE.DEPENDENT_COLUMN_NAME; + } + + @Override + public Field field7() { + return MockDataRule.MOCK_DATA_RULE.MOCK_DATA_TYPE; + } + + @Override + public Field field8() { + return MockDataRule.MOCK_DATA_RULE.MOCK_DATA_SCRIPT; + } + + @Override + public Field field9() { + return MockDataRule.MOCK_DATA_RULE.UPDATE_AT; + } + + @Override + public Field field10() { + return MockDataRule.MOCK_DATA_RULE.CREATE_AT; + } + + @Override + public Integer component1() { + return getId(); + } + + @Override + public Integer component2() { + return getProjectId(); + } + + @Override + public String component3() { + return getTableName(); + } + + @Override + public String component4() { + return getColumnName(); + } + + @Override + public String component5() { + return getDependentTableName(); + } + + @Override + public String component6() { + return getDependentColumnName(); + } + + @Override + public MockDataType component7() { + return getMockDataType(); + } + + @Override + public String component8() { + return getMockDataScript(); + } + + @Override + public LocalDateTime component9() { + return getUpdateAt(); + } + + @Override + public LocalDateTime component10() { + return getCreateAt(); + } + + @Override + public Integer value1() { + return getId(); + } + + @Override + public Integer value2() { + return getProjectId(); + } + + @Override + public String value3() { + return getTableName(); + } + + @Override + public String value4() { + return getColumnName(); + } + + @Override + public String value5() { + return getDependentTableName(); + } + + @Override + public String value6() { + return getDependentColumnName(); + } + + @Override + public MockDataType value7() { + return getMockDataType(); + } + + @Override + public String value8() { + return getMockDataScript(); + } + + @Override + public LocalDateTime value9() { + return getUpdateAt(); + } + + @Override + public LocalDateTime value10() { + return getCreateAt(); + } + + @Override + public MockDataRuleRecord value1(Integer value) { + setId(value); + return this; + } + + @Override + public MockDataRuleRecord value2(Integer value) { + setProjectId(value); + return this; + } + + @Override + public MockDataRuleRecord value3(String value) { + setTableName(value); + return this; + } + + @Override + public MockDataRuleRecord value4(String value) { + setColumnName(value); + return this; + } + + @Override + public MockDataRuleRecord value5(String value) { + setDependentTableName(value); + return this; + } + + @Override + public MockDataRuleRecord value6(String value) { + setDependentColumnName(value); + return this; + } + + @Override + public MockDataRuleRecord value7(MockDataType value) { + setMockDataType(value); + return this; + } + + @Override + public MockDataRuleRecord value8(String value) { + setMockDataScript(value); + return this; + } + + @Override + public MockDataRuleRecord value9(LocalDateTime value) { + setUpdateAt(value); + return this; + } + + @Override + public MockDataRuleRecord value10(LocalDateTime value) { + setCreateAt(value); + return this; + } + + @Override + public MockDataRuleRecord values(Integer value1, Integer value2, String value3, String value4, String value5, String value6, MockDataType value7, String value8, LocalDateTime value9, LocalDateTime value10) { + value1(value1); + value2(value2); + value3(value3); + value4(value4); + value5(value5); + value6(value6); + value7(value7); + value8(value8); + value9(value9); + value10(value10); + return this; + } + + // ------------------------------------------------------------------------- + // Constructors + // ------------------------------------------------------------------------- + + /** + * Create a detached MockDataRuleRecord + */ + public MockDataRuleRecord() { + super(MockDataRule.MOCK_DATA_RULE); + } + + /** + * Create a detached, initialised MockDataRuleRecord + */ + public MockDataRuleRecord(Integer id, Integer projectId, String tableName, String columnName, String dependentTableName, String dependentColumnName, MockDataType mockDataType, String mockDataScript, LocalDateTime updateAt, LocalDateTime createAt) { + super(MockDataRule.MOCK_DATA_RULE); + + setId(id); + setProjectId(projectId); + setTableName(tableName); + setColumnName(columnName); + setDependentTableName(dependentTableName); + setDependentColumnName(dependentColumnName); + setMockDataType(mockDataType); + setMockDataScript(mockDataScript); + setUpdateAt(updateAt); + setCreateAt(createAt); + } + + /** + * Create a detached, initialised MockDataRuleRecord + */ + public MockDataRuleRecord(MockDataRulePojo value) { + super(MockDataRule.MOCK_DATA_RULE); + + if (value != null) { + setId(value.getId()); + setProjectId(value.getProjectId()); + setTableName(value.getTableName()); + setColumnName(value.getColumnName()); + setDependentTableName(value.getDependentTableName()); + setDependentColumnName(value.getDependentColumnName()); + setMockDataType(value.getMockDataType()); + setMockDataScript(value.getMockDataScript()); + setUpdateAt(value.getUpdateAt()); + setCreateAt(value.getCreateAt()); + } + } +} diff --git a/dao/generated-src/jooq/main/java/com/databasir/dao/tables/records/TableColumnDocumentRecord.java b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/records/TableColumnDocumentRecord.java index 84f8972..a1a9921 100644 --- a/dao/generated-src/jooq/main/java/com/databasir/dao/tables/records/TableColumnDocumentRecord.java +++ b/dao/generated-src/jooq/main/java/com/databasir/dao/tables/records/TableColumnDocumentRecord.java @@ -11,8 +11,8 @@ import java.time.LocalDateTime; import org.jooq.Field; import org.jooq.Record1; -import org.jooq.Record13; -import org.jooq.Row13; +import org.jooq.Record14; +import org.jooq.Row14; import org.jooq.impl.UpdatableRecordImpl; @@ -20,7 +20,7 @@ import org.jooq.impl.UpdatableRecordImpl; * This class is generated by jOOQ. */ @SuppressWarnings({ "all", "unchecked", "rawtypes" }) -public class TableColumnDocumentRecord extends UpdatableRecordImpl implements Record13 { +public class TableColumnDocumentRecord extends UpdatableRecordImpl implements Record14 { private static final long serialVersionUID = 1L; @@ -98,74 +98,88 @@ public class TableColumnDocumentRecord extends UpdatableRecordImpldatabasir.table_column_document.data_type. + */ + public void setDataType(Integer value) { + set(5, value); + } + + /** + * Getter for databasir.table_column_document.data_type. + */ + public Integer getDataType() { + return (Integer) get(5); + } + /** * Setter for databasir.table_column_document.comment. */ public void setComment(String value) { - set(5, value); + set(6, value); } /** * Getter for databasir.table_column_document.comment. */ public String getComment() { - return (String) get(5); + return (String) get(6); } /** * Setter for databasir.table_column_document.default_value. */ public void setDefaultValue(String value) { - set(6, value); + set(7, value); } /** * Getter for databasir.table_column_document.default_value. */ public String getDefaultValue() { - return (String) get(6); + return (String) get(7); } /** * Setter for databasir.table_column_document.size. */ public void setSize(Integer value) { - set(7, value); + set(8, value); } /** * Getter for databasir.table_column_document.size. */ public Integer getSize() { - return (Integer) get(7); + return (Integer) get(8); } /** * Setter for databasir.table_column_document.decimal_digits. */ public void setDecimalDigits(Integer value) { - set(8, value); + set(9, value); } /** * Getter for databasir.table_column_document.decimal_digits. */ public Integer getDecimalDigits() { - return (Integer) get(8); + return (Integer) get(9); } /** * Setter for databasir.table_column_document.is_primary_key. */ public void setIsPrimaryKey(Boolean value) { - set(9, value); + set(10, value); } /** * Getter for databasir.table_column_document.is_primary_key. */ public Boolean getIsPrimaryKey() { - return (Boolean) get(9); + return (Boolean) get(10); } /** @@ -173,7 +187,7 @@ public class TableColumnDocumentRecord extends UpdatableRecordImpldatabasir.table_column_document.create_at. */ public void setCreateAt(LocalDateTime value) { - set(12, value); + set(13, value); } /** * Getter for databasir.table_column_document.create_at. */ public LocalDateTime getCreateAt() { - return (LocalDateTime) get(12); + return (LocalDateTime) get(13); } // ------------------------------------------------------------------------- @@ -224,17 +238,17 @@ public class TableColumnDocumentRecord extends UpdatableRecordImpl fieldsRow() { - return (Row13) super.fieldsRow(); + public Row14 fieldsRow() { + return (Row14) super.fieldsRow(); } @Override - public Row13 valuesRow() { - return (Row13) super.valuesRow(); + public Row14 valuesRow() { + return (Row14) super.valuesRow(); } @Override @@ -263,42 +277,47 @@ public class TableColumnDocumentRecord extends UpdatableRecordImpl field6() { - return TableColumnDocument.TABLE_COLUMN_DOCUMENT.COMMENT; + public Field field6() { + return TableColumnDocument.TABLE_COLUMN_DOCUMENT.DATA_TYPE; } @Override public Field field7() { + return TableColumnDocument.TABLE_COLUMN_DOCUMENT.COMMENT; + } + + @Override + public Field field8() { return TableColumnDocument.TABLE_COLUMN_DOCUMENT.DEFAULT_VALUE; } @Override - public Field field8() { + public Field field9() { return TableColumnDocument.TABLE_COLUMN_DOCUMENT.SIZE; } @Override - public Field field9() { + public Field field10() { return TableColumnDocument.TABLE_COLUMN_DOCUMENT.DECIMAL_DIGITS; } @Override - public Field field10() { + public Field field11() { return TableColumnDocument.TABLE_COLUMN_DOCUMENT.IS_PRIMARY_KEY; } @Override - public Field field11() { + public Field field12() { return TableColumnDocument.TABLE_COLUMN_DOCUMENT.NULLABLE; } @Override - public Field field12() { + public Field field13() { return TableColumnDocument.TABLE_COLUMN_DOCUMENT.AUTO_INCREMENT; } @Override - public Field field13() { + public Field field14() { return TableColumnDocument.TABLE_COLUMN_DOCUMENT.CREATE_AT; } @@ -328,42 +347,47 @@ public class TableColumnDocumentRecord extends UpdatableRecordImpl { + + public MockDataTypeConverter() { + super(String.class, MockDataType.class); + } + +} diff --git a/dao/src/main/java/com/databasir/dao/enums/MockDataType.java b/dao/src/main/java/com/databasir/dao/enums/MockDataType.java new file mode 100644 index 0000000..31c1508 --- /dev/null +++ b/dao/src/main/java/com/databasir/dao/enums/MockDataType.java @@ -0,0 +1,25 @@ +package com.databasir.dao.enums; + +import java.util.List; + +public enum MockDataType { + + // java faker supported type + PHONE, + EMAIL, + FULL_NAME, + FULL_ADDRESS, + AVATAR_URL, + UUID, + + // databasir custom type + SCRIPT, + CONSTANT, + REF, + AUTO, + ; + + public static List fakerTypes() { + return List.of(PHONE, EMAIL, FULL_NAME, FULL_ADDRESS, AVATAR_URL, UUID); + } +} diff --git a/dao/src/main/java/com/databasir/dao/impl/MockDataRuleDao.java b/dao/src/main/java/com/databasir/dao/impl/MockDataRuleDao.java new file mode 100644 index 0000000..79ee4c2 --- /dev/null +++ b/dao/src/main/java/com/databasir/dao/impl/MockDataRuleDao.java @@ -0,0 +1,61 @@ +package com.databasir.dao.impl; + +import com.databasir.dao.tables.pojos.MockDataRulePojo; +import com.databasir.dao.tables.records.MockDataRuleRecord; +import lombok.Getter; +import org.jooq.DSLContext; +import org.jooq.InsertReturningStep; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Repository; + +import java.util.Collection; +import java.util.List; +import java.util.stream.Collectors; + +import static com.databasir.dao.Tables.MOCK_DATA_RULE; + +@Repository +public class MockDataRuleDao extends BaseDao { + + @Autowired + @Getter + private DSLContext dslContext; + + public MockDataRuleDao() { + super(MOCK_DATA_RULE, MockDataRulePojo.class); + } + + public List selectByProjectId(Integer projectId) { + return this.getDslContext() + .selectFrom(MOCK_DATA_RULE) + .where(MOCK_DATA_RULE.PROJECT_ID.eq(projectId)) + .fetchInto(MockDataRulePojo.class); + } + + public List selectByProjectIdAndTableName(Integer projectId, String tableName) { + return this.getDslContext() + .selectFrom(MOCK_DATA_RULE) + .where(MOCK_DATA_RULE.PROJECT_ID.eq(projectId) + .and(MOCK_DATA_RULE.TABLE_NAME.eq(tableName))) + .fetchInto(MockDataRulePojo.class); + } + + public void batchSave(Collection data) { + if (data == null || data.isEmpty()) { + return; + } + List> query = data.stream() + .map(pojo -> getDslContext() + .insertInto(MOCK_DATA_RULE) + .set(getDslContext().newRecord(MOCK_DATA_RULE, pojo)) + .onDuplicateKeyUpdate() + .set(MOCK_DATA_RULE.MOCK_DATA_TYPE, pojo.getMockDataType()) + .set(MOCK_DATA_RULE.MOCK_DATA_SCRIPT, pojo.getMockDataScript()) + .set(MOCK_DATA_RULE.DEPENDENT_COLUMN_NAME, pojo.getDependentColumnName()) + .set(MOCK_DATA_RULE.DEPENDENT_TABLE_NAME, pojo.getDependentTableName()) + ) + .collect(Collectors.toList()); + getDslContext().batch(query).execute(); + } + +} \ No newline at end of file diff --git a/dao/src/main/java/com/databasir/dao/impl/TableColumnDocumentDao.java b/dao/src/main/java/com/databasir/dao/impl/TableColumnDocumentDao.java index b1a2c53..6552b1c 100644 --- a/dao/src/main/java/com/databasir/dao/impl/TableColumnDocumentDao.java +++ b/dao/src/main/java/com/databasir/dao/impl/TableColumnDocumentDao.java @@ -40,4 +40,17 @@ public class TableColumnDocumentDao extends BaseDao { .and(TABLE_COLUMN_DOCUMENT.TABLE_DOCUMENT_ID.in(tableIdIn))) .fetchInto(TableColumnDocumentPojo.class); } + + public List selectByTableDocumentId(Integer tableDocumentId) { + return getDslContext() + .selectFrom(TABLE_COLUMN_DOCUMENT) + .where(TABLE_COLUMN_DOCUMENT.TABLE_DOCUMENT_ID.eq(tableDocumentId)) + .fetchInto(TableColumnDocumentPojo.class); + } + + public boolean exists(Integer tableDocumentId, String columnName) { + return getDslContext() + .fetchExists(TABLE_COLUMN_DOCUMENT, TABLE_COLUMN_DOCUMENT.TABLE_DOCUMENT_ID.eq(tableDocumentId) + .and(TABLE_COLUMN_DOCUMENT.NAME.eq(columnName))); + } } diff --git a/dao/src/main/java/com/databasir/dao/impl/TableDocumentDao.java b/dao/src/main/java/com/databasir/dao/impl/TableDocumentDao.java index d14fd84..12abef7 100644 --- a/dao/src/main/java/com/databasir/dao/impl/TableDocumentDao.java +++ b/dao/src/main/java/com/databasir/dao/impl/TableDocumentDao.java @@ -1,5 +1,6 @@ package com.databasir.dao.impl; +import com.databasir.dao.tables.pojos.TableColumnDocumentPojo; import com.databasir.dao.tables.pojos.TableDocumentPojo; import lombok.Getter; import org.jooq.DSLContext; @@ -8,6 +9,7 @@ import org.springframework.stereotype.Repository; import java.util.Collections; import java.util.List; +import java.util.Optional; import static com.databasir.dao.Tables.TABLE_DOCUMENT; @@ -29,12 +31,6 @@ public class TableDocumentDao extends BaseDao { .fetchInto(TableDocumentPojo.class); } - public void deleteByDatabaseDocumentId(Integer schemaDocumentId) { - getDslContext() - .deleteFrom(TABLE_DOCUMENT).where(TABLE_DOCUMENT.DATABASE_DOCUMENT_ID.eq(schemaDocumentId)) - .execute(); - } - public List selectByDatabaseDocumentIdAndIdIn(Integer databaseDocumentId, List idList) { if (idList == null || idList.isEmpty()) { @@ -46,4 +42,22 @@ public class TableDocumentDao extends BaseDao { .and(TABLE_DOCUMENT.ID.in(idList))) .fetchInto(TableDocumentPojo.class); } + + public Optional selectByDatabaseDocumentIdAndTableName(Integer databaseDocumentId, + String tableName) { + return getDslContext() + .select(TABLE_DOCUMENT.fields()).from(TABLE_DOCUMENT) + .where(TABLE_DOCUMENT.DATABASE_DOCUMENT_ID.eq(databaseDocumentId) + .and(TABLE_DOCUMENT.NAME.eq(tableName))) + .fetchOptionalInto(TableColumnDocumentPojo.class); + } + + public Optional selectByDatabaseDocumentIdAndId(Integer databaseDocumentId, + Integer id) { + return getDslContext() + .selectFrom(TABLE_DOCUMENT) + .where(TABLE_DOCUMENT.DATABASE_DOCUMENT_ID.eq(databaseDocumentId) + .and(TABLE_DOCUMENT.ID.eq(id))) + .fetchOptionalInto(TableDocumentPojo.class); + } } diff --git a/dao/src/main/resources/db/migration/V1.2__mock_data.sql b/dao/src/main/resources/db/migration/V1.2__mock_data.sql new file mode 100644 index 0000000..acfcb64 --- /dev/null +++ b/dao/src/main/resources/db/migration/V1.2__mock_data.sql @@ -0,0 +1,18 @@ +CREATE TABLE IF NOT EXISTS mock_data_rule +( + `id` INT PRIMARY KEY AUTO_INCREMENT, + `project_id` INT NOT NULL, + `table_name` VARCHAR(255) NOT NULL, + `column_name` VARCHAR(255) NOT NULL, + `dependent_table_name` VARCHAR(255) DEFAULT NULL, + `dependent_column_name` VARCHAR(255) DEFAULT NULL, + `mock_data_type` VARCHAR(255) NOT NULL DEFAULT 'AUTO / REF / SCRIPT / PHONE / DATE / TIMESTAMP / ...', + `mock_data_script` TEXT DEFAULT NULL, + `update_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + `create_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + CONSTRAINT UNIQUE uk_project_id_table_name_column_name (project_id, table_name, column_name) +) CHARSET utf8mb4 + COLLATE utf8mb4_unicode_ci; + +ALTER TABLE databasir.table_column_document + ADD COLUMN data_type INT NOT NULL DEFAULT 99999 AFTER type; \ No newline at end of file diff --git a/plugin/src/main/java/com/databasir/core/meta/data/ColumnMeta.java b/plugin/src/main/java/com/databasir/core/meta/data/ColumnMeta.java index b008694..58b2c36 100644 --- a/plugin/src/main/java/com/databasir/core/meta/data/ColumnMeta.java +++ b/plugin/src/main/java/com/databasir/core/meta/data/ColumnMeta.java @@ -17,6 +17,8 @@ public class ColumnMeta { private String type; + private Integer dataType; + /** * if default value is empty string, will be converted to ''. */ diff --git a/plugin/src/main/java/com/databasir/core/meta/repository/impl/jdbc/JdbcColumnMetaRepository.java b/plugin/src/main/java/com/databasir/core/meta/repository/impl/jdbc/JdbcColumnMetaRepository.java index 530b8d8..88f20c8 100644 --- a/plugin/src/main/java/com/databasir/core/meta/repository/impl/jdbc/JdbcColumnMetaRepository.java +++ b/plugin/src/main/java/com/databasir/core/meta/repository/impl/jdbc/JdbcColumnMetaRepository.java @@ -67,8 +67,10 @@ public class JdbcColumnMetaRepository implements ColumnMetaRepository { Integer columnSize = columnsResult.getInt("COLUMN_SIZE"); String columnType = columnsResult.getString("TYPE_NAME"); String columnComment = columnsResult.getString("REMARKS"); + int dataType = columnsResult.getInt("DATA_TYPE"); ColumnMeta columnMeta = ColumnMeta.builder() .name(columnName) + .dataType(dataType) .type(columnType) .size(columnSize) .decimalDigits(decimalDigits) @@ -80,7 +82,6 @@ public class JdbcColumnMetaRepository implements ColumnMetaRepository { .build(); columnDocs.add(columnMeta); } - } return columnDocs; }