From 2138b4290947c4ef7adcc29b0c1cde6ef463ce9a Mon Sep 17 00:00:00 2001 From: taojinlong Date: Wed, 27 Mar 2024 17:12:44 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E5=A2=9E=E5=8A=A0=E6=95=B0=E6=8D=AE?= =?UTF-8?q?=E5=AF=BC=E5=87=BA=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../dataset/DataSetTableController.java | 8 +- .../exportCenter/ExportCenterController.java | 38 + .../exportCenter/ExportCenterService.java | 884 ++++++++++++++++++ .../resources/db/migration/V62__1.18.18.sql | 18 +- .../common/base/domain/ExportTask.java | 27 + .../common/base/domain/ExportTaskExample.java | 800 ++++++++++++++++ .../common/base/mapper/ExportTaskMapper.java | 30 + .../common/base/mapper/ExportTaskMapper.xml | 276 ++++++ 8 files changed, 2077 insertions(+), 4 deletions(-) create mode 100644 core/backend/src/main/java/io/dataease/controller/exportCenter/ExportCenterController.java create mode 100644 core/backend/src/main/java/io/dataease/service/exportCenter/ExportCenterService.java create mode 100644 sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/domain/ExportTask.java create mode 100644 sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/domain/ExportTaskExample.java create mode 100644 sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/mapper/ExportTaskMapper.java create mode 100644 sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/mapper/ExportTaskMapper.xml diff --git a/core/backend/src/main/java/io/dataease/controller/dataset/DataSetTableController.java b/core/backend/src/main/java/io/dataease/controller/dataset/DataSetTableController.java index c516dad14e..b93069ad2f 100644 --- a/core/backend/src/main/java/io/dataease/controller/dataset/DataSetTableController.java +++ b/core/backend/src/main/java/io/dataease/controller/dataset/DataSetTableController.java @@ -27,13 +27,13 @@ import io.dataease.plugins.common.dto.dataset.SqlVariableDetails; import io.dataease.plugins.common.dto.datasource.TableField; import io.dataease.service.authModel.VAuthModelService; import io.dataease.service.dataset.DataSetTableService; +import io.dataease.service.exportCenter.ExportCenterService; import io.swagger.annotations.*; import org.apache.shiro.authz.annotation.Logical; import org.springframework.web.bind.annotation.*; import org.springframework.web.multipart.MultipartFile; import javax.annotation.Resource; -import javax.servlet.http.HttpServletResponse; import java.util.Collections; import java.util.List; import java.util.Map; @@ -53,6 +53,8 @@ public class DataSetTableController { @Resource private VAuthModelService vAuthModelService; + @Resource + private ExportCenterService exportCenterService; @DePermissions(value = { @DePermission(type = DePermissionType.DATASET, value = "id"), @@ -269,7 +271,7 @@ public class DataSetTableController { @ApiOperation("数据集导出") @PostMapping("/exportDataset") @I18n - public void exportDataset(@RequestBody DataSetExportRequest request, HttpServletResponse response) throws Exception { - dataSetTableService.exportDataset(request, response); + public void exportDataset(@RequestBody DataSetExportRequest request) { + exportCenterService.addTask(request.getId(), "dataset", request); } } diff --git a/core/backend/src/main/java/io/dataease/controller/exportCenter/ExportCenterController.java b/core/backend/src/main/java/io/dataease/controller/exportCenter/ExportCenterController.java new file mode 100644 index 0000000000..8406c2bde7 --- /dev/null +++ b/core/backend/src/main/java/io/dataease/controller/exportCenter/ExportCenterController.java @@ -0,0 +1,38 @@ +package io.dataease.controller.exportCenter; + +import com.github.xiaoymin.knife4j.annotations.ApiSupport; + +import io.dataease.controller.request.dataset.DataSetExportRequest; + +import io.dataease.plugins.common.base.domain.ExportTask; + +import io.dataease.service.exportCenter.ExportCenterService; + +import org.springframework.web.bind.annotation.*; + +import javax.annotation.Resource; + +import java.util.List; + +@ApiSupport(order = 31) +@RequestMapping("exportCenter") +@RestController +public class ExportCenterController { + + @Resource + private ExportCenterService exportCenterService; + + + + @PostMapping("/exportTasks/{status}") + public List exportTasks(@PathVariable String status) { + return exportCenterService.exportTasks(status); + } + + + @PostMapping("/exportTasks/{status}") + public void addTask(String exportFrom, String exportFromType, DataSetExportRequest request){ + + } + +} diff --git a/core/backend/src/main/java/io/dataease/service/exportCenter/ExportCenterService.java b/core/backend/src/main/java/io/dataease/service/exportCenter/ExportCenterService.java new file mode 100644 index 0000000000..cddda63386 --- /dev/null +++ b/core/backend/src/main/java/io/dataease/service/exportCenter/ExportCenterService.java @@ -0,0 +1,884 @@ +package io.dataease.service.exportCenter; + + +import com.google.gson.Gson; +import io.dataease.commons.constants.JobStatus; +import io.dataease.commons.utils.AuthUtils; +import io.dataease.commons.utils.CommonBeanFactory; +import io.dataease.commons.utils.LogUtil; +import io.dataease.commons.utils.TableUtils; +import io.dataease.controller.dataset.request.DataSetTaskInstanceGridRequest; +import io.dataease.controller.request.dataset.DataSetExportRequest; +import io.dataease.controller.request.dataset.DataSetTableRequest; +import io.dataease.dto.dataset.DataSetPreviewPage; +import io.dataease.dto.dataset.DataSetTableUnionDTO; +import io.dataease.dto.dataset.DataSetTaskLogDTO; +import io.dataease.i18n.Translator; +import io.dataease.plugins.common.base.domain.*; +import io.dataease.plugins.common.base.mapper.DatasetTableMapper; +import io.dataease.plugins.common.base.mapper.DatasourceMapper; +import io.dataease.plugins.common.base.mapper.ExportTaskMapper; +import io.dataease.plugins.common.constants.DatasetType; +import io.dataease.plugins.common.constants.DeTypeConstants; +import io.dataease.plugins.common.dto.dataset.DataTableInfoDTO; +import io.dataease.plugins.common.exception.DataEaseException; +import io.dataease.plugins.common.request.datasource.DatasourceRequest; +import io.dataease.plugins.common.request.permission.DataSetRowPermissionsTreeDTO; +import io.dataease.plugins.common.request.permission.DatasetRowPermissionsTreeObj; +import io.dataease.plugins.datasource.provider.Provider; +import io.dataease.plugins.datasource.provider.ProviderFactory; +import io.dataease.plugins.datasource.query.QueryProvider; +import io.dataease.plugins.xpack.auth.dto.request.ColumnPermissionItem; +import io.dataease.provider.datasource.JdbcProvider; +import io.dataease.service.chart.util.ChartDataBuild; +import io.dataease.service.dataset.*; +import io.dataease.service.datasource.DatasourceService; +import io.dataease.service.engine.EngineService; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.ObjectUtils; +import org.apache.commons.lang3.StringUtils; +import org.apache.poi.ss.usermodel.*; +import org.apache.poi.xssf.streaming.SXSSFWorkbook; +import org.apache.poi.xssf.usermodel.XSSFWorkbook; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; + +import javax.annotation.PostConstruct; +import javax.annotation.Resource; +import javax.servlet.http.HttpServletResponse; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.text.DecimalFormat; +import java.util.*; +import java.util.concurrent.ScheduledThreadPoolExecutor; +import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; + + +@Service +public class ExportCenterService { + + @Resource + private ExportTaskMapper exportTaskMapper; + @Value("${export.dataset.limit:100000}") + private int limit; + + private static final String exportData_path = "/opt/dataease/data/exportData/"; + + @Value("${extract.page.size:50000}") + private Integer extractPageSize; + static private List STATUS = Arrays.asList("SUCCESS", "FAILED", "PENDING", "IN_PROGRESS", "ALL"); + + private ScheduledThreadPoolExecutor scheduledThreadPoolExecutor; + @Resource + private DataSetTableService dataSetTableService; + @Resource + private DataSetTableUnionService dataSetTableUnionService; + @Resource + private EngineService engineService; + @Resource + private DatasetTableMapper datasetTableMapper; + @Resource + private DatasourceMapper datasourceMapper; + @Resource + private DataSetTableFieldsService dataSetTableFieldsService; + @Resource + private PermissionsTreeService permissionsTreeService; + @Resource + private DatasourceService datasourceService; + @Resource + private PermissionService permissionService; + + private int corePoolSize = 10; + private int keepAliveSeconds = 600; + + @PostConstruct + public void init() { + scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(corePoolSize); + scheduledThreadPoolExecutor.setKeepAliveTime(keepAliveSeconds, TimeUnit.SECONDS); + } + + public List exportTasks(String status) { + if (!STATUS.contains(status)) { + DataEaseException.throwException("Invalid status: " + status); + } + ExportTaskExample exportTaskExample = new ExportTaskExample(); + ExportTaskExample.Criteria criteria = exportTaskExample.createCriteria(); + if (!status.equalsIgnoreCase("ALL")) { + criteria.andExportStatusEqualTo(status); + } + criteria.andUserIdEqualTo(AuthUtils.getUser().getUserId()); + return exportTaskMapper.selectByExample(exportTaskExample); + } + + public void addTask(String exportFrom, String exportFromType, DataSetExportRequest request) { + ExportTask exportTask = new ExportTask(); + exportTask.setId(UUID.randomUUID().toString()); + exportTask.setUserId(AuthUtils.getUser().getUserId()); + exportTask.setExportFrom(exportFrom); + exportTask.setExportFromType(exportFromType); + exportTask.setExportStatus("PENDING"); + exportTask.setFileName(request.getFilename() + ".xlsx"); + exportTask.setExportPogress("0"); + exportTask.setExportTime(System.currentTimeMillis()); + exportTaskMapper.insert(exportTask); + + String dataPath = exportData_path + exportTask.getId(); + File directory = new File(dataPath); + boolean isCreated = directory.mkdir(); + + + scheduledThreadPoolExecutor.execute(() -> { + try { + exportTask.setExportStatus("IN_PROGRESS"); + exportTaskMapper.updateByPrimaryKey(exportTask); + DatasetRowPermissionsTreeObj tree = null; + if (StringUtils.isNotEmpty(request.getExpressionTree())) { + Gson gson = new Gson(); + tree = gson.fromJson(request.getExpressionTree(), DatasetRowPermissionsTreeObj.class); + permissionsTreeService.getField(tree); + } + Datasource datasource = datasourceService.get(request.getDataSourceId()); + + Integer totalCount = getTotal(request, limit, tree); + + if (totalCount == null) { + + Workbook wb = new SXSSFWorkbook(); + // Sheet + Sheet detailsSheet = wb.createSheet("数据"); + //给单元格设置样式 + CellStyle cellStyle = wb.createCellStyle(); + Font font = wb.createFont(); + //设置字体大小 + font.setFontHeightInPoints((short) 12); + //设置字体加粗 + font.setBold(true); + //给字体设置样式 + cellStyle.setFont(font); + //设置单元格背景颜色 + cellStyle.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex()); + //设置单元格填充样式(使用纯色背景颜色填充) + cellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND); + + int pageSize = (datasource != null && StringUtils.equalsIgnoreCase(datasource.getType(), "es")) ? 10000 : limit; + request.setRow(String.valueOf(pageSize)); + Map previewData = dataSetTableService.getPreviewData(request, 1, pageSize, null, tree); + List fields = (List) previewData.get("fields"); + List> data = (List>) previewData.get("data"); + List header = new ArrayList<>(); + for (DatasetTableField field : fields) { + header.add(field.getName()); + } + + List> details = new ArrayList<>(); + details.add(header); + + for (Map obj : data) { + List row = new ArrayList<>(); + for (DatasetTableField field : fields) { + String string = (String) obj.get(field.getDataeaseName()); + row.add(string); + } + details.add(row); + } + if (CollectionUtils.isNotEmpty(details)) { + for (int i = 0; i < details.size(); i++) { + Row row = detailsSheet.createRow(i); + List rowData = details.get(i); + if (rowData != null) { + for (int j = 0; j < rowData.size(); j++) { + Cell cell = row.createCell(j); + if (i == 0) {// 头部 + cell.setCellValue(rowData.get(j)); + cell.setCellStyle(cellStyle); + //设置列的宽度 + detailsSheet.setColumnWidth(j, 255 * 20); + } else { + if ((fields.get(j).getDeType().equals(DeTypeConstants.DE_INT) || fields.get(j).getDeType() == DeTypeConstants.DE_FLOAT) && StringUtils.isNotEmpty(rowData.get(j))) { + try { + cell.setCellValue(Double.valueOf(rowData.get(j))); + } catch (Exception e) { + LogUtil.warn("export excel data transform error"); + } + } else { + cell.setCellValue(rowData.get(j)); + } + } + } + } + } + } + + try (FileOutputStream outputStream = new FileOutputStream(dataPath + "/" + request.getFilename() + ".xlsx")) { + wb.write(outputStream); + } + wb.close(); + } else { + Integer totalPage = (totalCount / extractPageSize) + (totalCount % extractPageSize > 0 ? 1 : 0); + List> details = new ArrayList<>(); + List fields = new ArrayList<>(); + for (Integer p = 1; p < totalPage + 1; p++) { + Integer offset = p * extractPageSize; + Integer all = offset + extractPageSize; + + Map previewData = getPreviewData(request, p, extractPageSize, all, null, tree); + + Workbook wb = null; + Sheet detailsSheet = null; + CellStyle cellStyle = null; + FileInputStream fis = null; + if (p == 0L) { + wb = new SXSSFWorkbook(); + // Sheet + detailsSheet = wb.createSheet("数据"); + //给单元格设置样式 + cellStyle = wb.createCellStyle(); + Font font = wb.createFont(); + //设置字体大小 + font.setFontHeightInPoints((short) 12); + //设置字体加粗 + font.setBold(true); + //给字体设置样式 + cellStyle.setFont(font); + //设置单元格背景颜色 + cellStyle.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex()); + //设置单元格填充样式(使用纯色背景颜色填充) + cellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND); + fields = (List) previewData.get("fields"); + List header = new ArrayList<>(); + for (DatasetTableField field : fields) { + header.add(field.getName()); + } + details.add(header); + } else { + fis = new FileInputStream("existing_file.xlsx"); + wb = new XSSFWorkbook(fis); // 假设这是个.xlsx格式的文件 + detailsSheet = wb.getSheetAt(0); + } + + List> data = (List>) previewData.get("data"); + for (Map obj : data) { + List row = new ArrayList<>(); + for (DatasetTableField field : fields) { + String string = (String) obj.get(field.getDataeaseName()); + row.add(string); + } + details.add(row); + } + + + if (CollectionUtils.isNotEmpty(details)) { + for (int i = 0; i < details.size(); i++) { + Row row = detailsSheet.createRow(i); + List rowData = details.get(i); + if (rowData != null) { + for (int j = 0; j < rowData.size(); j++) { + Cell cell = row.createCell(j); + if (i == 0) {// 头部 + cell.setCellValue(rowData.get(j)); + cell.setCellStyle(cellStyle); + //设置列的宽度 + detailsSheet.setColumnWidth(j, 255 * 20); + } else { + if ((fields.get(j).getDeType().equals(DeTypeConstants.DE_INT) || fields.get(j).getDeType() == DeTypeConstants.DE_FLOAT) && StringUtils.isNotEmpty(rowData.get(j))) { + try { + cell.setCellValue(Double.valueOf(rowData.get(j))); + } catch (Exception e) { + LogUtil.warn("export excel data transform error"); + } + } else { + cell.setCellValue(rowData.get(j)); + } + } + } + } + } + } + if (p == 1) { + try (FileOutputStream outputStream = new FileOutputStream(dataPath + "/" + request.getFilename() + ".xlsx")) { + wb.write(outputStream); + } + wb.close(); + } else { + fis.close(); + wb.close(); + } + + + exportTask.setExportStatus("IN_PROGRESS"); + double exportRogress = (double) (p / totalCount); + DecimalFormat df = new DecimalFormat("#.##"); + String formattedResult = df.format(exportRogress * 100); + exportTask.setExportPogress(formattedResult); + exportTaskMapper.updateByPrimaryKey(exportTask); + + + } + + } + exportTask.setExportStatus("SUCCESS"); + } catch (Exception e) { + exportTask.setExportStatus("FAILED"); + } finally { + exportTaskMapper.updateByPrimaryKey(exportTask); + } + }); + + + } + + public Boolean checkEngineTableIsExists(String id) throws Exception { + Datasource engine = engineService.getDeEngine(); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(engine); + QueryProvider qp = ProviderFactory.getQueryProvider(engine.getType()); + datasourceRequest.setQuery(qp.searchTable(TableUtils.tableName(id))); + List data = jdbcProvider.getData(datasourceRequest); + return CollectionUtils.isNotEmpty(data); + } + + private Integer getTotal(DataSetTableRequest dataSetTableRequest, Integer limit, DatasetRowPermissionsTreeObj extTree) throws Exception { + DatasetTableField datasetTableField = DatasetTableField.builder().tableId(dataSetTableRequest.getId()).checked(Boolean.TRUE).build(); + List fields = dataSetTableFieldsService.list(datasetTableField); + if (CollectionUtils.isEmpty(fields)) { + return null; + } + DatasetTable datasetTable = datasetTableMapper.selectByPrimaryKey(dataSetTableRequest.getId()); + // 行权限 + List rowPermissionsTree = permissionsTreeService.getRowPermissionsTree(fields, datasetTable, null); + // ext filter + if (extTree != null) { + DataSetRowPermissionsTreeDTO dto = new DataSetRowPermissionsTreeDTO(); + dto.setTree(extTree); + rowPermissionsTree.add(dto); + } + // 列权限 + Map desensitizationList = new HashMap<>(); + fields = permissionService.filterColumnPermissions(fields, desensitizationList, datasetTable.getId(), null); + if (CollectionUtils.isEmpty(fields)) { + return null; + } + DataTableInfoDTO dataTableInfoDTO = new Gson().fromJson(dataSetTableRequest.getInfo(), DataTableInfoDTO.class); + if (StringUtils.equalsIgnoreCase(datasetTable.getType(), DatasetType.DB.name()) || StringUtils.equalsIgnoreCase(datasetTable.getType(), DatasetType.API.name())) { + if (datasetTable.getMode() == 0) { + Datasource ds = datasourceMapper.selectByPrimaryKey(dataSetTableRequest.getDataSourceId()); + if (ObjectUtils.isEmpty(ds)) { + throw new RuntimeException(Translator.get("i18n_datasource_delete")); + } + if (StringUtils.isNotEmpty(ds.getStatus()) && ds.getStatus().equalsIgnoreCase("Error")) { + throw new Exception(Translator.get("i18n_invalid_ds")); + } + Provider datasourceProvider = ProviderFactory.getProvider(ds.getType()); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = dataTableInfoDTO.getTable(); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + try { + String totalSql = qp.getTotalCount(false, qp.createQuerySQL(table, fields, false, ds, null, rowPermissionsTree), ds); + if (totalSql == null) { + return null; + } + datasourceRequest.setQuery(totalSql); + List tmpData = datasourceProvider.getData(datasourceRequest); + return CollectionUtils.isEmpty(tmpData) ? 0 : Integer.valueOf(tmpData.get(0)[0]); + } catch (Exception e) { + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + } else { + // check doris table + if (!checkEngineTableIsExists(dataSetTableRequest.getId())) { + if (dataSetTableRequest.isPreviewForTask()) { + return null; + } else { + throw new RuntimeException(Translator.get("i18n_data_not_sync")); + } + } + Datasource ds = engineService.getDeEngine(); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = TableUtils.tableName(dataSetTableRequest.getId()); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + + try { + String totalSql = qp.getTotalCount(false, qp.createQuerySQL(table, fields, false, ds, null, rowPermissionsTree), ds); + if (totalSql == null) { + return null; + } + datasourceRequest.setQuery(totalSql); + List tmpData = jdbcProvider.getData(datasourceRequest); + return CollectionUtils.isEmpty(tmpData) ? 0 : Integer.valueOf(tmpData.get(0)[0]); + } catch (Exception e) { + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + } + + } else if (StringUtils.equalsIgnoreCase(datasetTable.getType(), DatasetType.SQL.name())) { + if (datasetTable.getMode() == 0) { + Datasource ds = datasourceMapper.selectByPrimaryKey(dataSetTableRequest.getDataSourceId()); + if (ObjectUtils.isEmpty(ds)) { + throw new RuntimeException(Translator.get("i18n_datasource_delete")); + } + if (StringUtils.isNotEmpty(ds.getStatus()) && ds.getStatus().equalsIgnoreCase("Error")) { + throw new Exception(Translator.get("i18n_invalid_ds")); + } + Provider datasourceProvider = ProviderFactory.getProvider(ds.getType()); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + DataTableInfoDTO dataTableInfo = new Gson().fromJson(datasetTable.getInfo(), DataTableInfoDTO.class); + String sql = dataTableInfo.isBase64Encryption() ? new String(java.util.Base64.getDecoder().decode(dataTableInfo.getSql())) : dataTableInfo.getSql(); + sql = dataSetTableService.handleVariableDefaultValue(sql, datasetTable.getSqlVariableDetails(), ds.getType(), false); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + try { + String totalSql = qp.getTotalCount(false, qp.createQuerySQLAsTmp(sql, fields, false, null, rowPermissionsTree), ds); + if (totalSql == null) { + return null; + } + datasourceRequest.setQuery(totalSql); + List tmpData = datasourceProvider.getData(datasourceRequest); + return CollectionUtils.isEmpty(tmpData) ? 0 : Integer.valueOf(tmpData.get(0)[0]); + } catch (Exception e) { + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + } else { + // check doris table + if (!checkEngineTableIsExists(dataSetTableRequest.getId())) { + throw new RuntimeException(Translator.get("i18n_data_not_sync")); + } + Datasource ds = engineService.getDeEngine(); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = TableUtils.tableName(dataSetTableRequest.getId()); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + + + try { + String totalSql = qp.getTotalCount(true, qp.createQuerySQL(table, fields, false, ds, null, rowPermissionsTree), ds); + if (totalSql == null) { + return null; + } + datasourceRequest.setQuery(totalSql); + List tmpData = jdbcProvider.getData(datasourceRequest); + return CollectionUtils.isEmpty(tmpData) ? 0 : Integer.valueOf(tmpData.get(0)[0]); + } catch (Exception e) { + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + } + } else if (StringUtils.equalsIgnoreCase(datasetTable.getType(), "excel")) { + if (!checkEngineTableIsExists(dataSetTableRequest.getId())) { + throw new RuntimeException(Translator.get("i18n_data_not_sync")); + } + + Datasource ds = engineService.getDeEngine(); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = TableUtils.tableName(dataSetTableRequest.getId()); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + try { + String totalSql = qp.getTotalCount(true, qp.createQuerySQL(table, fields, false, ds, null, rowPermissionsTree), ds); + if (totalSql == null) { + return null; + } + datasourceRequest.setQuery(totalSql); + List tmpData = jdbcProvider.getData(datasourceRequest); + return CollectionUtils.isEmpty(tmpData) ? 0 : Integer.valueOf(tmpData.get(0)[0]); + } catch (Exception e) { + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + + } else if (StringUtils.equalsIgnoreCase(datasetTable.getType(), "custom")) { + if (datasetTable.getMode() == 0) { + Datasource ds = datasourceMapper.selectByPrimaryKey(dataSetTableRequest.getDataSourceId()); + if (ObjectUtils.isEmpty(ds)) { + throw new RuntimeException(Translator.get("i18n_datasource_delete")); + } + Provider datasourceProvider = ProviderFactory.getProvider(ds.getType()); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + + DataTableInfoDTO dt = new Gson().fromJson(datasetTable.getInfo(), DataTableInfoDTO.class); + List list = dataSetTableUnionService.listByTableId(dt.getList().get(0).getTableId()); + + String sql = ""; + try { + sql = dataSetTableService.getCustomSQLDatasource(dt, list, ds); + } catch (Exception e) { + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + try { + String totalSql = qp.getTotalCount(false, qp.createQuerySQLAsTmp(sql, fields, false, null, rowPermissionsTree), ds); + if (totalSql == null) { + return null; + } + datasourceRequest.setQuery(totalSql); + List tmpData = datasourceProvider.getData(datasourceRequest); + return CollectionUtils.isEmpty(tmpData) ? 0 : Integer.valueOf(tmpData.get(0)[0]); + } catch (Exception e) { + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + + } else { + Datasource ds = engineService.getDeEngine(); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = TableUtils.tableName(dataSetTableRequest.getId()); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + try { + String totalSql = qp.getTotalCount(true, qp.createQuerySQL(table, fields, false, ds, null, rowPermissionsTree), ds); + if (totalSql == null) { + return null; + } + datasourceRequest.setQuery(totalSql); + List tmpData = jdbcProvider.getData(datasourceRequest); + return CollectionUtils.isEmpty(tmpData) ? 0 : Integer.valueOf(tmpData.get(0)[0]); + } catch (Exception e) { + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + } + } else if (StringUtils.equalsIgnoreCase(datasetTable.getType(), "union")) { + if (datasetTable.getMode() == 0) { + Datasource ds = datasourceMapper.selectByPrimaryKey(dataSetTableRequest.getDataSourceId()); + if (ObjectUtils.isEmpty(ds)) { + DataEaseException.throwException(Translator.get("i18n_datasource_delete")); + } + Provider datasourceProvider = ProviderFactory.getProvider(ds.getType()); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + + DataTableInfoDTO dt = new Gson().fromJson(datasetTable.getInfo(), DataTableInfoDTO.class); + + String sql = ""; + try { + sql = (String) dataSetTableService.getUnionSQLDatasource(dt, ds).get("sql"); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + try { + String totalSql = qp.getTotalCount(true, qp.createQuerySQLAsTmp(sql, fields, false, null, rowPermissionsTree), ds); + if (totalSql == null) { + return null; + } + datasourceRequest.setQuery(totalSql); + List tmpData = datasourceProvider.getData(datasourceRequest); + return CollectionUtils.isEmpty(tmpData) ? 0 : Integer.valueOf(tmpData.get(0)[0]); + } catch (Exception e) { + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + } else { + Datasource ds = engineService.getDeEngine(); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = TableUtils.tableName(dataSetTableRequest.getId()); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + try { + String totalSql = qp.getTotalCount(true, qp.createQuerySQL(table, fields, false, ds, null, rowPermissionsTree), ds); + if (totalSql == null) { + return null; + } + datasourceRequest.setQuery(totalSql); + List tmpData = jdbcProvider.getData(datasourceRequest); + return CollectionUtils.isEmpty(tmpData) ? 0 : Integer.valueOf(tmpData.get(0)[0]); + } catch (Exception e) { + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + } + } + return null; + } + + + public Map getPreviewData(DataSetTableRequest dataSetTableRequest, Integer page, Integer pageSize, Integer realSize, List extFields, DatasetRowPermissionsTreeObj extTree) throws Exception { + Map map = new HashMap<>(); + String syncStatus = ""; + DatasetTableField datasetTableField = DatasetTableField.builder().tableId(dataSetTableRequest.getId()).checked(Boolean.TRUE).build(); + List fields = dataSetTableFieldsService.list(datasetTableField); + if (CollectionUtils.isNotEmpty(extFields)) { + fields = extFields; + } + if (CollectionUtils.isEmpty(fields)) { + map.put("fields", fields); + map.put("data", new ArrayList<>()); + return map; + } + DatasetTable datasetTable = datasetTableMapper.selectByPrimaryKey(dataSetTableRequest.getId()); + // 行权限 + List rowPermissionsTree = permissionsTreeService.getRowPermissionsTree(fields, datasetTable, null); + // ext filter + if (extTree != null) { + DataSetRowPermissionsTreeDTO dto = new DataSetRowPermissionsTreeDTO(); + dto.setTree(extTree); + rowPermissionsTree.add(dto); + } + // 列权限 + Map desensitizationList = new HashMap<>(); + fields = permissionService.filterColumnPermissions(fields, desensitizationList, datasetTable.getId(), null); + if (CollectionUtils.isEmpty(fields)) { + map.put("fields", fields); + map.put("data", new ArrayList<>()); + return map; + } + + String[] fieldArray = fields.stream().map(DatasetTableField::getDataeaseName).toArray(String[]::new); + + DataTableInfoDTO dataTableInfoDTO = new Gson().fromJson(dataSetTableRequest.getInfo(), DataTableInfoDTO.class); + + List data = new ArrayList<>(); + if (StringUtils.equalsIgnoreCase(datasetTable.getType(), DatasetType.DB.name()) || StringUtils.equalsIgnoreCase(datasetTable.getType(), DatasetType.API.name())) { + if (datasetTable.getMode() == 0) { + Datasource ds = datasourceMapper.selectByPrimaryKey(dataSetTableRequest.getDataSourceId()); + if (ObjectUtils.isEmpty(ds)) { + throw new RuntimeException(Translator.get("i18n_datasource_delete")); + } + if (StringUtils.isNotEmpty(ds.getStatus()) && ds.getStatus().equalsIgnoreCase("Error")) { + throw new Exception(Translator.get("i18n_invalid_ds")); + } + Provider datasourceProvider = ProviderFactory.getProvider(ds.getType()); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = dataTableInfoDTO.getTable(); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + datasourceRequest.setQuery(qp.createQueryTableWithPage(table, fields, page, pageSize, realSize, false, ds, null, rowPermissionsTree)); + + try { + + data.addAll(datasourceProvider.getData(datasourceRequest)); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + + } else { + // check doris table + if (!checkEngineTableIsExists(dataSetTableRequest.getId())) { + if (dataSetTableRequest.isPreviewForTask()) { + map.put("fields", fields); + map.put("data", new ArrayList<>()); + map.put("page", new DataSetPreviewPage()); + return map; + } else { + throw new RuntimeException(Translator.get("i18n_data_not_sync")); + } + } + Datasource ds = engineService.getDeEngine(); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = TableUtils.tableName(dataSetTableRequest.getId()); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + datasourceRequest.setQuery(qp.createQueryTableWithPage(table, fields, page, pageSize, realSize, false, ds, null, rowPermissionsTree)); + map.put("sql", java.util.Base64.getEncoder().encodeToString(datasourceRequest.getQuery().getBytes())); + try { + data.addAll(jdbcProvider.getData(datasourceRequest)); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + + } + + } else if (StringUtils.equalsIgnoreCase(datasetTable.getType(), DatasetType.SQL.name())) { + if (datasetTable.getMode() == 0) { + Datasource ds = datasourceMapper.selectByPrimaryKey(dataSetTableRequest.getDataSourceId()); + if (ObjectUtils.isEmpty(ds)) { + throw new RuntimeException(Translator.get("i18n_datasource_delete")); + } + if (StringUtils.isNotEmpty(ds.getStatus()) && ds.getStatus().equalsIgnoreCase("Error")) { + throw new Exception(Translator.get("i18n_invalid_ds")); + } + Provider datasourceProvider = ProviderFactory.getProvider(ds.getType()); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + DataTableInfoDTO dataTableInfo = new Gson().fromJson(datasetTable.getInfo(), DataTableInfoDTO.class); + String sql = dataTableInfo.isBase64Encryption() ? new String(java.util.Base64.getDecoder().decode(dataTableInfo.getSql())) : dataTableInfo.getSql(); + sql = dataSetTableService.handleVariableDefaultValue(sql, datasetTable.getSqlVariableDetails(), ds.getType(), false); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + datasourceRequest.setQuery(qp.createQuerySQLWithPage(sql, fields, page, pageSize, realSize, false, null, rowPermissionsTree)); + map.put("sql", java.util.Base64.getEncoder().encodeToString(datasourceRequest.getQuery().getBytes())); + datasourceRequest.setPage(page); + datasourceRequest.setFetchSize(Integer.parseInt(dataSetTableRequest.getRow())); + datasourceRequest.setPageSize(pageSize); + datasourceRequest.setRealSize(realSize); + datasourceRequest.setPreviewData(true); + try { + datasourceRequest.setPageable(true); + datasourceRequest.setPermissionFields(fields); + data.addAll(datasourceProvider.getData(datasourceRequest)); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + + } else { + // check doris table + if (!checkEngineTableIsExists(dataSetTableRequest.getId())) { + throw new RuntimeException(Translator.get("i18n_data_not_sync")); + } + Datasource ds = engineService.getDeEngine(); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = TableUtils.tableName(dataSetTableRequest.getId()); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + datasourceRequest.setQuery(qp.createQueryTableWithPage(table, fields, page, pageSize, realSize, false, ds, null, rowPermissionsTree)); + map.put("sql", java.util.Base64.getEncoder().encodeToString(datasourceRequest.getQuery().getBytes())); + try { + data.addAll(jdbcProvider.getData(datasourceRequest)); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + + } + } else if (StringUtils.equalsIgnoreCase(datasetTable.getType(), "excel")) { + if (!checkEngineTableIsExists(dataSetTableRequest.getId())) { + throw new RuntimeException(Translator.get("i18n_data_not_sync")); + } + + Datasource ds = engineService.getDeEngine(); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = TableUtils.tableName(dataSetTableRequest.getId()); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + datasourceRequest.setQuery(qp.createQueryTableWithPage(table, fields, page, pageSize, realSize, false, ds, null, rowPermissionsTree)); + map.put("sql", java.util.Base64.getEncoder().encodeToString(datasourceRequest.getQuery().getBytes())); + try { + data.addAll(jdbcProvider.getData(datasourceRequest)); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + + + } else if (StringUtils.equalsIgnoreCase(datasetTable.getType(), "custom")) { + if (datasetTable.getMode() == 0) { + Datasource ds = datasourceMapper.selectByPrimaryKey(dataSetTableRequest.getDataSourceId()); + if (ObjectUtils.isEmpty(ds)) { + throw new RuntimeException(Translator.get("i18n_datasource_delete")); + } + Provider datasourceProvider = ProviderFactory.getProvider(ds.getType()); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + + DataTableInfoDTO dt = new Gson().fromJson(datasetTable.getInfo(), DataTableInfoDTO.class); + List list = dataSetTableUnionService.listByTableId(dt.getList().get(0).getTableId()); + + String sql = ""; + try { + sql = dataSetTableService.getCustomSQLDatasource(dt, list, ds); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + datasourceRequest.setQuery(qp.createQuerySQLWithPage(sql, fields, page, pageSize, realSize, false, null, rowPermissionsTree)); + map.put("sql", java.util.Base64.getEncoder().encodeToString(datasourceRequest.getQuery().getBytes())); + + try { + + data.addAll(datasourceProvider.getData(datasourceRequest)); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + + } else { + Datasource ds = engineService.getDeEngine(); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = TableUtils.tableName(dataSetTableRequest.getId()); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + datasourceRequest.setQuery(qp.createQueryTableWithPage(table, fields, page, pageSize, realSize, false, ds, null, rowPermissionsTree)); + map.put("sql", java.util.Base64.getEncoder().encodeToString(datasourceRequest.getQuery().getBytes())); + try { + data.addAll(jdbcProvider.getData(datasourceRequest)); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + + } + } else if (StringUtils.equalsIgnoreCase(datasetTable.getType(), "union")) { + if (datasetTable.getMode() == 0) { + Datasource ds = datasourceMapper.selectByPrimaryKey(dataSetTableRequest.getDataSourceId()); + if (ObjectUtils.isEmpty(ds)) { + DataEaseException.throwException(Translator.get("i18n_datasource_delete")); + } + Provider datasourceProvider = ProviderFactory.getProvider(ds.getType()); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + + DataTableInfoDTO dt = new Gson().fromJson(datasetTable.getInfo(), DataTableInfoDTO.class); + + String sql = ""; + try { + sql = (String) dataSetTableService.getUnionSQLDatasource(dt, ds).get("sql"); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + datasourceRequest.setQuery(qp.createQuerySQLWithPage(sql, fields, page, pageSize, realSize, false, null, rowPermissionsTree)); + map.put("sql", java.util.Base64.getEncoder().encodeToString(datasourceRequest.getQuery().getBytes())); + + try { + + data.addAll(datasourceProvider.getData(datasourceRequest)); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + + } else { + Datasource ds = engineService.getDeEngine(); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(ds); + String table = TableUtils.tableName(dataSetTableRequest.getId()); + QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); + datasourceRequest.setQuery(qp.createQueryTableWithPage(table, fields, page, pageSize, realSize, false, ds, null, rowPermissionsTree)); + map.put("sql", java.util.Base64.getEncoder().encodeToString(datasourceRequest.getQuery().getBytes())); + try { + data.addAll(jdbcProvider.getData(datasourceRequest)); + } catch (Exception e) { + + DataEaseException.throwException(Translator.get("i18n_ds_error") + "->" + e.getMessage()); + } + + + } + } + + List> jsonArray = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(data)) { + jsonArray = data.stream().map(ele -> { + Map tmpMap = new HashMap<>(); + for (int i = 0; i < ele.length; i++) { + if (desensitizationList.keySet().contains(fieldArray[i])) { + tmpMap.put(fieldArray[i], ChartDataBuild.desensitizationValue(desensitizationList.get(fieldArray[i]), String.valueOf(ele[i]))); + } else { + tmpMap.put(fieldArray[i], ele[i]); + } + } + return tmpMap; + }).collect(Collectors.toList()); + } + map.put("fields", fields); + map.put("data", jsonArray); + return map; + } + + +} + diff --git a/core/backend/src/main/resources/db/migration/V62__1.18.18.sql b/core/backend/src/main/resources/db/migration/V62__1.18.18.sql index 30befd3d02..96651f855f 100644 --- a/core/backend/src/main/resources/db/migration/V62__1.18.18.sql +++ b/core/backend/src/main/resources/db/migration/V62__1.18.18.sql @@ -17,4 +17,20 @@ CREATE TABLE `panel_link_ticket` ALTER TABLE `panel_link_mapping` ADD COLUMN `require_ticket` tinyint(1) NOT NULL DEFAULT 0 AFTER `uuid`; -INSERT INTO `system_parameter` (`param_key`, `param_value`, `type`, `sort`) VALUES ('ai.baseUrl', 'https://maxkb.fit2cloud.com/ui/chat/5baa787163381fa2', 'text', 100); \ No newline at end of file +INSERT INTO `system_parameter` (`param_key`, `param_value`, `type`, `sort`) VALUES ('ai.baseUrl', 'https://maxkb.fit2cloud.com/ui/chat/5baa787163381fa2', 'text', 100); + + +DROP TABLE IF EXISTS `export_task`; +CREATE TABLE `export_task` ( + `id` varchar(255) NOT NULL, + `user_id` bigint(20) NOT NULL , + `file_name` varchar(2048) DEFAULT NULL, + `file_size` DOUBLE DEFAULT NULL, + `export_from` varchar(255) DEFAULT NULL, + `export_status` varchar(255) DEFAULT NULL, + `export_from_type` varchar(255) DEFAULT NULL, + `export_time` bigint(20) DEFAULT NULL, + `export_pogress` varchar(255) DEFAULT NULL, + PRIMARY KEY (`id`) +) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE utf8mb4_general_ci; + diff --git a/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/domain/ExportTask.java b/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/domain/ExportTask.java new file mode 100644 index 0000000000..e902c533d7 --- /dev/null +++ b/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/domain/ExportTask.java @@ -0,0 +1,27 @@ +package io.dataease.plugins.common.base.domain; + +import java.io.Serializable; +import lombok.Data; + +@Data +public class ExportTask implements Serializable { + private String id; + + private Long userId; + + private String fileName; + + private Double fileSize; + + private String exportFrom; + + private String exportStatus; + + private String exportFromType; + + private Long exportTime; + + private String exportPogress; + + private static final long serialVersionUID = 1L; +} \ No newline at end of file diff --git a/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/domain/ExportTaskExample.java b/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/domain/ExportTaskExample.java new file mode 100644 index 0000000000..e42471ebae --- /dev/null +++ b/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/domain/ExportTaskExample.java @@ -0,0 +1,800 @@ +package io.dataease.plugins.common.base.domain; + +import java.util.ArrayList; +import java.util.List; + +public class ExportTaskExample { + protected String orderByClause; + + protected boolean distinct; + + protected List oredCriteria; + + public ExportTaskExample() { + oredCriteria = new ArrayList(); + } + + public void setOrderByClause(String orderByClause) { + this.orderByClause = orderByClause; + } + + public String getOrderByClause() { + return orderByClause; + } + + public void setDistinct(boolean distinct) { + this.distinct = distinct; + } + + public boolean isDistinct() { + return distinct; + } + + public List getOredCriteria() { + return oredCriteria; + } + + public void or(Criteria criteria) { + oredCriteria.add(criteria); + } + + public Criteria or() { + Criteria criteria = createCriteriaInternal(); + oredCriteria.add(criteria); + return criteria; + } + + public Criteria createCriteria() { + Criteria criteria = createCriteriaInternal(); + if (oredCriteria.size() == 0) { + oredCriteria.add(criteria); + } + return criteria; + } + + protected Criteria createCriteriaInternal() { + Criteria criteria = new Criteria(); + return criteria; + } + + public void clear() { + oredCriteria.clear(); + orderByClause = null; + distinct = false; + } + + protected abstract static class GeneratedCriteria { + protected List criteria; + + protected GeneratedCriteria() { + super(); + criteria = new ArrayList(); + } + + public boolean isValid() { + return criteria.size() > 0; + } + + public List getAllCriteria() { + return criteria; + } + + public List getCriteria() { + return criteria; + } + + protected void addCriterion(String condition) { + if (condition == null) { + throw new RuntimeException("Value for condition cannot be null"); + } + criteria.add(new Criterion(condition)); + } + + protected void addCriterion(String condition, Object value, String property) { + if (value == null) { + throw new RuntimeException("Value for " + property + " cannot be null"); + } + criteria.add(new Criterion(condition, value)); + } + + protected void addCriterion(String condition, Object value1, Object value2, String property) { + if (value1 == null || value2 == null) { + throw new RuntimeException("Between values for " + property + " cannot be null"); + } + criteria.add(new Criterion(condition, value1, value2)); + } + + public Criteria andIdIsNull() { + addCriterion("id is null"); + return (Criteria) this; + } + + public Criteria andIdIsNotNull() { + addCriterion("id is not null"); + return (Criteria) this; + } + + public Criteria andIdEqualTo(String value) { + addCriterion("id =", value, "id"); + return (Criteria) this; + } + + public Criteria andIdNotEqualTo(String value) { + addCriterion("id <>", value, "id"); + return (Criteria) this; + } + + public Criteria andIdGreaterThan(String value) { + addCriterion("id >", value, "id"); + return (Criteria) this; + } + + public Criteria andIdGreaterThanOrEqualTo(String value) { + addCriterion("id >=", value, "id"); + return (Criteria) this; + } + + public Criteria andIdLessThan(String value) { + addCriterion("id <", value, "id"); + return (Criteria) this; + } + + public Criteria andIdLessThanOrEqualTo(String value) { + addCriterion("id <=", value, "id"); + return (Criteria) this; + } + + public Criteria andIdLike(String value) { + addCriterion("id like", value, "id"); + return (Criteria) this; + } + + public Criteria andIdNotLike(String value) { + addCriterion("id not like", value, "id"); + return (Criteria) this; + } + + public Criteria andIdIn(List values) { + addCriterion("id in", values, "id"); + return (Criteria) this; + } + + public Criteria andIdNotIn(List values) { + addCriterion("id not in", values, "id"); + return (Criteria) this; + } + + public Criteria andIdBetween(String value1, String value2) { + addCriterion("id between", value1, value2, "id"); + return (Criteria) this; + } + + public Criteria andIdNotBetween(String value1, String value2) { + addCriterion("id not between", value1, value2, "id"); + return (Criteria) this; + } + + public Criteria andUserIdIsNull() { + addCriterion("user_id is null"); + return (Criteria) this; + } + + public Criteria andUserIdIsNotNull() { + addCriterion("user_id is not null"); + return (Criteria) this; + } + + public Criteria andUserIdEqualTo(Long value) { + addCriterion("user_id =", value, "userId"); + return (Criteria) this; + } + + public Criteria andUserIdNotEqualTo(Long value) { + addCriterion("user_id <>", value, "userId"); + return (Criteria) this; + } + + public Criteria andUserIdGreaterThan(Long value) { + addCriterion("user_id >", value, "userId"); + return (Criteria) this; + } + + public Criteria andUserIdGreaterThanOrEqualTo(Long value) { + addCriterion("user_id >=", value, "userId"); + return (Criteria) this; + } + + public Criteria andUserIdLessThan(Long value) { + addCriterion("user_id <", value, "userId"); + return (Criteria) this; + } + + public Criteria andUserIdLessThanOrEqualTo(Long value) { + addCriterion("user_id <=", value, "userId"); + return (Criteria) this; + } + + public Criteria andUserIdIn(List values) { + addCriterion("user_id in", values, "userId"); + return (Criteria) this; + } + + public Criteria andUserIdNotIn(List values) { + addCriterion("user_id not in", values, "userId"); + return (Criteria) this; + } + + public Criteria andUserIdBetween(Long value1, Long value2) { + addCriterion("user_id between", value1, value2, "userId"); + return (Criteria) this; + } + + public Criteria andUserIdNotBetween(Long value1, Long value2) { + addCriterion("user_id not between", value1, value2, "userId"); + return (Criteria) this; + } + + public Criteria andFileNameIsNull() { + addCriterion("file_name is null"); + return (Criteria) this; + } + + public Criteria andFileNameIsNotNull() { + addCriterion("file_name is not null"); + return (Criteria) this; + } + + public Criteria andFileNameEqualTo(String value) { + addCriterion("file_name =", value, "fileName"); + return (Criteria) this; + } + + public Criteria andFileNameNotEqualTo(String value) { + addCriterion("file_name <>", value, "fileName"); + return (Criteria) this; + } + + public Criteria andFileNameGreaterThan(String value) { + addCriterion("file_name >", value, "fileName"); + return (Criteria) this; + } + + public Criteria andFileNameGreaterThanOrEqualTo(String value) { + addCriterion("file_name >=", value, "fileName"); + return (Criteria) this; + } + + public Criteria andFileNameLessThan(String value) { + addCriterion("file_name <", value, "fileName"); + return (Criteria) this; + } + + public Criteria andFileNameLessThanOrEqualTo(String value) { + addCriterion("file_name <=", value, "fileName"); + return (Criteria) this; + } + + public Criteria andFileNameLike(String value) { + addCriterion("file_name like", value, "fileName"); + return (Criteria) this; + } + + public Criteria andFileNameNotLike(String value) { + addCriterion("file_name not like", value, "fileName"); + return (Criteria) this; + } + + public Criteria andFileNameIn(List values) { + addCriterion("file_name in", values, "fileName"); + return (Criteria) this; + } + + public Criteria andFileNameNotIn(List values) { + addCriterion("file_name not in", values, "fileName"); + return (Criteria) this; + } + + public Criteria andFileNameBetween(String value1, String value2) { + addCriterion("file_name between", value1, value2, "fileName"); + return (Criteria) this; + } + + public Criteria andFileNameNotBetween(String value1, String value2) { + addCriterion("file_name not between", value1, value2, "fileName"); + return (Criteria) this; + } + + public Criteria andFileSizeIsNull() { + addCriterion("file_size is null"); + return (Criteria) this; + } + + public Criteria andFileSizeIsNotNull() { + addCriterion("file_size is not null"); + return (Criteria) this; + } + + public Criteria andFileSizeEqualTo(Double value) { + addCriterion("file_size =", value, "fileSize"); + return (Criteria) this; + } + + public Criteria andFileSizeNotEqualTo(Double value) { + addCriterion("file_size <>", value, "fileSize"); + return (Criteria) this; + } + + public Criteria andFileSizeGreaterThan(Double value) { + addCriterion("file_size >", value, "fileSize"); + return (Criteria) this; + } + + public Criteria andFileSizeGreaterThanOrEqualTo(Double value) { + addCriterion("file_size >=", value, "fileSize"); + return (Criteria) this; + } + + public Criteria andFileSizeLessThan(Double value) { + addCriterion("file_size <", value, "fileSize"); + return (Criteria) this; + } + + public Criteria andFileSizeLessThanOrEqualTo(Double value) { + addCriterion("file_size <=", value, "fileSize"); + return (Criteria) this; + } + + public Criteria andFileSizeIn(List values) { + addCriterion("file_size in", values, "fileSize"); + return (Criteria) this; + } + + public Criteria andFileSizeNotIn(List values) { + addCriterion("file_size not in", values, "fileSize"); + return (Criteria) this; + } + + public Criteria andFileSizeBetween(Double value1, Double value2) { + addCriterion("file_size between", value1, value2, "fileSize"); + return (Criteria) this; + } + + public Criteria andFileSizeNotBetween(Double value1, Double value2) { + addCriterion("file_size not between", value1, value2, "fileSize"); + return (Criteria) this; + } + + public Criteria andExportFromIsNull() { + addCriterion("export_from is null"); + return (Criteria) this; + } + + public Criteria andExportFromIsNotNull() { + addCriterion("export_from is not null"); + return (Criteria) this; + } + + public Criteria andExportFromEqualTo(String value) { + addCriterion("export_from =", value, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportFromNotEqualTo(String value) { + addCriterion("export_from <>", value, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportFromGreaterThan(String value) { + addCriterion("export_from >", value, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportFromGreaterThanOrEqualTo(String value) { + addCriterion("export_from >=", value, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportFromLessThan(String value) { + addCriterion("export_from <", value, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportFromLessThanOrEqualTo(String value) { + addCriterion("export_from <=", value, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportFromLike(String value) { + addCriterion("export_from like", value, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportFromNotLike(String value) { + addCriterion("export_from not like", value, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportFromIn(List values) { + addCriterion("export_from in", values, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportFromNotIn(List values) { + addCriterion("export_from not in", values, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportFromBetween(String value1, String value2) { + addCriterion("export_from between", value1, value2, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportFromNotBetween(String value1, String value2) { + addCriterion("export_from not between", value1, value2, "exportFrom"); + return (Criteria) this; + } + + public Criteria andExportStatusIsNull() { + addCriterion("export_status is null"); + return (Criteria) this; + } + + public Criteria andExportStatusIsNotNull() { + addCriterion("export_status is not null"); + return (Criteria) this; + } + + public Criteria andExportStatusEqualTo(String value) { + addCriterion("export_status =", value, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportStatusNotEqualTo(String value) { + addCriterion("export_status <>", value, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportStatusGreaterThan(String value) { + addCriterion("export_status >", value, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportStatusGreaterThanOrEqualTo(String value) { + addCriterion("export_status >=", value, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportStatusLessThan(String value) { + addCriterion("export_status <", value, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportStatusLessThanOrEqualTo(String value) { + addCriterion("export_status <=", value, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportStatusLike(String value) { + addCriterion("export_status like", value, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportStatusNotLike(String value) { + addCriterion("export_status not like", value, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportStatusIn(List values) { + addCriterion("export_status in", values, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportStatusNotIn(List values) { + addCriterion("export_status not in", values, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportStatusBetween(String value1, String value2) { + addCriterion("export_status between", value1, value2, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportStatusNotBetween(String value1, String value2) { + addCriterion("export_status not between", value1, value2, "exportStatus"); + return (Criteria) this; + } + + public Criteria andExportFromTypeIsNull() { + addCriterion("export_from_type is null"); + return (Criteria) this; + } + + public Criteria andExportFromTypeIsNotNull() { + addCriterion("export_from_type is not null"); + return (Criteria) this; + } + + public Criteria andExportFromTypeEqualTo(String value) { + addCriterion("export_from_type =", value, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportFromTypeNotEqualTo(String value) { + addCriterion("export_from_type <>", value, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportFromTypeGreaterThan(String value) { + addCriterion("export_from_type >", value, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportFromTypeGreaterThanOrEqualTo(String value) { + addCriterion("export_from_type >=", value, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportFromTypeLessThan(String value) { + addCriterion("export_from_type <", value, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportFromTypeLessThanOrEqualTo(String value) { + addCriterion("export_from_type <=", value, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportFromTypeLike(String value) { + addCriterion("export_from_type like", value, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportFromTypeNotLike(String value) { + addCriterion("export_from_type not like", value, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportFromTypeIn(List values) { + addCriterion("export_from_type in", values, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportFromTypeNotIn(List values) { + addCriterion("export_from_type not in", values, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportFromTypeBetween(String value1, String value2) { + addCriterion("export_from_type between", value1, value2, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportFromTypeNotBetween(String value1, String value2) { + addCriterion("export_from_type not between", value1, value2, "exportFromType"); + return (Criteria) this; + } + + public Criteria andExportTimeIsNull() { + addCriterion("export_time is null"); + return (Criteria) this; + } + + public Criteria andExportTimeIsNotNull() { + addCriterion("export_time is not null"); + return (Criteria) this; + } + + public Criteria andExportTimeEqualTo(Long value) { + addCriterion("export_time =", value, "exportTime"); + return (Criteria) this; + } + + public Criteria andExportTimeNotEqualTo(Long value) { + addCriterion("export_time <>", value, "exportTime"); + return (Criteria) this; + } + + public Criteria andExportTimeGreaterThan(Long value) { + addCriterion("export_time >", value, "exportTime"); + return (Criteria) this; + } + + public Criteria andExportTimeGreaterThanOrEqualTo(Long value) { + addCriterion("export_time >=", value, "exportTime"); + return (Criteria) this; + } + + public Criteria andExportTimeLessThan(Long value) { + addCriterion("export_time <", value, "exportTime"); + return (Criteria) this; + } + + public Criteria andExportTimeLessThanOrEqualTo(Long value) { + addCriterion("export_time <=", value, "exportTime"); + return (Criteria) this; + } + + public Criteria andExportTimeIn(List values) { + addCriterion("export_time in", values, "exportTime"); + return (Criteria) this; + } + + public Criteria andExportTimeNotIn(List values) { + addCriterion("export_time not in", values, "exportTime"); + return (Criteria) this; + } + + public Criteria andExportTimeBetween(Long value1, Long value2) { + addCriterion("export_time between", value1, value2, "exportTime"); + return (Criteria) this; + } + + public Criteria andExportTimeNotBetween(Long value1, Long value2) { + addCriterion("export_time not between", value1, value2, "exportTime"); + return (Criteria) this; + } + + public Criteria andExportPogressIsNull() { + addCriterion("export_pogress is null"); + return (Criteria) this; + } + + public Criteria andExportPogressIsNotNull() { + addCriterion("export_pogress is not null"); + return (Criteria) this; + } + + public Criteria andExportPogressEqualTo(String value) { + addCriterion("export_pogress =", value, "exportPogress"); + return (Criteria) this; + } + + public Criteria andExportPogressNotEqualTo(String value) { + addCriterion("export_pogress <>", value, "exportPogress"); + return (Criteria) this; + } + + public Criteria andExportPogressGreaterThan(String value) { + addCriterion("export_pogress >", value, "exportPogress"); + return (Criteria) this; + } + + public Criteria andExportPogressGreaterThanOrEqualTo(String value) { + addCriterion("export_pogress >=", value, "exportPogress"); + return (Criteria) this; + } + + public Criteria andExportPogressLessThan(String value) { + addCriterion("export_pogress <", value, "exportPogress"); + return (Criteria) this; + } + + public Criteria andExportPogressLessThanOrEqualTo(String value) { + addCriterion("export_pogress <=", value, "exportPogress"); + return (Criteria) this; + } + + public Criteria andExportPogressLike(String value) { + addCriterion("export_pogress like", value, "exportPogress"); + return (Criteria) this; + } + + public Criteria andExportPogressNotLike(String value) { + addCriterion("export_pogress not like", value, "exportPogress"); + return (Criteria) this; + } + + public Criteria andExportPogressIn(List values) { + addCriterion("export_pogress in", values, "exportPogress"); + return (Criteria) this; + } + + public Criteria andExportPogressNotIn(List values) { + addCriterion("export_pogress not in", values, "exportPogress"); + return (Criteria) this; + } + + public Criteria andExportPogressBetween(String value1, String value2) { + addCriterion("export_pogress between", value1, value2, "exportPogress"); + return (Criteria) this; + } + + public Criteria andExportPogressNotBetween(String value1, String value2) { + addCriterion("export_pogress not between", value1, value2, "exportPogress"); + return (Criteria) this; + } + } + + public static class Criteria extends GeneratedCriteria { + + protected Criteria() { + super(); + } + } + + public static class Criterion { + private String condition; + + private Object value; + + private Object secondValue; + + private boolean noValue; + + private boolean singleValue; + + private boolean betweenValue; + + private boolean listValue; + + private String typeHandler; + + public String getCondition() { + return condition; + } + + public Object getValue() { + return value; + } + + public Object getSecondValue() { + return secondValue; + } + + public boolean isNoValue() { + return noValue; + } + + public boolean isSingleValue() { + return singleValue; + } + + public boolean isBetweenValue() { + return betweenValue; + } + + public boolean isListValue() { + return listValue; + } + + public String getTypeHandler() { + return typeHandler; + } + + protected Criterion(String condition) { + super(); + this.condition = condition; + this.typeHandler = null; + this.noValue = true; + } + + protected Criterion(String condition, Object value, String typeHandler) { + super(); + this.condition = condition; + this.value = value; + this.typeHandler = typeHandler; + if (value instanceof List) { + this.listValue = true; + } else { + this.singleValue = true; + } + } + + protected Criterion(String condition, Object value) { + this(condition, value, null); + } + + protected Criterion(String condition, Object value, Object secondValue, String typeHandler) { + super(); + this.condition = condition; + this.value = value; + this.secondValue = secondValue; + this.typeHandler = typeHandler; + this.betweenValue = true; + } + + protected Criterion(String condition, Object value, Object secondValue) { + this(condition, value, secondValue, null); + } + } +} \ No newline at end of file diff --git a/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/mapper/ExportTaskMapper.java b/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/mapper/ExportTaskMapper.java new file mode 100644 index 0000000000..6f79500a92 --- /dev/null +++ b/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/mapper/ExportTaskMapper.java @@ -0,0 +1,30 @@ +package io.dataease.plugins.common.base.mapper; + +import io.dataease.plugins.common.base.domain.ExportTask; +import io.dataease.plugins.common.base.domain.ExportTaskExample; +import java.util.List; +import org.apache.ibatis.annotations.Param; + +public interface ExportTaskMapper { + long countByExample(ExportTaskExample example); + + int deleteByExample(ExportTaskExample example); + + int deleteByPrimaryKey(String id); + + int insert(ExportTask record); + + int insertSelective(ExportTask record); + + List selectByExample(ExportTaskExample example); + + ExportTask selectByPrimaryKey(String id); + + int updateByExampleSelective(@Param("record") ExportTask record, @Param("example") ExportTaskExample example); + + int updateByExample(@Param("record") ExportTask record, @Param("example") ExportTaskExample example); + + int updateByPrimaryKeySelective(ExportTask record); + + int updateByPrimaryKey(ExportTask record); +} \ No newline at end of file diff --git a/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/mapper/ExportTaskMapper.xml b/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/mapper/ExportTaskMapper.xml new file mode 100644 index 0000000000..3308b81065 --- /dev/null +++ b/sdk/dataease-plugin-common/src/main/java/io/dataease/plugins/common/base/mapper/ExportTaskMapper.xml @@ -0,0 +1,276 @@ + + + + + + + + + + + + + + + + + + + + + + + and ${criterion.condition} + + + and ${criterion.condition} #{criterion.value} + + + and ${criterion.condition} #{criterion.value} and #{criterion.secondValue} + + + and ${criterion.condition} + + #{listItem} + + + + + + + + + + + + + + + + + + and ${criterion.condition} + + + and ${criterion.condition} #{criterion.value} + + + and ${criterion.condition} #{criterion.value} and #{criterion.secondValue} + + + and ${criterion.condition} + + #{listItem} + + + + + + + + + + + id, user_id, file_name, file_size, export_from, export_status, export_from_type, + export_time, export_pogress + + + + + delete from export_task + where id = #{id,jdbcType=VARCHAR} + + + delete from export_task + + + + + + insert into export_task (id, user_id, file_name, + file_size, export_from, export_status, + export_from_type, export_time, export_pogress + ) + values (#{id,jdbcType=VARCHAR}, #{userId,jdbcType=BIGINT}, #{fileName,jdbcType=VARCHAR}, + #{fileSize,jdbcType=DOUBLE}, #{exportFrom,jdbcType=VARCHAR}, #{exportStatus,jdbcType=VARCHAR}, + #{exportFromType,jdbcType=VARCHAR}, #{exportTime,jdbcType=BIGINT}, #{exportPogress,jdbcType=VARCHAR} + ) + + + insert into export_task + + + id, + + + user_id, + + + file_name, + + + file_size, + + + export_from, + + + export_status, + + + export_from_type, + + + export_time, + + + export_pogress, + + + + + #{id,jdbcType=VARCHAR}, + + + #{userId,jdbcType=BIGINT}, + + + #{fileName,jdbcType=VARCHAR}, + + + #{fileSize,jdbcType=DOUBLE}, + + + #{exportFrom,jdbcType=VARCHAR}, + + + #{exportStatus,jdbcType=VARCHAR}, + + + #{exportFromType,jdbcType=VARCHAR}, + + + #{exportTime,jdbcType=BIGINT}, + + + #{exportPogress,jdbcType=VARCHAR}, + + + + + + update export_task + + + id = #{record.id,jdbcType=VARCHAR}, + + + user_id = #{record.userId,jdbcType=BIGINT}, + + + file_name = #{record.fileName,jdbcType=VARCHAR}, + + + file_size = #{record.fileSize,jdbcType=DOUBLE}, + + + export_from = #{record.exportFrom,jdbcType=VARCHAR}, + + + export_status = #{record.exportStatus,jdbcType=VARCHAR}, + + + export_from_type = #{record.exportFromType,jdbcType=VARCHAR}, + + + export_time = #{record.exportTime,jdbcType=BIGINT}, + + + export_pogress = #{record.exportPogress,jdbcType=VARCHAR}, + + + + + + + + update export_task + set id = #{record.id,jdbcType=VARCHAR}, + user_id = #{record.userId,jdbcType=BIGINT}, + file_name = #{record.fileName,jdbcType=VARCHAR}, + file_size = #{record.fileSize,jdbcType=DOUBLE}, + export_from = #{record.exportFrom,jdbcType=VARCHAR}, + export_status = #{record.exportStatus,jdbcType=VARCHAR}, + export_from_type = #{record.exportFromType,jdbcType=VARCHAR}, + export_time = #{record.exportTime,jdbcType=BIGINT}, + export_pogress = #{record.exportPogress,jdbcType=VARCHAR} + + + + + + update export_task + + + user_id = #{userId,jdbcType=BIGINT}, + + + file_name = #{fileName,jdbcType=VARCHAR}, + + + file_size = #{fileSize,jdbcType=DOUBLE}, + + + export_from = #{exportFrom,jdbcType=VARCHAR}, + + + export_status = #{exportStatus,jdbcType=VARCHAR}, + + + export_from_type = #{exportFromType,jdbcType=VARCHAR}, + + + export_time = #{exportTime,jdbcType=BIGINT}, + + + export_pogress = #{exportPogress,jdbcType=VARCHAR}, + + + where id = #{id,jdbcType=VARCHAR} + + + update export_task + set user_id = #{userId,jdbcType=BIGINT}, + file_name = #{fileName,jdbcType=VARCHAR}, + file_size = #{fileSize,jdbcType=DOUBLE}, + export_from = #{exportFrom,jdbcType=VARCHAR}, + export_status = #{exportStatus,jdbcType=VARCHAR}, + export_from_type = #{exportFromType,jdbcType=VARCHAR}, + export_time = #{exportTime,jdbcType=BIGINT}, + export_pogress = #{exportPogress,jdbcType=VARCHAR} + where id = #{id,jdbcType=VARCHAR} + + \ No newline at end of file