diff --git a/backend/src/main/java/io/dataease/base/domain/UserKey.java b/backend/src/main/java/io/dataease/base/domain/UserKey.java new file mode 100644 index 0000000000..bd9aaab7c6 --- /dev/null +++ b/backend/src/main/java/io/dataease/base/domain/UserKey.java @@ -0,0 +1,21 @@ +package io.dataease.base.domain; + +import java.io.Serializable; +import lombok.Data; + +@Data +public class UserKey implements Serializable { + private Long id; + + private Long userId; + + private String accessKey; + + private String secretKey; + + private Long createTime; + + private String status; + + private static final long serialVersionUID = 1L; +} \ No newline at end of file diff --git a/backend/src/main/java/io/dataease/base/domain/UserKeyExample.java b/backend/src/main/java/io/dataease/base/domain/UserKeyExample.java new file mode 100644 index 0000000000..eca0701de4 --- /dev/null +++ b/backend/src/main/java/io/dataease/base/domain/UserKeyExample.java @@ -0,0 +1,590 @@ +package io.dataease.base.domain; + +import java.util.ArrayList; +import java.util.List; + +public class UserKeyExample { + protected String orderByClause; + + protected boolean distinct; + + protected List oredCriteria; + + public UserKeyExample() { + 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(Long value) { + addCriterion("id =", value, "id"); + return (Criteria) this; + } + + public Criteria andIdNotEqualTo(Long value) { + addCriterion("id <>", value, "id"); + return (Criteria) this; + } + + public Criteria andIdGreaterThan(Long value) { + addCriterion("id >", value, "id"); + return (Criteria) this; + } + + public Criteria andIdGreaterThanOrEqualTo(Long value) { + addCriterion("id >=", value, "id"); + return (Criteria) this; + } + + public Criteria andIdLessThan(Long value) { + addCriterion("id <", value, "id"); + return (Criteria) this; + } + + public Criteria andIdLessThanOrEqualTo(Long value) { + addCriterion("id <=", 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(Long value1, Long value2) { + addCriterion("id between", value1, value2, "id"); + return (Criteria) this; + } + + public Criteria andIdNotBetween(Long value1, Long 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 andAccessKeyIsNull() { + addCriterion("access_key is null"); + return (Criteria) this; + } + + public Criteria andAccessKeyIsNotNull() { + addCriterion("access_key is not null"); + return (Criteria) this; + } + + public Criteria andAccessKeyEqualTo(String value) { + addCriterion("access_key =", value, "accessKey"); + return (Criteria) this; + } + + public Criteria andAccessKeyNotEqualTo(String value) { + addCriterion("access_key <>", value, "accessKey"); + return (Criteria) this; + } + + public Criteria andAccessKeyGreaterThan(String value) { + addCriterion("access_key >", value, "accessKey"); + return (Criteria) this; + } + + public Criteria andAccessKeyGreaterThanOrEqualTo(String value) { + addCriterion("access_key >=", value, "accessKey"); + return (Criteria) this; + } + + public Criteria andAccessKeyLessThan(String value) { + addCriterion("access_key <", value, "accessKey"); + return (Criteria) this; + } + + public Criteria andAccessKeyLessThanOrEqualTo(String value) { + addCriterion("access_key <=", value, "accessKey"); + return (Criteria) this; + } + + public Criteria andAccessKeyLike(String value) { + addCriterion("access_key like", value, "accessKey"); + return (Criteria) this; + } + + public Criteria andAccessKeyNotLike(String value) { + addCriterion("access_key not like", value, "accessKey"); + return (Criteria) this; + } + + public Criteria andAccessKeyIn(List values) { + addCriterion("access_key in", values, "accessKey"); + return (Criteria) this; + } + + public Criteria andAccessKeyNotIn(List values) { + addCriterion("access_key not in", values, "accessKey"); + return (Criteria) this; + } + + public Criteria andAccessKeyBetween(String value1, String value2) { + addCriterion("access_key between", value1, value2, "accessKey"); + return (Criteria) this; + } + + public Criteria andAccessKeyNotBetween(String value1, String value2) { + addCriterion("access_key not between", value1, value2, "accessKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyIsNull() { + addCriterion("secret_key is null"); + return (Criteria) this; + } + + public Criteria andSecretKeyIsNotNull() { + addCriterion("secret_key is not null"); + return (Criteria) this; + } + + public Criteria andSecretKeyEqualTo(String value) { + addCriterion("secret_key =", value, "secretKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyNotEqualTo(String value) { + addCriterion("secret_key <>", value, "secretKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyGreaterThan(String value) { + addCriterion("secret_key >", value, "secretKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyGreaterThanOrEqualTo(String value) { + addCriterion("secret_key >=", value, "secretKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyLessThan(String value) { + addCriterion("secret_key <", value, "secretKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyLessThanOrEqualTo(String value) { + addCriterion("secret_key <=", value, "secretKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyLike(String value) { + addCriterion("secret_key like", value, "secretKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyNotLike(String value) { + addCriterion("secret_key not like", value, "secretKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyIn(List values) { + addCriterion("secret_key in", values, "secretKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyNotIn(List values) { + addCriterion("secret_key not in", values, "secretKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyBetween(String value1, String value2) { + addCriterion("secret_key between", value1, value2, "secretKey"); + return (Criteria) this; + } + + public Criteria andSecretKeyNotBetween(String value1, String value2) { + addCriterion("secret_key not between", value1, value2, "secretKey"); + return (Criteria) this; + } + + public Criteria andCreateTimeIsNull() { + addCriterion("create_time is null"); + return (Criteria) this; + } + + public Criteria andCreateTimeIsNotNull() { + addCriterion("create_time is not null"); + return (Criteria) this; + } + + public Criteria andCreateTimeEqualTo(Long value) { + addCriterion("create_time =", value, "createTime"); + return (Criteria) this; + } + + public Criteria andCreateTimeNotEqualTo(Long value) { + addCriterion("create_time <>", value, "createTime"); + return (Criteria) this; + } + + public Criteria andCreateTimeGreaterThan(Long value) { + addCriterion("create_time >", value, "createTime"); + return (Criteria) this; + } + + public Criteria andCreateTimeGreaterThanOrEqualTo(Long value) { + addCriterion("create_time >=", value, "createTime"); + return (Criteria) this; + } + + public Criteria andCreateTimeLessThan(Long value) { + addCriterion("create_time <", value, "createTime"); + return (Criteria) this; + } + + public Criteria andCreateTimeLessThanOrEqualTo(Long value) { + addCriterion("create_time <=", value, "createTime"); + return (Criteria) this; + } + + public Criteria andCreateTimeIn(List values) { + addCriterion("create_time in", values, "createTime"); + return (Criteria) this; + } + + public Criteria andCreateTimeNotIn(List values) { + addCriterion("create_time not in", values, "createTime"); + return (Criteria) this; + } + + public Criteria andCreateTimeBetween(Long value1, Long value2) { + addCriterion("create_time between", value1, value2, "createTime"); + return (Criteria) this; + } + + public Criteria andCreateTimeNotBetween(Long value1, Long value2) { + addCriterion("create_time not between", value1, value2, "createTime"); + return (Criteria) this; + } + + public Criteria andStatusIsNull() { + addCriterion("`status` is null"); + return (Criteria) this; + } + + public Criteria andStatusIsNotNull() { + addCriterion("`status` is not null"); + return (Criteria) this; + } + + public Criteria andStatusEqualTo(String value) { + addCriterion("`status` =", value, "status"); + return (Criteria) this; + } + + public Criteria andStatusNotEqualTo(String value) { + addCriterion("`status` <>", value, "status"); + return (Criteria) this; + } + + public Criteria andStatusGreaterThan(String value) { + addCriterion("`status` >", value, "status"); + return (Criteria) this; + } + + public Criteria andStatusGreaterThanOrEqualTo(String value) { + addCriterion("`status` >=", value, "status"); + return (Criteria) this; + } + + public Criteria andStatusLessThan(String value) { + addCriterion("`status` <", value, "status"); + return (Criteria) this; + } + + public Criteria andStatusLessThanOrEqualTo(String value) { + addCriterion("`status` <=", value, "status"); + return (Criteria) this; + } + + public Criteria andStatusLike(String value) { + addCriterion("`status` like", value, "status"); + return (Criteria) this; + } + + public Criteria andStatusNotLike(String value) { + addCriterion("`status` not like", value, "status"); + return (Criteria) this; + } + + public Criteria andStatusIn(List values) { + addCriterion("`status` in", values, "status"); + return (Criteria) this; + } + + public Criteria andStatusNotIn(List values) { + addCriterion("`status` not in", values, "status"); + return (Criteria) this; + } + + public Criteria andStatusBetween(String value1, String value2) { + addCriterion("`status` between", value1, value2, "status"); + return (Criteria) this; + } + + public Criteria andStatusNotBetween(String value1, String value2) { + addCriterion("`status` not between", value1, value2, "status"); + 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/backend/src/main/java/io/dataease/base/mapper/UserKeyMapper.java b/backend/src/main/java/io/dataease/base/mapper/UserKeyMapper.java new file mode 100644 index 0000000000..0103fd1305 --- /dev/null +++ b/backend/src/main/java/io/dataease/base/mapper/UserKeyMapper.java @@ -0,0 +1,30 @@ +package io.dataease.base.mapper; + +import io.dataease.base.domain.UserKey; +import io.dataease.base.domain.UserKeyExample; +import java.util.List; +import org.apache.ibatis.annotations.Param; + +public interface UserKeyMapper { + long countByExample(UserKeyExample example); + + int deleteByExample(UserKeyExample example); + + int deleteByPrimaryKey(Long id); + + int insert(UserKey record); + + int insertSelective(UserKey record); + + List selectByExample(UserKeyExample example); + + UserKey selectByPrimaryKey(Long id); + + int updateByExampleSelective(@Param("record") UserKey record, @Param("example") UserKeyExample example); + + int updateByExample(@Param("record") UserKey record, @Param("example") UserKeyExample example); + + int updateByPrimaryKeySelective(UserKey record); + + int updateByPrimaryKey(UserKey record); +} \ No newline at end of file diff --git a/backend/src/main/java/io/dataease/base/mapper/UserKeyMapper.xml b/backend/src/main/java/io/dataease/base/mapper/UserKeyMapper.xml new file mode 100644 index 0000000000..c10a33dc45 --- /dev/null +++ b/backend/src/main/java/io/dataease/base/mapper/UserKeyMapper.xml @@ -0,0 +1,228 @@ + + + + + + + + + + + + + + + + + + + + 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, access_key, secret_key, create_time, `status` + + + + + delete from user_key + where id = #{id,jdbcType=BIGINT} + + + delete from user_key + + + + + + insert into user_key (id, user_id, access_key, + secret_key, create_time, `status` + ) + values (#{id,jdbcType=BIGINT}, #{userId,jdbcType=BIGINT}, #{accessKey,jdbcType=VARCHAR}, + #{secretKey,jdbcType=VARCHAR}, #{createTime,jdbcType=BIGINT}, #{status,jdbcType=VARCHAR} + ) + + + insert into user_key + + + id, + + + user_id, + + + access_key, + + + secret_key, + + + create_time, + + + `status`, + + + + + #{id,jdbcType=BIGINT}, + + + #{userId,jdbcType=BIGINT}, + + + #{accessKey,jdbcType=VARCHAR}, + + + #{secretKey,jdbcType=VARCHAR}, + + + #{createTime,jdbcType=BIGINT}, + + + #{status,jdbcType=VARCHAR}, + + + + + + update user_key + + + id = #{record.id,jdbcType=BIGINT}, + + + user_id = #{record.userId,jdbcType=BIGINT}, + + + access_key = #{record.accessKey,jdbcType=VARCHAR}, + + + secret_key = #{record.secretKey,jdbcType=VARCHAR}, + + + create_time = #{record.createTime,jdbcType=BIGINT}, + + + `status` = #{record.status,jdbcType=VARCHAR}, + + + + + + + + update user_key + set id = #{record.id,jdbcType=BIGINT}, + user_id = #{record.userId,jdbcType=BIGINT}, + access_key = #{record.accessKey,jdbcType=VARCHAR}, + secret_key = #{record.secretKey,jdbcType=VARCHAR}, + create_time = #{record.createTime,jdbcType=BIGINT}, + `status` = #{record.status,jdbcType=VARCHAR} + + + + + + update user_key + + + user_id = #{userId,jdbcType=BIGINT}, + + + access_key = #{accessKey,jdbcType=VARCHAR}, + + + secret_key = #{secretKey,jdbcType=VARCHAR}, + + + create_time = #{createTime,jdbcType=BIGINT}, + + + `status` = #{status,jdbcType=VARCHAR}, + + + where id = #{id,jdbcType=BIGINT} + + + update user_key + set user_id = #{userId,jdbcType=BIGINT}, + access_key = #{accessKey,jdbcType=VARCHAR}, + secret_key = #{secretKey,jdbcType=VARCHAR}, + create_time = #{createTime,jdbcType=BIGINT}, + `status` = #{status,jdbcType=VARCHAR} + where id = #{id,jdbcType=BIGINT} + + \ No newline at end of file diff --git a/backend/src/main/java/io/dataease/commons/constants/DeTypeConstants.java b/backend/src/main/java/io/dataease/commons/constants/DeTypeConstants.java new file mode 100644 index 0000000000..50a925c2ee --- /dev/null +++ b/backend/src/main/java/io/dataease/commons/constants/DeTypeConstants.java @@ -0,0 +1,12 @@ +package io.dataease.commons.constants; + +public class DeTypeConstants { + + public final static Integer DE_STRING = 0; + public final static Integer DE_TIME = 1; + public final static Integer DE_INT = 2; + public final static Integer DE_FLOAT = 3; + public final static Integer DE_BOOL = 4; + public final static Integer DE_Binary = 5; + +} diff --git a/backend/src/main/java/io/dataease/commons/filter/SqlFilter.java b/backend/src/main/java/io/dataease/commons/filter/SqlFilter.java index 3a913cb270..2894857bef 100644 --- a/backend/src/main/java/io/dataease/commons/filter/SqlFilter.java +++ b/backend/src/main/java/io/dataease/commons/filter/SqlFilter.java @@ -68,7 +68,6 @@ public class SqlFilter implements Filter { } br.close(); } catch (IOException e) { - System.out.println("IOException: " + e); } return str; diff --git a/backend/src/main/java/io/dataease/commons/utils/ExcelReaderUtil.java b/backend/src/main/java/io/dataease/commons/utils/ExcelReaderUtil.java index 41cddf3f21..2bfddcf3de 100644 --- a/backend/src/main/java/io/dataease/commons/utils/ExcelReaderUtil.java +++ b/backend/src/main/java/io/dataease/commons/utils/ExcelReaderUtil.java @@ -68,7 +68,7 @@ public class ExcelReaderUtil { } public static void main(String[] args) throws Exception { - String file ="全国现有确诊趋势.xlsx"; + String file ="下单渠道.xlsx"; ExcelReaderUtil.readExcel(file, new FileInputStream("/Users/taojinlong/Desktop/" + file)); } } diff --git a/backend/src/main/java/io/dataease/controller/sys/LicenseController.java b/backend/src/main/java/io/dataease/controller/sys/LicenseController.java index 0e932cec62..d45745a8bb 100644 --- a/backend/src/main/java/io/dataease/controller/sys/LicenseController.java +++ b/backend/src/main/java/io/dataease/controller/sys/LicenseController.java @@ -32,7 +32,6 @@ public class LicenseController { return ResultHolder.success(null); } F2CLicenseResponse f2CLicenseResponse = defaultLicenseService.validateLicense(); - System.out.println(new Gson().toJson(f2CLicenseResponse)); switch (f2CLicenseResponse.getStatus()) { case no_record: return ResultHolder.success(f2CLicenseResponse); diff --git a/backend/src/main/java/io/dataease/datasource/dto/SqlServerConfigration.java b/backend/src/main/java/io/dataease/datasource/dto/SqlServerConfigration.java index 7282704586..1cbe90c83a 100644 --- a/backend/src/main/java/io/dataease/datasource/dto/SqlServerConfigration.java +++ b/backend/src/main/java/io/dataease/datasource/dto/SqlServerConfigration.java @@ -8,6 +8,7 @@ import lombok.Setter; @Setter public class SqlServerConfigration extends JdbcDTO { private String driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver"; + private String schema; public String getJdbc(){ return "jdbc:sqlserver://HOSTNAME:PORT;DatabaseName=DATABASE".replace("HOSTNAME", getHost()).replace("PORT", getPort().toString()).replace("DATABASE", getDataBase()); diff --git a/backend/src/main/java/io/dataease/datasource/provider/JdbcProvider.java b/backend/src/main/java/io/dataease/datasource/provider/JdbcProvider.java index d2bc037a38..12e30186df 100644 --- a/backend/src/main/java/io/dataease/datasource/provider/JdbcProvider.java +++ b/backend/src/main/java/io/dataease/datasource/provider/JdbcProvider.java @@ -108,7 +108,9 @@ public class JdbcProvider extends DatasourceProvider { int columType = metaData.getColumnType(j + 1); switch (columType) { case Types.DATE: - row[j] = rs.getDate(j + 1).toString(); + if(rs.getDate(j + 1) != null){ + row[j] = rs.getDate(j + 1).toString(); + } break; default: row[j] = rs.getString(j + 1); @@ -287,7 +289,7 @@ public class JdbcProvider extends DatasourceProvider { } tableFiled.setRemarks(remarks); tableFiled.setFieldSize(Integer.valueOf(resultSet.getString("COLUMN_SIZE"))); - String dbType = resultSet.getString("TYPE_NAME"); + String dbType = resultSet.getString("TYPE_NAME").toUpperCase(); tableFiled.setFieldType(dbType); if(dbType.equalsIgnoreCase("LONG")){tableFiled.setFieldSize(65533);} if(StringUtils.isNotEmpty(dbType) && dbType.toLowerCase().contains("date") && tableFiled.getFieldSize() < 50 ){ @@ -506,7 +508,9 @@ public class JdbcProvider extends DatasourceProvider { return "show tables;"; case sqlServer: SqlServerConfigration sqlServerConfigration = new Gson().fromJson(datasourceRequest.getDatasource().getConfiguration(), SqlServerConfigration.class); - return "SELECT TABLE_NAME FROM DATABASE.INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE';".replace("DATABASE", sqlServerConfigration.getDataBase()); + return "SELECT TABLE_NAME FROM DATABASE.INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_SCHEMA = 'DS_SCHEMA' ;" + .replace("DATABASE", sqlServerConfigration.getDataBase()) + .replace("DS_SCHEMA", sqlServerConfigration.getSchema()); case oracle: OracleConfigration oracleConfigration = new Gson().fromJson(datasourceRequest.getDatasource().getConfiguration(), OracleConfigration.class); if(StringUtils.isEmpty(oracleConfigration.getSchema())){ @@ -523,6 +527,8 @@ public class JdbcProvider extends DatasourceProvider { switch (datasourceType) { case oracle: return "select * from all_users"; + case sqlServer: + return "select name from sys.schemas;"; default: return "show tables;"; } diff --git a/backend/src/main/java/io/dataease/dto/chart/AxisChartDataDTO.java b/backend/src/main/java/io/dataease/dto/chart/AxisChartDataDTO.java new file mode 100644 index 0000000000..1301169e90 --- /dev/null +++ b/backend/src/main/java/io/dataease/dto/chart/AxisChartDataDTO.java @@ -0,0 +1,17 @@ +package io.dataease.dto.chart; + +import lombok.Data; + +import java.math.BigDecimal; +import java.util.List; + +/** + * @Author gin + * @Date 2021/8/9 10:14 上午 + */ +@Data +public class AxisChartDataDTO { + private BigDecimal value; + private List dimensionList; + private List quotaList; +} diff --git a/backend/src/main/java/io/dataease/dto/chart/ChartDimensionDTO.java b/backend/src/main/java/io/dataease/dto/chart/ChartDimensionDTO.java new file mode 100644 index 0000000000..a0b139b75c --- /dev/null +++ b/backend/src/main/java/io/dataease/dto/chart/ChartDimensionDTO.java @@ -0,0 +1,13 @@ +package io.dataease.dto.chart; + +import lombok.Data; + +/** + * @Author gin + * @Date 2021/8/9 10:15 上午 + */ +@Data +public class ChartDimensionDTO { + private String id; + private String value; +} diff --git a/backend/src/main/java/io/dataease/dto/chart/ChartQuotaDTO.java b/backend/src/main/java/io/dataease/dto/chart/ChartQuotaDTO.java new file mode 100644 index 0000000000..3784df31cd --- /dev/null +++ b/backend/src/main/java/io/dataease/dto/chart/ChartQuotaDTO.java @@ -0,0 +1,12 @@ +package io.dataease.dto.chart; + +import lombok.Data; + +/** + * @Author gin + * @Date 2021/8/9 10:16 上午 + */ +@Data +public class ChartQuotaDTO { + private String id; +} diff --git a/backend/src/main/java/io/dataease/dto/chart/ScatterChartDataDTO.java b/backend/src/main/java/io/dataease/dto/chart/ScatterChartDataDTO.java new file mode 100644 index 0000000000..d8ee6cd6ef --- /dev/null +++ b/backend/src/main/java/io/dataease/dto/chart/ScatterChartDataDTO.java @@ -0,0 +1,17 @@ +package io.dataease.dto.chart; + +import lombok.Data; + +import java.math.BigDecimal; +import java.util.List; + +/** + * @Author gin + * @Date 2021/8/9 10:14 上午 + */ +@Data +public class ScatterChartDataDTO { + private Object[] value; + private List dimensionList; + private List quotaList; +} diff --git a/backend/src/main/java/io/dataease/plugins/server/XUserKeysServer.java b/backend/src/main/java/io/dataease/plugins/server/XUserKeysServer.java new file mode 100644 index 0000000000..e3fb1e4ea6 --- /dev/null +++ b/backend/src/main/java/io/dataease/plugins/server/XUserKeysServer.java @@ -0,0 +1,61 @@ +package io.dataease.plugins.server; + +import io.dataease.commons.utils.AuthUtils; +import io.dataease.plugins.config.SpringContextUtil; +import io.dataease.plugins.xpack.ukey.dto.request.XpackUkeyDto; +import io.dataease.plugins.xpack.ukey.service.UkeyXpackService; +import org.springframework.web.bind.annotation.*; + +import javax.servlet.ServletRequest; +import java.util.List; + +@RequestMapping("/plugin/ukey") +@RestController +public class XUserKeysServer { + + + @PostMapping("info") + public List getUserKeysInfo() { + + UkeyXpackService ukeyXpackService = SpringContextUtil.getBean(UkeyXpackService.class); + Long userId = AuthUtils.getUser().getUserId(); + return ukeyXpackService.getUserKeysInfo(userId); + } + + @PostMapping("validate") + public String validate(ServletRequest request) { + // return ApiKeyHandler.getUser(WebUtils.toHttp(request)); + return null; + } + + @PostMapping("generate") + public void generateUserKey() { + UkeyXpackService ukeyXpackService = SpringContextUtil.getBean(UkeyXpackService.class); + Long userId = AuthUtils.getUser().getUserId(); + ukeyXpackService.generateUserKey(userId); + } + + @PostMapping("delete/{id}") + public void deleteUserKey(@PathVariable Long id) { + UkeyXpackService ukeyXpackService = SpringContextUtil.getBean(UkeyXpackService.class); + ukeyXpackService.deleteUserKey(id); + } + + @PostMapping("changeStatus/{id}") + public void changeStatus(@PathVariable Long id) { + UkeyXpackService ukeyXpackService = SpringContextUtil.getBean(UkeyXpackService.class); + ukeyXpackService.switchStatus(id); + } + + /*@GetMapping("active/{id}") + public void activeUserKey(@PathVariable Long id) { + UkeyXpackService ukeyXpackService = SpringContextUtil.getBean(UkeyXpackService.class); + ukeyXpackService.activeUserKey(id); + } + + @GetMapping("disable/{id}") + public void disabledUserKey(@PathVariable Long id) { + UkeyXpackService ukeyXpackService = SpringContextUtil.getBean(UkeyXpackService.class); + ukeyXpackService.disableUserKey(id); + }*/ +} diff --git a/backend/src/main/java/io/dataease/provider/QueryProvider.java b/backend/src/main/java/io/dataease/provider/QueryProvider.java index b0ba96cb2c..4c56399036 100644 --- a/backend/src/main/java/io/dataease/provider/QueryProvider.java +++ b/backend/src/main/java/io/dataease/provider/QueryProvider.java @@ -1,6 +1,7 @@ package io.dataease.provider; import io.dataease.base.domain.DatasetTableField; +import io.dataease.base.domain.Datasource; import io.dataease.controller.request.chart.ChartExtFilterRequest; import io.dataease.dto.chart.ChartCustomFilterDTO; import io.dataease.dto.chart.ChartViewFieldDTO; @@ -12,21 +13,18 @@ import java.util.List; * @Date 2021/5/17 2:42 下午 */ public abstract class QueryProvider { + public abstract Integer transFieldType(String field); - public abstract String createQueryCountSQL(String table); - - public abstract String createQueryCountSQLAsTmp(String sql); - public abstract String createSQLPreview(String sql, String orderBy); - public abstract String createQuerySQL(String table, List fields, boolean isGroup); + public abstract String createQuerySQL(String table, List fields, boolean isGroup, Datasource ds); public abstract String createQuerySQLAsTmp(String sql, List fields, boolean isGroup); - public abstract String createQuerySQLWithPage(String table, List fields, Integer page, Integer pageSize, Integer realSize, boolean isGroup); + public abstract String createQuerySQLWithPage(String table, List fields, Integer page, Integer pageSize, Integer realSize, boolean isGroup, Datasource ds); - public abstract String createQueryTableWithLimit(String table, List fields, Integer limit, boolean isGroup); + public abstract String createQueryTableWithLimit(String table, List fields, Integer limit, boolean isGroup, Datasource ds); public abstract String createQuerySqlWithLimit(String sql, List fields, Integer limit, boolean isGroup); diff --git a/backend/src/main/java/io/dataease/provider/doris/DorisQueryProvider.java b/backend/src/main/java/io/dataease/provider/doris/DorisQueryProvider.java index 96d22045fe..8a411a6de6 100644 --- a/backend/src/main/java/io/dataease/provider/doris/DorisQueryProvider.java +++ b/backend/src/main/java/io/dataease/provider/doris/DorisQueryProvider.java @@ -2,6 +2,7 @@ package io.dataease.provider.doris; import io.dataease.base.domain.DatasetTableField; import io.dataease.base.domain.DatasetTableFieldExample; +import io.dataease.base.domain.Datasource; import io.dataease.base.mapper.DatasetTableFieldMapper; import io.dataease.controller.request.chart.ChartExtFilterRequest; import io.dataease.dto.chart.ChartCustomFilterDTO; @@ -70,23 +71,13 @@ public class DorisQueryProvider extends QueryProvider { } } - @Override - public String createQueryCountSQL(String table) { - return MessageFormat.format("SELECT count(*) FROM {0}", table); - } - - @Override - public String createQueryCountSQLAsTmp(String sql) { - return createQueryCountSQL(" (" + sql + ") AS tmp "); - } - @Override public String createSQLPreview(String sql, String orderBy) { return "SELECT * FROM (" + sql + ") AS tmp ORDER BY " + orderBy + " LIMIT 0,1000"; } @Override - public String createQuerySQL(String table, List fields, boolean isGroup) { + public String createQuerySQL(String table, List fields, boolean isGroup, Datasource ds) { SQLObj tableObj = SQLObj.builder() .tableName((table.startsWith("(") && table.endsWith(")")) ? table : String.format(DorisConstants.KEYWORD_TABLE, table)) .tableAlias(String.format(TABLE_ALIAS_PREFIX, 0)) @@ -159,17 +150,17 @@ public class DorisQueryProvider extends QueryProvider { @Override public String createQuerySQLAsTmp(String sql, List fields, boolean isGroup) { - return createQuerySQL("(" + sql + ")", fields, isGroup); + return createQuerySQL("(" + sql + ")", fields, isGroup, null); } @Override - public String createQuerySQLWithPage(String table, List fields, Integer page, Integer pageSize, Integer realSize, boolean isGroup) { - return createQuerySQL(table, fields, isGroup) + " LIMIT " + (page - 1) * pageSize + "," + realSize; + public String createQuerySQLWithPage(String table, List fields, Integer page, Integer pageSize, Integer realSize, boolean isGroup, Datasource ds) { + return createQuerySQL(table, fields, isGroup, null) + " LIMIT " + (page - 1) * pageSize + "," + realSize; } @Override - public String createQueryTableWithLimit(String table, List fields, Integer limit, boolean isGroup) { - return createQuerySQL(table, fields, isGroup) + " LIMIT 0," + limit; + public String createQueryTableWithLimit(String table, List fields, Integer limit, boolean isGroup, Datasource ds) { + return createQuerySQL(table, fields, isGroup, null) + " LIMIT 0," + limit; } @Override diff --git a/backend/src/main/java/io/dataease/provider/mysql/MysqlQueryProvider.java b/backend/src/main/java/io/dataease/provider/mysql/MysqlQueryProvider.java index 56ad71c2f8..5702a9a68d 100644 --- a/backend/src/main/java/io/dataease/provider/mysql/MysqlQueryProvider.java +++ b/backend/src/main/java/io/dataease/provider/mysql/MysqlQueryProvider.java @@ -2,6 +2,7 @@ package io.dataease.provider.mysql; import io.dataease.base.domain.DatasetTableField; import io.dataease.base.domain.DatasetTableFieldExample; +import io.dataease.base.domain.Datasource; import io.dataease.base.mapper.DatasetTableFieldMapper; import io.dataease.controller.request.chart.ChartExtFilterRequest; import io.dataease.dto.chart.ChartCustomFilterDTO; @@ -70,23 +71,13 @@ public class MysqlQueryProvider extends QueryProvider { } } - @Override - public String createQueryCountSQL(String table) { - return MessageFormat.format("SELECT COUNT(*) FROM {0}", table); - } - - @Override - public String createQueryCountSQLAsTmp(String sql) { - return createQueryCountSQL(" (" + sqlFix(sql) + ") AS tmp "); - } - @Override public String createSQLPreview(String sql, String orderBy) { return "SELECT * FROM (" + sqlFix(sql) + ") AS tmp ORDER BY null " + " LIMIT 0,1000"; } @Override - public String createQuerySQL(String table, List fields, boolean isGroup) { + public String createQuerySQL(String table, List fields, boolean isGroup, Datasource ds) { SQLObj tableObj = SQLObj.builder() .tableName((table.startsWith("(") && table.endsWith(")")) ? table : String.format(MySQLConstants.KEYWORD_TABLE, table)) .tableAlias(String.format(TABLE_ALIAS_PREFIX, 0)) @@ -150,17 +141,17 @@ public class MysqlQueryProvider extends QueryProvider { @Override public String createQuerySQLAsTmp(String sql, List fields, boolean isGroup) { - return createQuerySQL("(" + sqlFix(sql) + ")", fields, isGroup); + return createQuerySQL("(" + sqlFix(sql) + ")", fields, isGroup, null); } @Override - public String createQuerySQLWithPage(String table, List fields, Integer page, Integer pageSize, Integer realSize, boolean isGroup) { - return createQuerySQL(table, fields, isGroup) + " LIMIT " + (page - 1) * pageSize + "," + realSize; + public String createQuerySQLWithPage(String table, List fields, Integer page, Integer pageSize, Integer realSize, boolean isGroup, Datasource ds) { + return createQuerySQL(table, fields, isGroup, null) + " LIMIT " + (page - 1) * pageSize + "," + realSize; } @Override - public String createQueryTableWithLimit(String table, List fields, Integer limit, boolean isGroup) { - return createQuerySQL(table, fields, isGroup) + " LIMIT 0," + limit; + public String createQueryTableWithLimit(String table, List fields, Integer limit, boolean isGroup, Datasource ds) { + return createQuerySQL(table, fields, isGroup, null) + " LIMIT 0," + limit; } @Override diff --git a/backend/src/main/java/io/dataease/provider/oracle/OracleQueryProvider.java b/backend/src/main/java/io/dataease/provider/oracle/OracleQueryProvider.java index 140387a1d3..02af808450 100644 --- a/backend/src/main/java/io/dataease/provider/oracle/OracleQueryProvider.java +++ b/backend/src/main/java/io/dataease/provider/oracle/OracleQueryProvider.java @@ -2,6 +2,7 @@ package io.dataease.provider.oracle; import io.dataease.base.domain.DatasetTableField; import io.dataease.base.domain.DatasetTableFieldExample; +import io.dataease.base.domain.Datasource; import io.dataease.base.mapper.DatasetTableFieldMapper; import io.dataease.controller.request.chart.ChartExtFilterRequest; import io.dataease.dto.chart.ChartCustomFilterDTO; @@ -82,23 +83,13 @@ public class OracleQueryProvider extends QueryProvider { } } - @Override - public String createQueryCountSQL(String table) { - return MessageFormat.format("SELECT COUNT(*) FROM {0}", table); - } - - @Override - public String createQueryCountSQLAsTmp(String sql) { - return createQueryCountSQL(" (" + sqlFix(sql) + ") DE_TMP "); - } - @Override public String createSQLPreview(String sql, String orderBy) { return "SELECT * FROM (" + sqlFix(sql) + ") DE_TMP " + " WHERE rownum <= 1000"; } @Override - public String createQuerySQL(String table, List fields, boolean isGroup) { + public String createQuerySQL(String table, List fields, boolean isGroup, Datasource ds) { SQLObj tableObj = SQLObj.builder() .tableName((table.startsWith("(") && table.endsWith(")")) ? table : String.format(OracleConstants.KEYWORD_TABLE, table)) .tableAlias(String.format(OracleConstants.ALIAS_FIX, String.format(TABLE_ALIAS_PREFIX, 0))) @@ -179,19 +170,19 @@ public class OracleQueryProvider extends QueryProvider { @Override public String createQuerySQLAsTmp(String sql, List fields, boolean isGroup) { - return createQuerySQL("(" + sqlFix(sql) + ")", fields, isGroup); + return createQuerySQL("(" + sqlFix(sql) + ")", fields, isGroup, null); } @Override - public String createQuerySQLWithPage(String table, List fields, Integer page, Integer pageSize, Integer realSize, boolean isGroup) { + public String createQuerySQLWithPage(String table, List fields, Integer page, Integer pageSize, Integer realSize, boolean isGroup, Datasource ds) { List xFields = xFields(table, fields); return MessageFormat.format("SELECT {0} FROM ( SELECT DE_TMP.*, rownum r FROM ( {1} ) DE_TMP WHERE rownum <= {2} ) WHERE r > {3} ", - sqlColumn(xFields), createQuerySQL(table, fields, isGroup), Integer.valueOf(page * realSize).toString(), Integer.valueOf((page - 1) * pageSize).toString()); + sqlColumn(xFields), createQuerySQL(table, fields, isGroup, null), Integer.valueOf(page * realSize).toString(), Integer.valueOf((page - 1) * pageSize).toString()); } @Override - public String createQueryTableWithLimit(String table, List fields, Integer limit, boolean isGroup) { + public String createQueryTableWithLimit(String table, List fields, Integer limit, boolean isGroup, Datasource ds) { return String.format("SELECT %s.* from %s WHERE rownum <= %s ", table, table, limit.toString()); } @@ -641,10 +632,10 @@ public class OracleQueryProvider extends QueryProvider { public String createRawQuerySQL(String table, List fields) { String[] array = fields.stream().map(f -> { StringBuilder stringBuilder = new StringBuilder(); - stringBuilder.append(" ").append(f.getOriginName()); + stringBuilder.append(" \"").append(f.getOriginName()).append("\""); return stringBuilder.toString(); }).toArray(String[]::new); - return MessageFormat.format("SELECT {0} FROM {1} ORDER BY null", StringUtils.join(array, ","), table); + return MessageFormat.format("SELECT {0} FROM {1} ORDER BY null", StringUtils.join(array, ","), "\"" + table + "\""); } @Override diff --git a/backend/src/main/java/io/dataease/provider/sqlserver/SqlServerSQLConstants.java b/backend/src/main/java/io/dataease/provider/sqlserver/SqlServerSQLConstants.java new file mode 100644 index 0000000000..4ea9eda683 --- /dev/null +++ b/backend/src/main/java/io/dataease/provider/sqlserver/SqlServerSQLConstants.java @@ -0,0 +1,43 @@ +package io.dataease.provider.sqlserver; + +import io.dataease.provider.SQLConstants; + +import static io.dataease.datasource.constants.DatasourceTypes.sqlServer; + +/** + * @Author gin + * @Date 2021/7/8 7:22 下午 + */ +public class SqlServerSQLConstants extends SQLConstants { + public static final String KEYWORD_TABLE = sqlServer.getKeywordPrefix() + "%s" + sqlServer.getKeywordSuffix(); + + public static final String KEYWORD_FIX = "%s." + sqlServer.getKeywordPrefix() + "%s" + sqlServer.getKeywordSuffix(); + + public static final String UNIX_TIMESTAMP = "CAST(DATEDIFF(ss,'1970-01-01 08:00:00', %s) as bigint ) * 1000 "; + + public static final String DATE_FORMAT = "CONVERT(varchar(100), %s, %s)"; + + public static final String FROM_UNIXTIME = "convert(varchar, %s ,120)"; + + public static final String CONVERT = "CONVERT(%s, %s)"; + + public static final String LONG_TO_DATE = "DATEADD(second,%s,'1970-01-01 08:00:00')"; + + public static final String STRING_TO_DATE = "CONVERT(datetime, %s ,120)"; + + public static final String DEFAULT_INT_FORMAT = "DECIMAL(20,0)"; + + public static final String DEFAULT_FLOAT_FORMAT = "DECIMAL(20,2)"; + + public static final String WHERE_VALUE_NULL = "(NULL,'')"; + + public static final String WHERE_VALUE_VALUE = "'%s'"; + + public static final String AGG_COUNT = "COUNT(*)"; + + public static final String AGG_FIELD = "%s(%s)"; + + public static final String WHERE_BETWEEN = "'%s' AND '%s'"; + + public static final String BRACKETS = "(%s)"; +} diff --git a/backend/src/main/java/io/dataease/provider/sqlserver/SqlserverQueryProvider.java b/backend/src/main/java/io/dataease/provider/sqlserver/SqlserverQueryProvider.java index 2096399f82..2c8d0254ba 100644 --- a/backend/src/main/java/io/dataease/provider/sqlserver/SqlserverQueryProvider.java +++ b/backend/src/main/java/io/dataease/provider/sqlserver/SqlserverQueryProvider.java @@ -1,533 +1,919 @@ -//package io.dataease.provider.sqlserver; -// -//import io.dataease.base.domain.DatasetTableField; -//import io.dataease.controller.request.chart.ChartExtFilterRequest; -//import io.dataease.dto.chart.ChartCustomFilterDTO; -//import io.dataease.dto.chart.ChartViewFieldDTO; -//import io.dataease.provider.QueryProvider; -//import org.apache.commons.collections4.CollectionUtils; -//import org.apache.commons.lang3.ObjectUtils; -//import org.apache.commons.lang3.StringUtils; -//import org.springframework.stereotype.Service; -// -//import java.text.MessageFormat; -//import java.text.SimpleDateFormat; -//import java.util.Arrays; -//import java.util.Date; -//import java.util.List; -// -///** -// * @Author gin -// * @Date 2021/5/17 2:43 下午 -// */ -//@Service("sqlServerQuery") -//public class SqlserverQueryProvider extends QueryProvider { -// @Override -// public Integer transFieldType(String field) { -// switch (field) { -// case "CHAR": -// case "VARCHAR": -// case "TEXT": -// case "TINYTEXT": -// case "MEDIUMTEXT": -// case "LONGTEXT": -// case "ENUM": -// return 0;// 文本 -// case "DATE": -// case "TIME": -// case "YEAR": -// case "DATETIME": -// case "TIMESTAMP": -// return 1;// 时间 -// case "INT": -// case "SMALLINT": -// case "MEDIUMINT": -// case "INTEGER": -// case "BIGINT": -// return 2;// 整型 -// case "FLOAT": -// case "DOUBLE": -// case "DECIMAL": -// return 3;// 浮点 -// case "BIT": -// case "TINYINT": -// return 4;// 布尔 -// default: -// return 0; -// } -// } -// -// @Override -// public String createQueryCountSQL(String table) { -// return MessageFormat.format("SELECT COUNT(*) FROM {0}", table); -// } -// -// @Override -// public String createQueryCountSQLAsTmp(String sql) { -// return createQueryCountSQL(" (" + sqlFix(sql) + ") AS tmp "); -// } -// -// @Override -// public String createSQLPreview(String sql, String orderBy) { -// return "SELECT * FROM (" + sqlFix(sql) + ") AS tmp ORDER BY null " + " LIMIT 0,1000"; -// } -// -// @Override -// public String createQuerySQL(String table, List fields) { -// String[] array = fields.stream().map(f -> { -// StringBuilder stringBuilder = new StringBuilder(); -// // 如果原始类型为时间 -// if (f.getDeExtractType() == 1) { -// if (f.getDeType() == 2 || f.getDeType() == 3) { -// stringBuilder.append("UNIX_TIMESTAMP(`").append(f.getOriginName()).append("`)*1000 AS ").append(f.getDataeaseName()); -// } else { -// stringBuilder.append("`").append(f.getOriginName()).append("` AS ").append(f.getDataeaseName()); -// } -// } else if (f.getDeExtractType() == 0) { -// if (f.getDeType() == 2) { -// stringBuilder.append("CAST(`").append(f.getOriginName()).append("` AS DECIMAL(20,0)) AS ").append(f.getDataeaseName()); -// } else if (f.getDeType() == 3) { -// stringBuilder.append("CAST(`").append(f.getOriginName()).append("` AS DECIMAL(20,2)) AS ").append(f.getDataeaseName()); -// } else if (f.getDeType() == 1) { -// stringBuilder.append("DATE_FORMAT(`").append(f.getOriginName()).append("`,'%Y-%m-%d %H:%i:%S') AS _").append(f.getDataeaseName()); -// } else { -// stringBuilder.append("`").append(f.getOriginName()).append("` AS ").append(f.getDataeaseName()); -// } +package io.dataease.provider.sqlserver; + +import com.google.gson.Gson; +import io.dataease.base.domain.DatasetTableField; +import io.dataease.base.domain.DatasetTableFieldExample; +import io.dataease.base.domain.Datasource; +import io.dataease.base.mapper.DatasetTableFieldMapper; +import io.dataease.commons.constants.DeTypeConstants; +import io.dataease.controller.request.chart.ChartExtFilterRequest; +import io.dataease.datasource.dto.SqlServerConfigration; +import io.dataease.dto.chart.ChartCustomFilterDTO; +import io.dataease.dto.chart.ChartViewFieldDTO; +import io.dataease.dto.sqlObj.SQLObj; +import io.dataease.provider.QueryProvider; +import io.dataease.provider.SQLConstants; +import io.dataease.provider.mysql.MySQLConstants; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.ObjectUtils; +import org.apache.commons.lang3.StringUtils; +import org.springframework.stereotype.Service; +import org.stringtemplate.v4.ST; +import org.stringtemplate.v4.STGroup; +import org.stringtemplate.v4.STGroupFile; + +import javax.annotation.Resource; +import java.text.MessageFormat; +import java.text.SimpleDateFormat; +import java.util.*; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import static io.dataease.provider.SQLConstants.TABLE_ALIAS_PREFIX; + +@Service("sqlserverQuery") +public class SqlserverQueryProvider extends QueryProvider { + @Resource + private DatasetTableFieldMapper datasetTableFieldMapper; + + @Override + public Integer transFieldType(String field) { + switch (field) { + case "CHAR": + case "NCHAR": + case "NTEXT": + case "VARCHAR": + case "TEXT": + case "TINYTEXT": + case "MEDIUMTEXT": + case "LONGTEXT": + case "ENUM": + case "XML": + case "TIME": + return DeTypeConstants.DE_STRING;// 文本 + case "DATE": + case "YEAR": + case "DATETIME": + case "DATETIME2": + case "DATETIMEOFFSET": + return DeTypeConstants.DE_TIME;// 时间 + case "INT": + case "MEDIUMINT": + case "INTEGER": + case "BIGINT": + case "SMALLINT": + return DeTypeConstants.DE_INT;// 整型 + case "FLOAT": + case "DOUBLE": + case "DECIMAL": + case "MONEY": + case "NUMERIC": + return DeTypeConstants.DE_FLOAT;// 浮点 + case "BIT": + case "TINYINT": + return DeTypeConstants.DE_BOOL;// 布尔 + case "TIMESTAMP": + return DeTypeConstants.DE_Binary;// 二进制 + default: + return DeTypeConstants.DE_STRING; + } + } + + @Override + public String createSQLPreview(String sql, String orderBy) { + return "SELECT top 1000 * FROM (" + sqlFix(sql) + ") AS tmp"; + } + + @Override + public String createQuerySQL(String table, List fields, boolean isGroup, Datasource ds) { + + SQLObj tableObj = SQLObj.builder() + .tableName((table.startsWith("(") && table.endsWith(")")) ? table : String.format(SqlServerSQLConstants.KEYWORD_TABLE, table)) + .tableAlias(String.format(TABLE_ALIAS_PREFIX, 0)) + .build(); + if(ds != null){ + String schema = new Gson().fromJson(ds.getConfiguration(), SqlServerConfigration.class).getSchema(); + tableObj.setTableName(schema + "." + tableObj.getTableName()); + } + + List xFields = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(fields)) { + for (int i = 0; i < fields.size(); i++) { + DatasetTableField f = fields.get(i); + String originField = String.format(SqlServerSQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), f.getOriginName()); + String fieldAlias = String.format(SQLConstants.FIELD_ALIAS_X_PREFIX, i); + String fieldName = ""; + // 处理横轴字段 + if (f.getDeExtractType() == DeTypeConstants.DE_TIME) { // 时间 转为 数值 + if (f.getDeType() == DeTypeConstants.DE_INT || f.getDeType() == DeTypeConstants.DE_FLOAT) { + fieldName = String.format(SqlServerSQLConstants.UNIX_TIMESTAMP, originField); + } else { + fieldName = originField; + } + } else if (f.getDeExtractType() == DeTypeConstants.DE_STRING) { + if (f.getDeType() == DeTypeConstants.DE_INT) { + fieldName = String.format(SqlServerSQLConstants.CONVERT, SqlServerSQLConstants.DEFAULT_INT_FORMAT, originField); + } else if (f.getDeType() == DeTypeConstants.DE_FLOAT) { + fieldName = String.format(SqlServerSQLConstants.CONVERT, SqlServerSQLConstants.DEFAULT_FLOAT_FORMAT, originField); + } else if (f.getDeType() == DeTypeConstants.DE_TIME) { //字符串转时间 + fieldName = String.format(SqlServerSQLConstants.STRING_TO_DATE, originField); + } else { + fieldName = originField; + } + } else { + if (f.getDeType() == DeTypeConstants.DE_TIME) { // 数值转时间 + String cast = String.format(SqlServerSQLConstants.LONG_TO_DATE, originField + "/1000"); + fieldName = String.format(SqlServerSQLConstants.FROM_UNIXTIME, cast); + } else if (f.getDeType() == DeTypeConstants.DE_INT) { + fieldName = String.format(SqlServerSQLConstants.CONVERT, SqlServerSQLConstants.DEFAULT_INT_FORMAT, originField); + } else { + fieldName = originField; + } + } + xFields.add(SQLObj.builder() + .fieldName(fieldName) + .fieldAlias(fieldAlias) + .build()); + } + } + + STGroup stg = new STGroupFile(SQLConstants.SQL_TEMPLATE); + ST st_sql = stg.getInstanceOf("previewSql"); + st_sql.add("isGroup", isGroup); + if (CollectionUtils.isNotEmpty(xFields)) st_sql.add("groups", xFields); + if (ObjectUtils.isNotEmpty(tableObj)) st_sql.add("table", tableObj); + return st_sql.render(); + } + + @Override + public String createQuerySQLAsTmp(String sql, List fields, boolean isGroup) { + return createQuerySQL("(" + sqlFix(sql) + ")", fields, isGroup, null); + } + + @Override + public String createQuerySQLWithPage(String table, List fields, Integer page, Integer pageSize, Integer realSize, boolean isGroup, Datasource ds) { + return createQuerySQL(table, fields, isGroup, ds) + " ORDER BY \"" + fields.get(0).getOriginName() + "\" offset " + (page - 1) * pageSize + " rows fetch next " + realSize + " rows only"; + } + + @Override + public String createQuerySQLAsTmpWithPage(String sql, List fields, Integer page, Integer pageSize, Integer realSize, boolean isGroup) { + return createQuerySQLAsTmp(sql, fields, isGroup) + " ORDER BY \"" + fields.get(0).getOriginName() + "\" offset " + (page - 1) * pageSize + " rows fetch next " + realSize + " rows only"; + } + + @Override + public String createQueryTableWithLimit(String table, List fields, Integer limit, boolean isGroup, Datasource ds) { + return createQuerySQL(table, fields, isGroup, ds) + " ORDER BY \"" + fields.get(0).getOriginName() + "\" offset 0 rows fetch next " + limit + " rows only"; + } + + @Override + public String createQuerySqlWithLimit(String sql, List fields, Integer limit, boolean isGroup) { + return createQuerySQLAsTmp(sql, fields, isGroup) + " ORDER BY \"" + fields.get(0).getOriginName() + "\" offset 0 rows fetch next " + limit + " rows only"; + } + + @Override + public String getSQL(String table, List xAxis, List yAxis, List customFilter, List extFilterRequestList) { + SQLObj tableObj = SQLObj.builder() + .tableName((table.startsWith("(") && table.endsWith(")")) ? table : String.format(SqlServerSQLConstants.KEYWORD_TABLE, table)) + .tableAlias(String.format(TABLE_ALIAS_PREFIX, 0)) + .build(); + List xFields = new ArrayList<>(); + List xWheres = new ArrayList<>(); + List xOrders = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(xAxis)) { + for (int i = 0; i < xAxis.size(); i++) { + ChartViewFieldDTO x = xAxis.get(i); + String originField = String.format(SqlServerSQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), x.getOriginName()); + String fieldAlias = String.format(SQLConstants.FIELD_ALIAS_X_PREFIX, i); + // 处理横轴字段 + xFields.add(getXFields(x, originField, fieldAlias)); + // 处理横轴过滤 +// xWheres.addAll(getXWheres(x, originField, fieldAlias)); + // 处理横轴排序 + if (StringUtils.isNotEmpty(x.getSort()) && !StringUtils.equalsIgnoreCase(x.getSort(), "none")) { + xOrders.add(SQLObj.builder() + .orderField(originField) + .orderAlias(fieldAlias) + .orderDirection(x.getSort()) + .build()); + } + } + } + List yFields = new ArrayList<>(); + List yWheres = new ArrayList<>(); + List yOrders = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(yAxis)) { + for (int i = 0; i < yAxis.size(); i++) { + ChartViewFieldDTO y = yAxis.get(i); + String originField = String.format(SqlServerSQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), y.getOriginName()); + String fieldAlias = String.format(SQLConstants.FIELD_ALIAS_Y_PREFIX, i); + // 处理纵轴字段 + yFields.add(getYFields(y, originField, fieldAlias)); + // 处理纵轴过滤 + yWheres.addAll(getYWheres(y, originField, fieldAlias)); + // 处理纵轴排序 + if (StringUtils.isNotEmpty(y.getSort()) && !StringUtils.equalsIgnoreCase(y.getSort(), "none")) { + yOrders.add(SQLObj.builder() + .orderField(originField) + .orderAlias(fieldAlias) + .orderDirection(y.getSort()) + .build()); + } + } + } + // 处理视图中字段过滤 + List customWheres = transCustomFilterList(tableObj, customFilter); + // 处理仪表板字段过滤 + List extWheres = transExtFilterList(tableObj, extFilterRequestList); + // 构建sql所有参数 + List fields = new ArrayList<>(); + fields.addAll(xFields); + fields.addAll(yFields); + List wheres = new ArrayList<>(); + wheres.addAll(xWheres); + if (customWheres != null) wheres.addAll(customWheres); + if (extWheres != null) wheres.addAll(extWheres); + List groups = new ArrayList<>(); + groups.addAll(xFields); + // 外层再次套sql + List orders = new ArrayList<>(); + orders.addAll(xOrders); + orders.addAll(yOrders); + List aggWheres = new ArrayList<>(); + aggWheres.addAll(yWheres); + + STGroup stg = new STGroupFile(SQLConstants.SQL_TEMPLATE); + ST st_sql = stg.getInstanceOf("querySql"); + if (CollectionUtils.isNotEmpty(xFields)) st_sql.add("groups", xFields); + if (CollectionUtils.isNotEmpty(yFields)) st_sql.add("aggregators", yFields); + if (CollectionUtils.isNotEmpty(wheres)) st_sql.add("filters", wheres); + if (ObjectUtils.isNotEmpty(tableObj)) st_sql.add("table", tableObj); + String sql = st_sql.render(); + + ST st = stg.getInstanceOf("querySql"); + SQLObj tableSQL = SQLObj.builder() + .tableName(String.format(SqlServerSQLConstants.BRACKETS, sql)) + .tableAlias(String.format(TABLE_ALIAS_PREFIX, 1)) + .build(); + if (CollectionUtils.isNotEmpty(aggWheres)) st.add("filters", aggWheres); + if (CollectionUtils.isNotEmpty(orders)) st.add("orders", orders); + if (ObjectUtils.isNotEmpty(tableSQL)) st.add("table", tableSQL); + return st.render(); + } + + + @Override + public String getSQLAsTmp(String sql, List xAxis, List yAxis, List customFilter, List extFilterRequestList) { + return getSQL("(" + sqlFix(sql) + ")", xAxis, yAxis, customFilter, extFilterRequestList); + } + + @Override + public String getSQLStack(String table, List xAxis, List yAxis, List customFilter, List extFilterRequestList, List extStack) { + SQLObj tableObj = SQLObj.builder() + .tableName((table.startsWith("(") && table.endsWith(")")) ? table : String.format(SqlServerSQLConstants.KEYWORD_TABLE, table)) + .tableAlias(String.format(TABLE_ALIAS_PREFIX, 0)) + .build(); + List xFields = new ArrayList<>(); + List xWheres = new ArrayList<>(); + List xOrders = new ArrayList<>(); + List xList = new ArrayList<>(); + xList.addAll(xAxis); + xList.addAll(extStack); + if (CollectionUtils.isNotEmpty(xList)) { + for (int i = 0; i < xList.size(); i++) { + ChartViewFieldDTO x = xList.get(i); + String originField = String.format(SqlServerSQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), x.getOriginName()); + String fieldAlias = String.format(SQLConstants.FIELD_ALIAS_X_PREFIX, i); + // 处理横轴字段 + xFields.add(getXFields(x, originField, fieldAlias)); + // 处理横轴过滤 +// xWheres.addAll(getXWheres(x, originField, fieldAlias)); + // 处理横轴排序 + if (StringUtils.isNotEmpty(x.getSort()) && !StringUtils.equalsIgnoreCase(x.getSort(), "none")) { + xOrders.add(SQLObj.builder() + .orderField(originField) + .orderAlias(fieldAlias) + .orderDirection(x.getSort()) + .build()); + } + } + } + List yFields = new ArrayList<>(); + List yWheres = new ArrayList<>(); + List yOrders = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(yAxis)) { + for (int i = 0; i < yAxis.size(); i++) { + ChartViewFieldDTO y = yAxis.get(i); + String originField = String.format(SqlServerSQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), y.getOriginName()); + String fieldAlias = String.format(SQLConstants.FIELD_ALIAS_Y_PREFIX, i); + // 处理纵轴字段 + yFields.add(getYFields(y, originField, fieldAlias)); + // 处理纵轴过滤 + yWheres.addAll(getYWheres(y, originField, fieldAlias)); + // 处理纵轴排序 + if (StringUtils.isNotEmpty(y.getSort()) && !StringUtils.equalsIgnoreCase(y.getSort(), "none")) { + yOrders.add(SQLObj.builder() + .orderField(originField) + .orderAlias(fieldAlias) + .orderDirection(y.getSort()) + .build()); + } + } + } + List stackFields = new ArrayList<>(); + List stackOrders = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(extStack)) { + for (int i = 0; i < extStack.size(); i++) { + ChartViewFieldDTO stack = extStack.get(i); + String originField = String.format(SqlServerSQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), stack.getOriginName()); + String fieldAlias = String.format(SQLConstants.FIELD_ALIAS_X_PREFIX, i); + // 处理横轴字段 + stackFields.add(getXFields(stack, originField, fieldAlias)); + // 处理横轴排序 + if (StringUtils.isNotEmpty(stack.getSort()) && !StringUtils.equalsIgnoreCase(stack.getSort(), "none")) { + stackOrders.add(SQLObj.builder() + .orderField(originField) + .orderAlias(fieldAlias) + .orderDirection(stack.getSort()) + .build()); + } + } + } + // 处理视图中字段过滤 + List customWheres = transCustomFilterList(tableObj, customFilter); + // 处理仪表板字段过滤 + List extWheres = transExtFilterList(tableObj, extFilterRequestList); + // 构建sql所有参数 + List fields = new ArrayList<>(); + fields.addAll(xFields); + fields.addAll(yFields); + List wheres = new ArrayList<>(); + wheres.addAll(xWheres); + if (customWheres != null) wheres.addAll(customWheres); + if (extWheres != null) wheres.addAll(extWheres); + List groups = new ArrayList<>(); + groups.addAll(xFields); + // 外层再次套sql + List orders = new ArrayList<>(); + orders.addAll(xOrders); + orders.addAll(yOrders); + List aggWheres = new ArrayList<>(); + aggWheres.addAll(yWheres); + + STGroup stg = new STGroupFile(SQLConstants.SQL_TEMPLATE); + ST st_sql = stg.getInstanceOf("querySql"); + if (CollectionUtils.isNotEmpty(xFields)) st_sql.add("groups", xFields); + if (CollectionUtils.isNotEmpty(yFields)) st_sql.add("aggregators", yFields); + if (CollectionUtils.isNotEmpty(wheres)) st_sql.add("filters", wheres); + if (ObjectUtils.isNotEmpty(tableObj)) st_sql.add("table", tableObj); + String sql = st_sql.render(); + + ST st = stg.getInstanceOf("querySql"); + SQLObj tableSQL = SQLObj.builder() + .tableName(String.format(SqlServerSQLConstants.BRACKETS, sql)) + .tableAlias(String.format(TABLE_ALIAS_PREFIX, 1)) + .build(); + if (CollectionUtils.isNotEmpty(aggWheres)) st.add("filters", aggWheres); + if (CollectionUtils.isNotEmpty(orders)) st.add("orders", orders); + if (ObjectUtils.isNotEmpty(tableSQL)) st.add("table", tableSQL); + return st.render(); + } + + @Override + public String getSQLAsTmpStack(String table, List xAxis, List yAxis, List customFilter, List extFilterRequestList, List extStack) { + return getSQLStack("(" + sqlFix(table) + ")", xAxis, yAxis, customFilter, extFilterRequestList, extStack); + } + + @Override + public String getSQLScatter(String table, List xAxis, List yAxis, List customFilter, List extFilterRequestList, List extBubble) { + SQLObj tableObj = SQLObj.builder() + .tableName((table.startsWith("(") && table.endsWith(")")) ? table : String.format(MySQLConstants.KEYWORD_TABLE, table)) + .tableAlias(String.format(TABLE_ALIAS_PREFIX, 0)) + .build(); + List xFields = new ArrayList<>(); + List xWheres = new ArrayList<>(); + List xOrders = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(xAxis)) { + for (int i = 0; i < xAxis.size(); i++) { + ChartViewFieldDTO x = xAxis.get(i); + String originField; + if (ObjectUtils.isNotEmpty(x.getExtField()) && x.getExtField() == 2) { + // 解析origin name中有关联的字段生成sql表达式 + originField = calcFieldRegex(x.getOriginName(), tableObj); + } else if (ObjectUtils.isNotEmpty(x.getExtField()) && x.getExtField() == 1) { + originField = String.format(MySQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), x.getOriginName()); + } else { + originField = String.format(MySQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), x.getOriginName()); + } + String fieldAlias = String.format(SQLConstants.FIELD_ALIAS_X_PREFIX, i); + // 处理横轴字段 + xFields.add(getXFields(x, originField, fieldAlias)); + // 处理横轴过滤 +// xWheres.addAll(getXWheres(x, originField, fieldAlias)); + // 处理横轴排序 + if (StringUtils.isNotEmpty(x.getSort()) && !StringUtils.equalsIgnoreCase(x.getSort(), "none")) { + xOrders.add(SQLObj.builder() + .orderField(originField) + .orderAlias(fieldAlias) + .orderDirection(x.getSort()) + .build()); + } + } + } + List yFields = new ArrayList<>(); + List yWheres = new ArrayList<>(); + List yOrders = new ArrayList<>(); + List yList = new ArrayList<>(); + yList.addAll(yAxis); + yList.addAll(extBubble); + if (CollectionUtils.isNotEmpty(yList)) { + for (int i = 0; i < yList.size(); i++) { + ChartViewFieldDTO y = yList.get(i); + String originField; + if (ObjectUtils.isNotEmpty(y.getExtField()) && y.getExtField() == 2) { + // 解析origin name中有关联的字段生成sql表达式 + originField = calcFieldRegex(y.getOriginName(), tableObj); + } else if (ObjectUtils.isNotEmpty(y.getExtField()) && y.getExtField() == 1) { + originField = String.format(MySQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), y.getOriginName()); + } else { + originField = String.format(MySQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), y.getOriginName()); + } + String fieldAlias = String.format(SQLConstants.FIELD_ALIAS_Y_PREFIX, i); + // 处理纵轴字段 + yFields.add(getYFields(y, originField, fieldAlias)); + // 处理纵轴过滤 + yWheres.addAll(getYWheres(y, originField, fieldAlias)); + // 处理纵轴排序 + if (StringUtils.isNotEmpty(y.getSort()) && !StringUtils.equalsIgnoreCase(y.getSort(), "none")) { + yOrders.add(SQLObj.builder() + .orderField(originField) + .orderAlias(fieldAlias) + .orderDirection(y.getSort()) + .build()); + } + } + } + // 处理视图中字段过滤 + List customWheres = transCustomFilterList(tableObj, customFilter); + // 处理仪表板字段过滤 + List extWheres = transExtFilterList(tableObj, extFilterRequestList); + // 构建sql所有参数 + List fields = new ArrayList<>(); + fields.addAll(xFields); + fields.addAll(yFields); + List wheres = new ArrayList<>(); + wheres.addAll(xWheres); + if (customWheres != null) wheres.addAll(customWheres); + if (extWheres != null) wheres.addAll(extWheres); + List groups = new ArrayList<>(); + groups.addAll(xFields); + // 外层再次套sql + List orders = new ArrayList<>(); + orders.addAll(xOrders); + orders.addAll(yOrders); + List aggWheres = new ArrayList<>(); + aggWheres.addAll(yWheres); + + STGroup stg = new STGroupFile(SQLConstants.SQL_TEMPLATE); + ST st_sql = stg.getInstanceOf("querySql"); + if (CollectionUtils.isNotEmpty(xFields)) st_sql.add("groups", xFields); + if (CollectionUtils.isNotEmpty(yFields)) st_sql.add("aggregators", yFields); + if (CollectionUtils.isNotEmpty(wheres)) st_sql.add("filters", wheres); + if (ObjectUtils.isNotEmpty(tableObj)) st_sql.add("table", tableObj); + String sql = st_sql.render(); + + ST st = stg.getInstanceOf("querySql"); + SQLObj tableSQL = SQLObj.builder() + .tableName(String.format(MySQLConstants.BRACKETS, sql)) + .tableAlias(String.format(TABLE_ALIAS_PREFIX, 1)) + .build(); + if (CollectionUtils.isNotEmpty(aggWheres)) st.add("filters", aggWheres); + if (CollectionUtils.isNotEmpty(orders)) st.add("orders", orders); + if (ObjectUtils.isNotEmpty(tableSQL)) st.add("table", tableSQL); + return st.render(); + } + + @Override + public String getSQLAsTmpScatter(String table, List xAxis, List yAxis, List customFilter, List extFilterRequestList, List extBubble) { + return getSQLScatter("(" + sqlFix(table) + ")", xAxis, yAxis, customFilter, extFilterRequestList, extBubble); + } + + @Override + public String searchTable(String table) { + return "SELECT table_name FROM information_schema.TABLES WHERE table_name ='" + table + "'"; + } + + @Override + public String getSQLSummary(String table, List yAxis, List customFilter, List extFilterRequestList) { + // 字段汇总 排序等 + SQLObj tableObj = SQLObj.builder() + .tableName((table.startsWith("(") && table.endsWith(")")) ? table : String.format(SqlServerSQLConstants.KEYWORD_TABLE, table)) + .tableAlias(String.format(TABLE_ALIAS_PREFIX, 0)) + .build(); + List yFields = new ArrayList<>(); + List yWheres = new ArrayList<>(); + List yOrders = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(yAxis)) { + for (int i = 0; i < yAxis.size(); i++) { + ChartViewFieldDTO y = yAxis.get(i); + String originField = String.format(SqlServerSQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), y.getOriginName()); + String fieldAlias = String.format(SQLConstants.FIELD_ALIAS_Y_PREFIX, i); + // 处理纵轴字段 + yFields.add(getYFields(y, originField, fieldAlias)); + // 处理纵轴过滤 + yWheres.addAll(getYWheres(y, originField, fieldAlias)); + // 处理纵轴排序 + if (StringUtils.isNotEmpty(y.getSort()) && !StringUtils.equalsIgnoreCase(y.getSort(), "none")) { + yOrders.add(SQLObj.builder() + .orderField(originField) + .orderAlias(fieldAlias) + .orderDirection(y.getSort()) + .build()); + } + } + } + // 处理视图中字段过滤 + List customWheres = transCustomFilterList(tableObj, customFilter); + // 处理仪表板字段过滤 + List extWheres = transExtFilterList(tableObj, extFilterRequestList); + // 构建sql所有参数 + List fields = new ArrayList<>(); + fields.addAll(yFields); + List wheres = new ArrayList<>(); + if (customWheres != null) wheres.addAll(customWheres); + if (extWheres != null) wheres.addAll(extWheres); + List groups = new ArrayList<>(); + // 外层再次套sql + List orders = new ArrayList<>(); + orders.addAll(yOrders); + List aggWheres = new ArrayList<>(); + aggWheres.addAll(yWheres); + + STGroup stg = new STGroupFile(SQLConstants.SQL_TEMPLATE); + ST st_sql = stg.getInstanceOf("querySql"); + if (CollectionUtils.isNotEmpty(yFields)) st_sql.add("aggregators", yFields); + if (CollectionUtils.isNotEmpty(wheres)) st_sql.add("filters", wheres); + if (ObjectUtils.isNotEmpty(tableObj)) st_sql.add("table", tableObj); + String sql = st_sql.render(); + + ST st = stg.getInstanceOf("querySql"); + SQLObj tableSQL = SQLObj.builder() + .tableName(String.format(SqlServerSQLConstants.BRACKETS, sql)) + .tableAlias(String.format(TABLE_ALIAS_PREFIX, 1)) + .build(); + if (CollectionUtils.isNotEmpty(aggWheres)) st.add("filters", aggWheres); + if (CollectionUtils.isNotEmpty(orders)) st.add("orders", orders); + if (ObjectUtils.isNotEmpty(tableSQL)) st.add("table", tableSQL); + return st.render(); + } + + @Override + public String getSQLSummaryAsTmp(String sql, List yAxis, List customFilter, List extFilterRequestList) { + return getSQLSummary("(" + sqlFix(sql) + ")", yAxis, customFilter, extFilterRequestList); + } + + @Override + public String wrapSql(String sql) { + sql = sql.trim(); + if (sql.lastIndexOf(";") == (sql.length() - 1)) { + sql = sql.substring(0, sql.length() - 1); + } + String tmpSql = "SELECT * FROM (" + sql + ") AS tmp " + " LIMIT 0"; + return tmpSql; + } + + @Override + public String createRawQuerySQL(String table, List fields) { + String[] array = fields.stream().map(f -> { + StringBuilder stringBuilder = new StringBuilder(); +// if (f.getDeExtractType() == 4) { // 处理 tinyint +// stringBuilder.append("concat(`").append(f.getOriginName()).append("`,'') AS ").append(f.getDataeaseName()); // } else { -// if (f.getDeType() == 1) { -// stringBuilder.append("FROM_UNIXTIME(CAST(`").append(f.getOriginName()).append("` AS DECIMAL(20,0))/1000,'%Y-%m-%d %H:%i:%S') AS ").append(f.getDataeaseName()); -// } else { -// stringBuilder.append("`").append(f.getOriginName()).append("` AS ").append(f.getDataeaseName()); -// } +// stringBuilder.append("`").append(f.getOriginName()).append("` AS ").append(f.getDataeaseName()); // } -// return stringBuilder.toString(); -// }).toArray(String[]::new); -// return MessageFormat.format("SELECT {0} FROM {1} ORDER BY null", StringUtils.join(array, ","), table); -// } -// -// @Override -// public String createQuerySQLAsTmp(String sql, List fields) { -// return createQuerySQL(" (" + sqlFix(sql) + ") AS tmp ", fields); -// } -// -// @Override -// public String createQuerySQLWithPage(String table, List fields, Integer page, Integer pageSize, Integer realSize) { -// return createQuerySQL(table, fields) + " LIMIT " + (page - 1) * pageSize + "," + realSize; -// } -// -// @Override -// public String createQueryTableWithLimit(String table, List fields, Integer limit) { -// return createQuerySQL(table, fields) + " LIMIT 0," + limit; -// } -// -// @Override -// public String createQuerySqlWithLimit(String sql, List fields, Integer limit) { -// return createQuerySQLAsTmp(sql, fields) + " LIMIT 0," + limit; -// } -// -// @Override -// public String createQuerySQLAsTmpWithPage(String sql, List fields, Integer page, Integer pageSize, Integer realSize) { -// return createQuerySQLAsTmp(sql, fields) + " LIMIT " + (page - 1) * pageSize + "," + realSize; -// } -// -// @Override -// public String getSQL(String table, List xAxis, List yAxis, List customFilter, List extFilterRequestList) { -// // 字段汇总 排序等 -// String[] field = yAxis.stream().map(y -> { -// StringBuilder f = new StringBuilder(); -// if (StringUtils.equalsIgnoreCase(y.getOriginName(), "*")) { -// f.append(y.getSummary()).append("(").append(y.getOriginName()).append(")"); -// } else { -// if (StringUtils.equalsIgnoreCase(y.getSummary(), "avg") || StringUtils.containsIgnoreCase(y.getSummary(), "pop")) { -// f.append("CAST(") -// .append(y.getSummary()).append("(") -// .append("CAST(`").append(y.getOriginName()).append("` AS ").append(y.getDeType() == 2 ? "DECIMAL(20,0)" : "DECIMAL(20,2)").append(")") -// .append(") AS DECIMAL(20,2)").append(")"); -// } else { -// f.append(y.getSummary()).append("(") -// .append("CAST(`").append(y.getOriginName()).append("` AS ").append(y.getDeType() == 2 ? "DECIMAL(20,0)" : "DECIMAL(20,2)").append(")") -// .append(")"); -// } -// } -// f.append(" AS `_").append(y.getSummary()).append("_").append(StringUtils.equalsIgnoreCase(y.getOriginName(), "*") ? "" : y.getOriginName()).append("`"); -// return f.toString(); -// }).toArray(String[]::new); -// String[] groupField = xAxis.stream().map(x -> { -// StringBuilder stringBuilder = new StringBuilder(); -// // 如果原始类型为时间 -// if (x.getDeExtractType() == 1) { -// if (x.getDeType() == 2 || x.getDeType() == 3) { -// stringBuilder.append("UNIX_TIMESTAMP(`").append(x.getOriginName()).append("`)*1000 AS `_").append(x.getOriginName()).append("`"); -// } else if (x.getDeType() == 1) { -// String format = transDateFormat(x.getDateStyle(), x.getDatePattern()); -// stringBuilder.append("DATE_FORMAT(`").append(x.getOriginName()).append("`,'").append(format).append("') AS `_").append(x.getOriginName()).append("`"); -// } else { -// stringBuilder.append("`").append(x.getOriginName()).append("` AS `_").append(x.getOriginName()).append("`"); -// } -// } else { -// if (x.getDeType() == 1) { -// String format = transDateFormat(x.getDateStyle(), x.getDatePattern()); -// if (x.getDeExtractType() == 0) { -// stringBuilder.append("DATE_FORMAT(`").append(x.getOriginName()).append("`,'").append(format).append("') AS `_").append(x.getOriginName()).append("`"); -// } else { -// stringBuilder.append("DATE_FORMAT(").append("FROM_UNIXTIME(CAST(`").append(x.getOriginName()).append("` AS DECIMAL(20,0))/1000,'%Y-%m-%d %H:%i:%S')").append(",'").append(format).append("') AS `_").append(x.getOriginName()).append("`"); -// } -// } else { -// stringBuilder.append("`").append(x.getOriginName()).append("` AS `_").append(x.getOriginName()).append("`"); -// } -// } -// return stringBuilder.toString(); -// }).toArray(String[]::new); -// String[] group = xAxis.stream().map(x -> "`_" + x.getOriginName() + "`").toArray(String[]::new); -// String[] xOrder = xAxis.stream().filter(f -> StringUtils.isNotEmpty(f.getSort()) && !StringUtils.equalsIgnoreCase(f.getSort(), "none")) -// .map(f -> "`_" + f.getOriginName() + "` " + f.getSort()).toArray(String[]::new); -// String[] yOrder = yAxis.stream().filter(f -> StringUtils.isNotEmpty(f.getSort()) && !StringUtils.equalsIgnoreCase(f.getSort(), "none")) -// .map(f -> "`_" + f.getSummary() + "_" + (StringUtils.equalsIgnoreCase(f.getOriginName(), "*") ? "" : f.getOriginName()) + "` " + f.getSort()).toArray(String[]::new); -// String[] order = Arrays.copyOf(xOrder, xOrder.length + yOrder.length); -// System.arraycopy(yOrder, 0, order, xOrder.length, yOrder.length); -// -// String[] xFilter = xAxis.stream().filter(x -> CollectionUtils.isNotEmpty(x.getFilter()) && x.getFilter().size() > 0) -// .map(x -> { -// String[] s = x.getFilter().stream().map(f -> { -// StringBuilder filter = new StringBuilder(); -// if (x.getDeType() == 1 && x.getDeExtractType() != 1) { -// filter.append(" AND FROM_UNIXTIME(cast(`") -// .append(x.getOriginName()) -// .append("` AS DECIMAL(20,0))/1000,'%Y-%m-%d %H:%i:%S') "); -// } else { -// filter.append(" AND `").append(x.getOriginName()).append("`"); -// } -// filter.append(transMysqlFilterTerm(f.getTerm())); -// if (StringUtils.equalsIgnoreCase(f.getTerm(), "null")) { -// filter.append("(null,'')"); -// } else if (StringUtils.equalsIgnoreCase(f.getTerm(), "not_null")) { -// filter.append(" AND `").append(x.getOriginName()).append("`").append(" <> ''"); -// } else if (StringUtils.containsIgnoreCase(f.getTerm(), "in")) { -// filter.append("('").append(StringUtils.join(f.getValue(), "','")).append("')"); -// } else if (StringUtils.containsIgnoreCase(f.getTerm(), "like")) { -// filter.append("%").append(f.getValue()).append("%"); -// } else { -// filter.append("'").append(f.getValue()).append("'"); -// } -// return filter.toString(); -// }).toArray(String[]::new); -// return StringUtils.join(s, " "); -// }).toArray(String[]::new); -// -// String sql = MessageFormat.format("SELECT {0},{1} FROM {2} WHERE 1=1 {3} GROUP BY {4} ORDER BY null,{5}", -// StringUtils.join(groupField, ","), -// StringUtils.join(field, ","), -// table, -// (xFilter.length > 0 ? StringUtils.join(xFilter, " ") : "") + transCustomFilter(customFilter) + transExtFilter(extFilterRequestList),// origin field filter and panel field filter -// StringUtils.join(group, ","), -// StringUtils.join(order, ",")); -// if (sql.endsWith(",")) { -// sql = sql.substring(0, sql.length() - 1); -// } -// // 如果是对结果字段过滤，则再包裹一层sql -// String[] resultFilter = yAxis.stream().filter(y -> CollectionUtils.isNotEmpty(y.getFilter()) && y.getFilter().size() > 0) -// .map(y -> { -// String[] s = y.getFilter().stream().map(f -> { -// StringBuilder filter = new StringBuilder(); -// // 原始类型不是时间，在de中被转成时间的字段做处理 -// if (y.getDeType() == 1 && y.getDeExtractType() != 1) { -// filter.append(" AND FROM_UNIXTIME(CAST(`_") -// .append(y.getSummary()).append("_").append(StringUtils.equalsIgnoreCase(y.getOriginName(), "*") ? "" : y.getOriginName()).append("`") -// .append(" AS DECIMAL(20,0))/1000,'%Y-%m-%d %H:%i:%S') "); -// } else { -// filter.append(" AND `_").append(y.getSummary()).append("_").append(StringUtils.equalsIgnoreCase(y.getOriginName(), "*") ? "" : y.getOriginName()).append("`"); -// } -// filter.append(transMysqlFilterTerm(f.getTerm())); -// if (StringUtils.equalsIgnoreCase(f.getTerm(), "null")) { -// filter.append("(null,'')"); -// } else if (StringUtils.equalsIgnoreCase(f.getTerm(), "not_null")) { -// filter.append(" AND `_") -// .append(y.getSummary()).append("_").append(StringUtils.equalsIgnoreCase(y.getOriginName(), "*") ? "" : y.getOriginName()) -// .append("`").append(" <> ''"); -// } else if (StringUtils.containsIgnoreCase(f.getTerm(), "in")) { -// filter.append("('").append(StringUtils.join(f.getValue(), "','")).append("')"); -// } else if (StringUtils.containsIgnoreCase(f.getTerm(), "like")) { -// filter.append("%").append(f.getValue()).append("%"); -// } else { -// filter.append("'").append(f.getValue()).append("'"); -// } -// return filter.toString(); -// }).toArray(String[]::new); -// return StringUtils.join(s, " "); -// }).toArray(String[]::new); -// if (resultFilter.length == 0) { -// return sql; -// } else { -// String filterSql = MessageFormat.format("SELECT * FROM {0} WHERE 1=1 {1} ORDER BY {2}", -// "(" + sql + ") AS tmp", -// StringUtils.join(resultFilter, " "), -// ObjectUtils.isNotEmpty(yOrder) ? StringUtils.join(yOrder, ",") : "null"); -// return filterSql; -// } -// } -// -// @Override -// public String getSQLAsTmp(String sql, List xAxis, List yAxis, List customFilter, List extFilterRequestList) { -// return getSQL(" (" + sqlFix(sql) + ") AS tmp ", xAxis, yAxis, customFilter, extFilterRequestList); -// } -// -// @Override -// public String getSQLStack(String table, List xAxis, List yAxis, List customFilter, List extFilterRequestList, List extStack) { -// return null; -// } -// -// @Override -// public String getSQLAsTmpStack(String table, List xAxis, List yAxis, List customFilter, List extFilterRequestList, List extStack) { -// return null; -// } -// -// @Override -// public String searchTable(String table) { -// return "SELECT table_name FROM information_schema.TABLES WHERE table_name ='" + table + "'"; -// } -// -// @Override -// public String getSQLSummary(String table, List yAxis, List customFilter, List extFilterRequestList) { -// // 字段汇总 排序等 -// String[] field = yAxis.stream().map(y -> { -// StringBuilder f = new StringBuilder(); -// if (StringUtils.equalsIgnoreCase(y.getOriginName(), "*")) { -// f.append(y.getSummary()).append("(").append(y.getOriginName()).append(")"); -// } else { -// if (StringUtils.equalsIgnoreCase(y.getSummary(), "avg") || StringUtils.containsIgnoreCase(y.getSummary(), "pop")) { -// f.append("CAST(") -// .append(y.getSummary()).append("(") -// .append("CAST(`").append(y.getOriginName()).append("` AS ").append(y.getDeType() == 2 ? "DECIMAL(20,0)" : "DECIMAL(20,2)").append(")") -// .append(") AS DECIMAL(20,2)").append(")"); -// } else { -// f.append(y.getSummary()).append("(") -// .append("CAST(`").append(y.getOriginName()).append("` AS ").append(y.getDeType() == 2 ? "DECIMAL(20,0)" : "DECIMAL(20,2)").append(")") -// .append(")"); -// } -// } -// f.append(" AS `_").append(y.getSummary()).append("_").append(StringUtils.equalsIgnoreCase(y.getOriginName(), "*") ? "" : y.getOriginName()).append("`"); -// return f.toString(); -// }).toArray(String[]::new); -// -// String[] order = yAxis.stream().filter(f -> StringUtils.isNotEmpty(f.getSort()) && !StringUtils.equalsIgnoreCase(f.getSort(), "none")) -// .map(f -> "`_" + f.getSummary() + "_" + (StringUtils.equalsIgnoreCase(f.getOriginName(), "*") ? "" : f.getOriginName()) + "` " + f.getSort()).toArray(String[]::new); -// -// String sql = MessageFormat.format("SELECT {0} FROM {1} WHERE 1=1 {2} ORDER BY null,{3}", -// StringUtils.join(field, ","), -// table, -// transCustomFilter(customFilter) + transExtFilter(extFilterRequestList),// origin field filter and panel field filter -// StringUtils.join(order, ",")); -// if (sql.endsWith(",")) { -// sql = sql.substring(0, sql.length() - 1); -// } -// // 如果是对结果字段过滤，则再包裹一层sql -// String[] resultFilter = yAxis.stream().filter(y -> CollectionUtils.isNotEmpty(y.getFilter()) && y.getFilter().size() > 0) -// .map(y -> { -// String[] s = y.getFilter().stream().map(f -> { -// StringBuilder filter = new StringBuilder(); -// // 原始类型不是时间，在de中被转成时间的字段做处理 -// if (y.getDeType() == 1 && y.getDeExtractType() != 1) { -// filter.append(" AND FROM_UNIXTIME(CAST(`_") -// .append(y.getSummary()).append("_").append(StringUtils.equalsIgnoreCase(y.getOriginName(), "*") ? "" : y.getOriginName()).append("`") -// .append(" AS DECIMAL(20,0))/1000,'%Y-%m-%d %H:%i:%S') "); -// } else { -// filter.append(" AND `_").append(y.getSummary()).append("_").append(StringUtils.equalsIgnoreCase(y.getOriginName(), "*") ? "" : y.getOriginName()).append("`"); -// } -// filter.append(transMysqlFilterTerm(f.getTerm())); -// if (StringUtils.equalsIgnoreCase(f.getTerm(), "null")) { -// filter.append("(null,'')"); -// } else if (StringUtils.equalsIgnoreCase(f.getTerm(), "not_null")) { -// filter.append(" AND `_") -// .append(y.getSummary()).append("_").append(StringUtils.equalsIgnoreCase(y.getOriginName(), "*") ? "" : y.getOriginName()) -// .append("`").append(" <> ''"); -// } else if (StringUtils.containsIgnoreCase(f.getTerm(), "in")) { -// filter.append("('").append(StringUtils.join(f.getValue(), "','")).append("')"); -// } else if (StringUtils.containsIgnoreCase(f.getTerm(), "like")) { -// filter.append("%").append(f.getValue()).append("%"); -// } else { -// filter.append("'").append(f.getValue()).append("'"); -// } -// return filter.toString(); -// }).toArray(String[]::new); -// return StringUtils.join(s, " "); -// }).toArray(String[]::new); -// if (resultFilter.length == 0) { -// return sql; -// } else { -// String filterSql = MessageFormat.format("SELECT * FROM {0} WHERE 1=1 {1} ORDER BY {2}", -// "(" + sql + ") AS tmp", -// StringUtils.join(resultFilter, " "), -// ObjectUtils.isNotEmpty(order) ? StringUtils.join(order, ",") : "null"); -// return filterSql; -// } -// } -// -// @Override -// public String getSQLSummaryAsTmp(String sql, List yAxis, List customFilter, List extFilterRequestList) { -// return getSQLSummary(" (" + sqlFix(sql) + ") AS tmp ", yAxis, customFilter, extFilterRequestList); -// } -// -// @Override -// public String wrapSql(String sql) { -// sql = sql.trim(); -// if (sql.lastIndexOf(";") == (sql.length() - 1)) { -// sql = sql.substring(0, sql.length() - 1); -// } -// String tmpSql = "SELECT * FROM (" + sql + ") AS tmp " + " LIMIT 0"; -// return tmpSql; -// } -// -// @Override -// public String createRawQuerySQL(String table, List fields) { -// String[] array = fields.stream().map(f -> { -// StringBuilder stringBuilder = new StringBuilder(); -// stringBuilder.append("`").append(f.getOriginName()).append("` AS ").append(f.getDataeaseName()); -// return stringBuilder.toString(); -// }).toArray(String[]::new); -// return MessageFormat.format("SELECT {0} FROM {1} ORDER BY null", StringUtils.join(array, ","), table); -// } -// -// @Override -// public String createRawQuerySQLAsTmp(String sql, List fields) { -// return createRawQuerySQL(" (" + sqlFix(sql) + ") AS tmp ", fields); -// } -// -// public String transMysqlFilterTerm(String term) { -// switch (term) { -// case "eq": -// return " = "; -// case "not_eq": -// return " <> "; -// case "lt": -// return " < "; -// case "le": -// return " <= "; -// case "gt": -// return " > "; -// case "ge": -// return " >= "; -// case "in": -// return " IN "; -// case "not in": -// return " NOT IN "; -// case "like": -// return " LIKE "; -// case "not like": -// return " NOT LIKE "; -// case "null": -// return " IN "; -// case "not_null": -// return " IS NOT NULL "; -// case "between": -// return " BETWEEN "; -// default: -// return ""; -// } -// } -// -// public String transCustomFilter(List requestList) { -// if (CollectionUtils.isEmpty(requestList)) { -// return ""; -// } -// StringBuilder filter = new StringBuilder(); -// for (ChartCustomFilterDTO request : requestList) { -// String value = request.getValue(); -// DatasetTableField field = request.getField(); -// if (ObjectUtils.isEmpty(field)) { -// continue; -// } -// if (field.getDeType() == 1 && field.getDeExtractType() != 1) { -// filter.append(" AND FROM_UNIXTIME(CAST(`") -// .append(field.getOriginName()) -// .append("` AS DECIMAL(20,0))/1000,'%Y-%m-%d %H:%i:%S') "); -// } else { -// filter.append(" AND `").append(field.getOriginName()).append("`"); -// } -// filter.append(" ") -// .append(transMysqlFilterTerm(request.getTerm())) -// .append(" "); -// if (StringUtils.equalsIgnoreCase(request.getTerm(), "null")) { -// filter.append("(null,'')"); -// } else if (StringUtils.equalsIgnoreCase(request.getTerm(), "not_null")) { -// filter.append(" AND `").append(field.getOriginName()).append("`").append(" <> ''"); -// } else if (StringUtils.containsIgnoreCase(request.getTerm(), "in")) { -// filter.append("('").append(StringUtils.join(value, "','")).append("')"); -// } else if (StringUtils.containsIgnoreCase(request.getTerm(), "like")) { -// filter.append("'%").append(value).append("%'"); -// } else { -// filter.append("'").append(value).append("'"); -// } -// } -// return filter.toString(); -// } -// -// public String transExtFilter(List requestList) { -// if (CollectionUtils.isEmpty(requestList)) { -// return ""; -// } -// StringBuilder filter = new StringBuilder(); -// for (ChartExtFilterRequest request : requestList) { -// List value = request.getValue(); -// if (CollectionUtils.isEmpty(value)) { -// continue; -// } -// DatasetTableField field = request.getDatasetTableField(); -// if (field.getDeType() == 1 && field.getDeExtractType() != 1) { -// filter.append(" AND FROM_UNIXTIME(CAST(`") -// .append(field.getOriginName()) -// .append("` AS DECIMAL(20,0))/1000,'%Y-%m-%d %H:%i:%S') "); -// } else { -// filter.append(" AND `").append(field.getOriginName()).append("`"); -// } -// filter.append(" ") -// .append(transMysqlFilterTerm(request.getOperator())) -// .append(" "); -// if (StringUtils.containsIgnoreCase(request.getOperator(), "in")) { -// filter.append("('").append(StringUtils.join(value, "','")).append("')"); -// } else if (StringUtils.containsIgnoreCase(request.getOperator(), "like")) { -// filter.append("'%").append(value.get(0)).append("%'"); -// } else if (StringUtils.containsIgnoreCase(request.getOperator(), "between")) { -// SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); -// String startTime = simpleDateFormat.format(new Date(Long.parseLong(value.get(0)))); -// String endTime = simpleDateFormat.format(new Date(Long.parseLong(value.get(1)))); -// filter.append("'").append(startTime).append("' AND '").append(endTime).append("'"); -// } else { -// filter.append("'").append(value.get(0)).append("'"); -// } -// } -// return filter.toString(); -// } -// -// private String sqlFix(String sql) { -// if (sql.lastIndexOf(";") == (sql.length() - 1)) { -// sql = sql.substring(0, sql.length() - 1); -// } -// return sql; -// } -// -// private String transDateFormat(String dateStyle, String datePattern) { -// String split = "-"; -// if (StringUtils.equalsIgnoreCase(datePattern, "date_sub")) { -// split = "-"; -// } else if (StringUtils.equalsIgnoreCase(datePattern, "date_split")) { -// split = "/"; -// } -// -// switch (dateStyle) { -// case "y": -// return "%Y"; -// case "y_M": -// return "%Y" + split + "%m"; -// case "y_M_d": -// return "%Y" + split + "%m" + split + "%d"; -// case "H_m_s": -// return "%H:%i:%S"; -// case "y_M_d_H_m": -// return "%Y" + split + "%m" + split + "%d" + " %H:%i"; -// case "y_M_d_H_m_s": -// return "%Y" + split + "%m" + split + "%d" + " %H:%i:%S"; -// default: -// return "%Y-%m-%d %H:%i:%S"; -// } -// } -//} + stringBuilder.append("\"").append(f.getOriginName()).append("\" AS ").append(f.getDataeaseName()); + return stringBuilder.toString(); + }).toArray(String[]::new); + return MessageFormat.format("SELECT {0} FROM {1}", StringUtils.join(array, ","), table); + } + + @Override + public String createRawQuerySQLAsTmp(String sql, List fields) { + return createRawQuerySQL(" (" + sqlFix(sql) + ") AS tmp ", fields); + } + + public String transMysqlFilterTerm(String term) { + switch (term) { + case "eq": + return " = "; + case "not_eq": + return " <> "; + case "lt": + return " < "; + case "le": + return " <= "; + case "gt": + return " > "; + case "ge": + return " >= "; + case "in": + return " IN "; + case "not in": + return " NOT IN "; + case "like": + return " LIKE "; + case "not like": + return " NOT LIKE "; + case "null": + return " IN "; + case "not_null": + return " IS NOT NULL AND %s <> ''"; + case "between": + return " BETWEEN "; + default: + return ""; + } + } + + + public List transCustomFilterList(SQLObj tableObj, List requestList) { + if (CollectionUtils.isEmpty(requestList)) { + return null; + } + List list = new ArrayList<>(); + for (ChartCustomFilterDTO request : requestList) { + DatasetTableField field = request.getField(); + if (ObjectUtils.isEmpty(field)) { + continue; + } + String value = request.getValue(); + String whereName = ""; + String whereTerm = transMysqlFilterTerm(request.getTerm()); + String whereValue = ""; + String originName = String.format(SqlServerSQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), field.getOriginName()); + if (field.getDeType() == DeTypeConstants.DE_TIME && field.getDeExtractType() != DeTypeConstants.DE_TIME) { + String cast = String.format(SqlServerSQLConstants.LONG_TO_DATE, originName + "/1000"); + whereName = String.format(SqlServerSQLConstants.FROM_UNIXTIME, cast); + } else { + whereName = originName; + } + if (StringUtils.equalsIgnoreCase(request.getTerm(), "null")) { + whereValue = SqlServerSQLConstants.WHERE_VALUE_NULL; + } else if (StringUtils.equalsIgnoreCase(request.getTerm(), "not_null")) { + whereTerm = String.format(whereTerm, originName); + } else if (StringUtils.containsIgnoreCase(request.getTerm(), "in")) { + whereValue = "('" + StringUtils.join(value, "','") + "')"; + } else if (StringUtils.containsIgnoreCase(request.getTerm(), "like")) { + whereValue = "'%" + value + "%'"; + } else { + whereValue = String.format(SqlServerSQLConstants.WHERE_VALUE_VALUE, value); + } + list.add(SQLObj.builder() + .whereField(whereName) + .whereTermAndValue(whereTerm + whereValue) + .build()); + } + return list; + } + + public List transExtFilterList(SQLObj tableObj, List requestList) { + if (CollectionUtils.isEmpty(requestList)) { + return null; + } + List list = new ArrayList<>(); + for (ChartExtFilterRequest request : requestList) { + List value = request.getValue(); + DatasetTableField field = request.getDatasetTableField(); + if (CollectionUtils.isEmpty(value) || ObjectUtils.isEmpty(field)) { + continue; + } + String whereName = ""; + String whereTerm = transMysqlFilterTerm(request.getOperator()); + String whereValue = ""; + String originName = String.format(SqlServerSQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), field.getOriginName()); + + if (field.getDeType() == 1 && field.getDeExtractType() != 1) { + String cast = String.format(SqlServerSQLConstants.LONG_TO_DATE, originName + "/1000"); + whereName = String.format(SqlServerSQLConstants.FROM_UNIXTIME, cast); + } else { + whereName = originName; + } + + + if (StringUtils.containsIgnoreCase(request.getOperator(), "in")) { + whereValue = "('" + StringUtils.join(value, "','") + "')"; + } else if (StringUtils.containsIgnoreCase(request.getOperator(), "like")) { + whereValue = "'%" + value.get(0) + "%'"; + } else if (StringUtils.containsIgnoreCase(request.getOperator(), "between")) { + if (request.getDatasetTableField().getDeType() == DeTypeConstants.DE_TIME) { + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + String startTime = simpleDateFormat.format(new Date(Long.parseLong(value.get(0)))); + String endTime = simpleDateFormat.format(new Date(Long.parseLong(value.get(1)))); + whereValue = String.format(SqlServerSQLConstants.WHERE_BETWEEN, startTime, endTime); + } else { + whereValue = String.format(SqlServerSQLConstants.WHERE_BETWEEN, value.get(0), value.get(1)); + } + } else { + whereValue = String.format(SqlServerSQLConstants.WHERE_VALUE_VALUE, value.get(0)); + } + list.add(SQLObj.builder() + .whereField(whereName) + .whereTermAndValue(whereTerm + whereValue) + .build()); + } + return list; + } + + private String sqlFix(String sql) { + if (sql.lastIndexOf(";") == (sql.length() - 1)) { + sql = sql.substring(0, sql.length() - 1); + } + return sql; + } + + //日期格式化 + private String transDateFormat(String dateStyle, String datePattern, String originField) { + String split = "-"; + if (StringUtils.equalsIgnoreCase(datePattern, "date_sub")) { + split = "-"; + } else if (StringUtils.equalsIgnoreCase(datePattern, "date_split")) { + split = "/"; + } + + switch (dateStyle) { + case "y": + return "CONVERT(varchar(100), datepart(yy, " + originField + "))"; + case "y_M": + if(split.equalsIgnoreCase("-")){ + return "substring( convert(varchar," + originField + ",120),1,7)"; + }else { + return "replace("+ "substring( convert(varchar," + originField + ",120),1,7), '-','/')"; + } + case "y_M_d": + if(split.equalsIgnoreCase("-")){ + return "CONVERT(varchar(100), " + originField + ", 23)"; + }else { + return "CONVERT(varchar(100), " + originField + ", 111)"; + } + case "H_m_s": + return "CONVERT(varchar(100), " + originField + ", 8)"; + case "y_M_d_H_m": + if(split.equalsIgnoreCase("-")){ + return "substring( convert(varchar," + originField + ",120),1,16)"; + }else { + return "replace("+ "substring( convert(varchar," + originField + ",120),1,16), '-','/')"; + } + case "y_M_d_H_m_s": + if(split.equalsIgnoreCase("-")){ + return "convert(varchar," + originField + ",120)"; + }else { + return "replace("+ "convert(varchar," + originField + ",120), '-','/')"; + } + default: + return "convert(varchar," + originField + ",120)"; + } + } + + private String transStringToDateFormat(String dateStyle, String datePattern, String originField) { + String split = "-"; + if (StringUtils.equalsIgnoreCase(datePattern, "date_sub")) { + split = "-"; + } else if (StringUtils.equalsIgnoreCase(datePattern, "date_split")) { + split = "/"; + } + switch (dateStyle) { + case "y": + return "CONVERT(varchar(100), datepart(yy, " + "SELECT CONVERT(datetime, " + originField + " ,120)" + "))"; + case "y_M": + if(split.equalsIgnoreCase("-")){ + return "substring( convert(varchar," + "SELECT CONVERT(datetime, " + originField + " ,120)" + ",120),1,7)"; + }else { + return "replace("+ "substring( convert(varchar," + "SELECT CONVERT(datetime, " + originField + " ,120)" + ",120),1,7), '-','/')"; + } + case "y_M_d": + if(split.equalsIgnoreCase("-")){ + return "CONVERT(varchar(100), " + "SELECT CONVERT(datetime, " + originField + " ,120)" + ", 23)"; + }else { + return "CONVERT(varchar(100), " + "SELECT CONVERT(datetime, " + originField + " ,120)" + ", 111)"; + } + case "H_m_s": + return "CONVERT(varchar(100), " + "SELECT CONVERT(datetime, " + originField + " ,120)" + ", 24)"; + case "y_M_d_H_m": + if(split.equalsIgnoreCase("-")){ + return "substring( convert(varchar," + "SELECT CONVERT(datetime, " + originField + " ,120)" + ",120),1,16)"; + }else { + return "replace("+ "substring( convert(varchar," + "SELECT CONVERT(datetime, " + originField + " ,120)" + ",120),1,16), '-','/')"; + } + case "y_M_d_H_m_s": + if(split.equalsIgnoreCase("-")){ + return "convert(varchar," + "SELECT CONVERT(datetime, " + originField + " ,120)" + ",120)"; + }else { + return "replace("+ "convert(varchar," + "SELECT CONVERT(datetime, " + originField + " ,120)" + ",120), '-','/')"; + } + default: + return "convert(varchar," + "SELECT CONVERT(datetime, " + originField + " ,120)" + ",120)"; + } + } + + private SQLObj getXFields(ChartViewFieldDTO x, String originField, String fieldAlias) { + String fieldName = ""; + if (x.getDeExtractType() == DeTypeConstants.DE_TIME) { + if (x.getDeType() == DeTypeConstants.DE_INT || x.getDeType() == DeTypeConstants.DE_FLOAT) { //时间转数值 + fieldName = String.format(SqlServerSQLConstants.UNIX_TIMESTAMP, originField); + } else if (x.getDeType() == DeTypeConstants.DE_TIME) { //时间格式化 + fieldName = transDateFormat(x.getDateStyle(), x.getDatePattern(), originField); + } else { + fieldName = originField; + } + } else { + if (x.getDeType() == DeTypeConstants.DE_TIME) { + if (x.getDeExtractType() == DeTypeConstants.DE_STRING) {// 字符串转时间 + String cast = String.format(SqlServerSQLConstants.STRING_TO_DATE, originField); + fieldName = transDateFormat(x.getDateStyle(), x.getDatePattern(), cast); + } else {// 数值转时间 + String cast = String.format(SqlServerSQLConstants.LONG_TO_DATE, originField+ "/1000"); + fieldName = transDateFormat(x.getDateStyle(), x.getDatePattern(), cast); + } + } else { + fieldName = originField; + } + } + return SQLObj.builder() + .fieldName(fieldName) + .fieldAlias(fieldAlias) + .build(); + } + + private SQLObj getYFields(ChartViewFieldDTO y, String originField, String fieldAlias) { + String fieldName = ""; + if (StringUtils.equalsIgnoreCase(y.getOriginName(), "*")) { + fieldName = SqlServerSQLConstants.AGG_COUNT; + } else if (SQLConstants.DIMENSION_TYPE.contains(y.getDeType())) { + fieldName = String.format(SqlServerSQLConstants.AGG_FIELD, y.getSummary(), originField); + } else { + if (StringUtils.equalsIgnoreCase(y.getSummary(), "avg") || StringUtils.containsIgnoreCase(y.getSummary(), "pop")) { + String convert = String.format(SqlServerSQLConstants.CONVERT, y.getDeType() == DeTypeConstants.DE_INT ? SqlServerSQLConstants.DEFAULT_INT_FORMAT : SqlServerSQLConstants.DEFAULT_FLOAT_FORMAT, originField); + String agg = String.format(SqlServerSQLConstants.AGG_FIELD, y.getSummary(), convert); + fieldName = String.format(SqlServerSQLConstants.CONVERT, SqlServerSQLConstants.DEFAULT_FLOAT_FORMAT, agg); + } else { + String convert = String.format(SqlServerSQLConstants.CONVERT, y.getDeType() == 2 ? SqlServerSQLConstants.DEFAULT_INT_FORMAT : SqlServerSQLConstants.DEFAULT_FLOAT_FORMAT, originField); + fieldName = String.format(SqlServerSQLConstants.AGG_FIELD, y.getSummary(), convert); + } + } + return SQLObj.builder() + .fieldName(fieldName) + .fieldAlias(fieldAlias) + .build(); + } + + private List getYWheres(ChartViewFieldDTO y, String originField, String fieldAlias) { + List list = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(y.getFilter()) && y.getFilter().size() > 0) { + y.getFilter().forEach(f -> { + String whereTerm = transMysqlFilterTerm(f.getTerm()); + String whereValue = ""; + // 原始类型不是时间，在de中被转成时间的字段做处理 + if (StringUtils.equalsIgnoreCase(f.getTerm(), "null")) { + whereValue = SqlServerSQLConstants.WHERE_VALUE_NULL; + } else if (StringUtils.equalsIgnoreCase(f.getTerm(), "not_null")) { + whereTerm = String.format(whereTerm, originField); + } else if (StringUtils.containsIgnoreCase(f.getTerm(), "in")) { + whereValue = "('" + StringUtils.join(f.getValue(), "','") + "')"; + } else if (StringUtils.containsIgnoreCase(f.getTerm(), "like")) { + whereValue = "'%" + f.getValue() + "%'"; + } else { + whereValue = String.format(SqlServerSQLConstants.WHERE_VALUE_VALUE, f.getValue()); + } + list.add(SQLObj.builder() + .whereField(fieldAlias) + .whereAlias(fieldAlias) + .whereTermAndValue(whereTerm + whereValue) + .build()); + }); + } + return list; + } + + private String calcFieldRegex(String originField, SQLObj tableObj) { + originField = originField.replaceAll("[\\t\\n\\r]]", ""); + // 正则提取[xxx] + String regex = "\\[(.*?)]"; + Pattern pattern = Pattern.compile(regex); + Matcher matcher = pattern.matcher(originField); + Set ids = new HashSet<>(); + while (matcher.find()) { + String id = matcher.group(1); + ids.add(id); + } + if (CollectionUtils.isEmpty(ids)) { + return originField; + } + DatasetTableFieldExample datasetTableFieldExample = new DatasetTableFieldExample(); + datasetTableFieldExample.createCriteria().andIdIn(new ArrayList<>(ids)); + List calcFields = datasetTableFieldMapper.selectByExample(datasetTableFieldExample); + for (DatasetTableField ele : calcFields) { + originField = originField.replaceAll("\\[" + ele.getId() + "]", + String.format(MySQLConstants.KEYWORD_FIX, tableObj.getTableAlias(), ele.getOriginName())); + } + return originField; + } +} diff --git a/backend/src/main/java/io/dataease/service/chart/ChartViewService.java b/backend/src/main/java/io/dataease/service/chart/ChartViewService.java index 89c08d91e7..68fa644ab0 100644 --- a/backend/src/main/java/io/dataease/service/chart/ChartViewService.java +++ b/backend/src/main/java/io/dataease/service/chart/ChartViewService.java @@ -365,6 +365,11 @@ public class ChartViewService { mapChart = transStackChartData(xAxis, yAxis, view, data, extStack); } else if (StringUtils.containsIgnoreCase(view.getType(), "scatter")) { mapChart = transScatterData(xAxis, yAxis, view, data, extBubble); + } else if (StringUtils.containsIgnoreCase(view.getType(), "radar")) { + mapChart = transRadarChartData(xAxis, yAxis, view, data); + } else if (StringUtils.containsIgnoreCase(view.getType(), "text") + || StringUtils.containsIgnoreCase(view.getType(), "gauge")) { + mapChart = transNormalChartData(xAxis, yAxis, view, data); } else { mapChart = transChartData(xAxis, yAxis, view, data); } @@ -421,6 +426,101 @@ public class ChartViewService { private Map transChartData(List xAxis, List yAxis, ChartViewWithBLOBs view, List data) { Map map = new HashMap<>(); + List x = new ArrayList<>(); + List series = new ArrayList<>(); + for (ChartViewFieldDTO y : yAxis) { + Series series1 = new Series(); + series1.setName(y.getName()); + series1.setType(view.getType()); + series1.setData(new ArrayList<>()); + series.add(series1); + } + for (int i1 = 0; i1 < data.size(); i1++) { + String[] d = data.get(i1); + + StringBuilder a = new StringBuilder(); + for (int i = xAxis.size(); i < xAxis.size() + yAxis.size(); i++) { + List dimensionList = new ArrayList<>(); + List quotaList = new ArrayList<>(); + AxisChartDataDTO axisChartDataDTO = new AxisChartDataDTO(); + + for (int j = 0; j < xAxis.size(); j++) { + ChartDimensionDTO chartDimensionDTO = new ChartDimensionDTO(); + chartDimensionDTO.setId(xAxis.get(j).getId()); + chartDimensionDTO.setValue(d[j]); + dimensionList.add(chartDimensionDTO); + } + axisChartDataDTO.setDimensionList(dimensionList); + + int j = i - xAxis.size(); + ChartQuotaDTO chartQuotaDTO = new ChartQuotaDTO(); + chartQuotaDTO.setId(yAxis.get(j).getId()); + quotaList.add(chartQuotaDTO); + axisChartDataDTO.setQuotaList(quotaList); + try { + axisChartDataDTO.setValue(new BigDecimal(StringUtils.isEmpty(d[i]) ? "0" : d[i])); + } catch (Exception e) { + axisChartDataDTO.setValue(new BigDecimal(0)); + } + series.get(j).getData().add(axisChartDataDTO); + } + for (int i = 0; i < xAxis.size(); i++) { + if (i == xAxis.size() - 1) { + a.append(d[i]); + } else { + a.append(d[i]).append("\n"); + } + } + x.add(a.toString()); + } + + map.put("x", x); + map.put("series", series); + return map; + } + + // 常规图形 + private Map transNormalChartData(List xAxis, List yAxis, ChartViewWithBLOBs view, List data) { + Map map = new HashMap<>(); + + List x = new ArrayList<>(); + List series = new ArrayList<>(); + for (ChartViewFieldDTO y : yAxis) { + Series series1 = new Series(); + series1.setName(y.getName()); + series1.setType(view.getType()); + series1.setData(new ArrayList<>()); + series.add(series1); + } + for (String[] d : data) { + StringBuilder a = new StringBuilder(); + for (int i = 0; i < xAxis.size(); i++) { + if (i == xAxis.size() - 1) { + a.append(d[i]); + } else { + a.append(d[i]).append("\n"); + } + } + x.add(a.toString()); + for (int i = xAxis.size(); i < xAxis.size() + yAxis.size(); i++) { + int j = i - xAxis.size(); + try { + series.get(j).getData().add(new BigDecimal(StringUtils.isEmpty(d[i]) ? "0" : d[i])); + } catch (Exception e) { + series.get(j).getData().add(new BigDecimal(0)); + } + } + } + + map.put("x", x); + map.put("series", series); + return map; + } + + // radar图 + private Map transRadarChartData(List xAxis, List yAxis, ChartViewWithBLOBs view, List data) { + Map map = new HashMap<>(); + List x = new ArrayList<>(); List series = new ArrayList<>(); for (ChartViewFieldDTO y : yAxis) { @@ -464,7 +564,9 @@ public class ChartViewService { List series = new ArrayList<>(); if (CollectionUtils.isNotEmpty(extStack)) { + AxisChartDataDTO defaultAxisChartDataDTO = new AxisChartDataDTO(); BigDecimal defaultValue = StringUtils.containsIgnoreCase(view.getType(), "line") ? new BigDecimal(0) : null; + defaultAxisChartDataDTO.setValue(defaultValue); // 构建横轴 for (String[] d : data) { StringBuilder a = new StringBuilder(); @@ -489,7 +591,7 @@ public class ChartViewService { series1.setType(view.getType()); List list = new ArrayList<>(); for (int i = 0; i < x.size(); i++) { - list.add(defaultValue); + list.add(defaultAxisChartDataDTO); } series1.setData(list); series.add(series1); @@ -509,9 +611,31 @@ public class ChartViewService { } if (StringUtils.equals(a.toString(), x.get(i))) { if (row.length > xAxis.size() + extStack.size()) { + List dimensionList = new ArrayList<>(); + List quotaList = new ArrayList<>(); + AxisChartDataDTO axisChartDataDTO = new AxisChartDataDTO(); + + ChartQuotaDTO chartQuotaDTO = new ChartQuotaDTO(); + chartQuotaDTO.setId(yAxis.get(0).getId()); + quotaList.add(chartQuotaDTO); + axisChartDataDTO.setQuotaList(quotaList); + + for (int k = 0; k < xAxis.size(); k++) { + ChartDimensionDTO chartDimensionDTO = new ChartDimensionDTO(); + chartDimensionDTO.setId(xAxis.get(k).getId()); + chartDimensionDTO.setValue(row[k]); + dimensionList.add(chartDimensionDTO); + } + ChartDimensionDTO chartDimensionDTO = new ChartDimensionDTO(); + chartDimensionDTO.setId(extStack.get(0).getId()); + chartDimensionDTO.setValue(row[xAxis.size()]); + dimensionList.add(chartDimensionDTO); + axisChartDataDTO.setDimensionList(dimensionList); + String s = row[xAxis.size() + extStack.size()]; if (StringUtils.isNotEmpty(s)) { - ss.getData().set(i, new BigDecimal(s)); + axisChartDataDTO.setValue(new BigDecimal(s)); + ss.getData().set(i, axisChartDataDTO); } } break; @@ -528,8 +652,35 @@ public class ChartViewService { series1.setData(new ArrayList<>()); series.add(series1); } - for (String[] d : data) { + for (int i1 = 0; i1 < data.size(); i1++) { + String[] d = data.get(i1); + StringBuilder a = new StringBuilder(); + for (int i = xAxis.size(); i < xAxis.size() + yAxis.size(); i++) { + List dimensionList = new ArrayList<>(); + List quotaList = new ArrayList<>(); + AxisChartDataDTO axisChartDataDTO = new AxisChartDataDTO(); + + for (int j = 0; j < xAxis.size(); j++) { + ChartDimensionDTO chartDimensionDTO = new ChartDimensionDTO(); + chartDimensionDTO.setId(xAxis.get(j).getId()); + chartDimensionDTO.setValue(d[j]); + dimensionList.add(chartDimensionDTO); + } + axisChartDataDTO.setDimensionList(dimensionList); + + int j = i - xAxis.size(); + ChartQuotaDTO chartQuotaDTO = new ChartQuotaDTO(); + chartQuotaDTO.setId(yAxis.get(j).getId()); + quotaList.add(chartQuotaDTO); + axisChartDataDTO.setQuotaList(quotaList); + try { + axisChartDataDTO.setValue(new BigDecimal(StringUtils.isEmpty(d[i]) ? "0" : d[i])); + } catch (Exception e) { + axisChartDataDTO.setValue(new BigDecimal(0)); + } + series.get(j).getData().add(axisChartDataDTO); + } for (int i = 0; i < xAxis.size(); i++) { if (i == xAxis.size() - 1) { a.append(d[i]); @@ -538,14 +689,6 @@ public class ChartViewService { } } x.add(a.toString()); - for (int i = xAxis.size(); i < xAxis.size() + yAxis.size(); i++) { - int j = i - xAxis.size(); - try { - series.get(j).getData().add(new BigDecimal(StringUtils.isEmpty(d[i]) ? "0" : d[i])); - } catch (Exception e) { - series.get(j).getData().add(new BigDecimal(0)); - } - } } } @@ -567,7 +710,66 @@ public class ChartViewService { series1.setData(new ArrayList<>()); series.add(series1); } - for (String[] d : data) { + for (int i1 = 0; i1 < data.size(); i1++) { + String[] d = data.get(i1); + + StringBuilder a = new StringBuilder(); + for (int i = 0; i < xAxis.size(); i++) { + if (i == xAxis.size() - 1) { + a.append(d[i]); + } else { + a.append(d[i]).append("\n"); + } + } + x.add(a.toString()); + for (int i = xAxis.size(); i < xAxis.size() + yAxis.size(); i++) { + List dimensionList = new ArrayList<>(); + List quotaList = new ArrayList<>(); + ScatterChartDataDTO scatterChartDataDTO = new ScatterChartDataDTO(); + + for (int j = 0; j < xAxis.size(); j++) { + ChartDimensionDTO chartDimensionDTO = new ChartDimensionDTO(); + chartDimensionDTO.setId(xAxis.get(j).getId()); + chartDimensionDTO.setValue(d[j]); + dimensionList.add(chartDimensionDTO); + } + scatterChartDataDTO.setDimensionList(dimensionList); + + int j = i - xAxis.size(); + ChartQuotaDTO chartQuotaDTO = new ChartQuotaDTO(); + chartQuotaDTO.setId(yAxis.get(j).getId()); + quotaList.add(chartQuotaDTO); + scatterChartDataDTO.setQuotaList(quotaList); +// try { +// axisChartDataDTO.setValue(new BigDecimal(StringUtils.isEmpty(d[i]) ? "0" : d[i])); +// } catch (Exception e) { +// axisChartDataDTO.setValue(new BigDecimal(0)); +// } + if (CollectionUtils.isNotEmpty(extBubble) && extBubble.size() > 0) { + try { + scatterChartDataDTO.setValue(new Object[]{ + a.toString(), + new BigDecimal(StringUtils.isEmpty(d[i]) ? "0" : d[i]), + new BigDecimal(StringUtils.isEmpty(d[xAxis.size() + yAxis.size()]) ? "0" : d[xAxis.size() + yAxis.size()]) + }); + } catch (Exception e) { + scatterChartDataDTO.setValue(new Object[]{a.toString(), new BigDecimal(0), new BigDecimal(0)}); + } + } else { + try { + scatterChartDataDTO.setValue(new Object[]{ + a.toString(), + new BigDecimal(StringUtils.isEmpty(d[i]) ? "0" : d[i]) + }); + } catch (Exception e) { + scatterChartDataDTO.setValue(new Object[]{a.toString(), new BigDecimal(0)}); + } + } + series.get(j).getData().add(scatterChartDataDTO); + } + } + + /*for (String[] d : data) { StringBuilder a = new StringBuilder(); for (int i = 0; i < xAxis.size(); i++) { if (i == xAxis.size() - 1) { @@ -600,7 +802,7 @@ public class ChartViewService { } } } - } + }*/ map.put("x", x); map.put("series", series); diff --git a/backend/src/main/java/io/dataease/service/dataset/DataSetTableService.java b/backend/src/main/java/io/dataease/service/dataset/DataSetTableService.java index 2bb34dce5b..080882493f 100644 --- a/backend/src/main/java/io/dataease/service/dataset/DataSetTableService.java +++ b/backend/src/main/java/io/dataease/service/dataset/DataSetTableService.java @@ -377,7 +377,7 @@ public class DataSetTableService { datasourceRequest.setDatasource(ds); String table = dataTableInfoDTO.getTable(); QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); - datasourceRequest.setQuery(qp.createQuerySQLWithPage(table, fields, page, pageSize, realSize, false)); + datasourceRequest.setQuery(qp.createQuerySQLWithPage(table, fields, page, pageSize, realSize, false, ds)); map.put("sql", datasourceRequest.getQuery()); try { data.addAll(datasourceProvider.getData(datasourceRequest)); @@ -386,7 +386,7 @@ public class DataSetTableService { DEException.throwException(e.getMessage()); } try { - datasourceRequest.setQuery(qp.createQueryTableWithLimit(table, fields, Integer.valueOf(dataSetTableRequest.getRow()), false)); + datasourceRequest.setQuery(qp.createQueryTableWithLimit(table, fields, Integer.valueOf(dataSetTableRequest.getRow()), false, ds)); dataSetPreviewPage.setTotal(datasourceProvider.getData(datasourceRequest).size()); } catch (Exception e) { e.printStackTrace(); @@ -403,7 +403,7 @@ public class DataSetTableService { datasourceRequest.setDatasource(ds); String table = DorisTableUtils.dorisName(dataSetTableRequest.getId()); QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); - datasourceRequest.setQuery(qp.createQuerySQLWithPage(table, fields, page, pageSize, realSize, false)); + datasourceRequest.setQuery(qp.createQuerySQLWithPage(table, fields, page, pageSize, realSize, false, ds)); map.put("sql", datasourceRequest.getQuery()); try { data.addAll(jdbcProvider.getData(datasourceRequest)); @@ -412,7 +412,7 @@ public class DataSetTableService { DEException.throwException(e.getMessage()); } try { - datasourceRequest.setQuery(qp.createQueryTableWithLimit(table, fields, Integer.valueOf(dataSetTableRequest.getRow()), false)); + datasourceRequest.setQuery(qp.createQueryTableWithLimit(table, fields, Integer.valueOf(dataSetTableRequest.getRow()), false, ds)); dataSetPreviewPage.setTotal(jdbcProvider.getData(datasourceRequest).size()); } catch (Exception e) { e.printStackTrace(); @@ -458,7 +458,7 @@ public class DataSetTableService { datasourceRequest.setDatasource(ds); String table = DorisTableUtils.dorisName(dataSetTableRequest.getId()); QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); - datasourceRequest.setQuery(qp.createQuerySQLWithPage(table, fields, page, pageSize, realSize, false)); + datasourceRequest.setQuery(qp.createQuerySQLWithPage(table, fields, page, pageSize, realSize, false, ds)); map.put("sql", datasourceRequest.getQuery()); try { data.addAll(jdbcProvider.getData(datasourceRequest)); @@ -467,7 +467,7 @@ public class DataSetTableService { DEException.throwException(e.getMessage()); } try { - datasourceRequest.setQuery(qp.createQueryTableWithLimit(table, fields, Integer.valueOf(dataSetTableRequest.getRow()), false)); + datasourceRequest.setQuery(qp.createQueryTableWithLimit(table, fields, Integer.valueOf(dataSetTableRequest.getRow()), false, ds)); dataSetPreviewPage.setTotal(jdbcProvider.getData(datasourceRequest).size()); } catch (Exception e) { e.printStackTrace(); @@ -485,7 +485,7 @@ public class DataSetTableService { datasourceRequest.setDatasource(ds); String table = DorisTableUtils.dorisName(dataSetTableRequest.getId()); QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); - datasourceRequest.setQuery(qp.createQuerySQLWithPage(table, fields, page, pageSize, realSize, false)); + datasourceRequest.setQuery(qp.createQuerySQLWithPage(table, fields, page, pageSize, realSize, false, ds)); map.put("sql", datasourceRequest.getQuery()); try { data.addAll(jdbcProvider.getData(datasourceRequest)); @@ -494,7 +494,7 @@ public class DataSetTableService { DEException.throwException(e.getMessage()); } try { - datasourceRequest.setQuery(qp.createQueryTableWithLimit(table, fields, Integer.valueOf(dataSetTableRequest.getRow()), false)); + datasourceRequest.setQuery(qp.createQueryTableWithLimit(table, fields, Integer.valueOf(dataSetTableRequest.getRow()), false, ds)); dataSetPreviewPage.setTotal(jdbcProvider.getData(datasourceRequest).size()); } catch (Exception e) { e.printStackTrace(); @@ -537,7 +537,7 @@ public class DataSetTableService { datasourceRequest.setDatasource(ds); String table = DorisTableUtils.dorisName(dataSetTableRequest.getId()); QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); - datasourceRequest.setQuery(qp.createQuerySQLWithPage(table, fields, page, pageSize, realSize, false)); + datasourceRequest.setQuery(qp.createQuerySQLWithPage(table, fields, page, pageSize, realSize, false, ds)); map.put("sql", datasourceRequest.getQuery()); try { data.addAll(jdbcProvider.getData(datasourceRequest)); @@ -547,7 +547,7 @@ public class DataSetTableService { } try { - datasourceRequest.setQuery(qp.createQueryTableWithLimit(table, fields, Integer.valueOf(dataSetTableRequest.getRow()), false)); + datasourceRequest.setQuery(qp.createQueryTableWithLimit(table, fields, Integer.valueOf(dataSetTableRequest.getRow()), false, ds)); dataSetPreviewPage.setTotal(jdbcProvider.getData(datasourceRequest).size()); } catch (Exception e) { e.printStackTrace(); diff --git a/backend/src/main/java/io/dataease/service/dataset/ExtractDataService.java b/backend/src/main/java/io/dataease/service/dataset/ExtractDataService.java index 8aafc110d1..6c90cb0491 100644 --- a/backend/src/main/java/io/dataease/service/dataset/ExtractDataService.java +++ b/backend/src/main/java/io/dataease/service/dataset/ExtractDataService.java @@ -865,7 +865,7 @@ public class ExtractDataService { textFileOutputMeta.setSeparator(separator); textFileOutputMeta.setExtension(extention); - if (datasource.getType().equalsIgnoreCase(DatasourceTypes.oracle.name())) { + if (datasource.getType().equalsIgnoreCase(DatasourceTypes.oracle.name()) ) { TextFileField[] outputFields = new TextFileField[datasetTableFields.size() + 1]; for(int i=0;i< datasetTableFields.size();i++){ TextFileField textFileField = new TextFileField(); @@ -878,6 +878,20 @@ public class ExtractDataService { textFileField.setType("String"); outputFields[datasetTableFields.size()] = textFileField; + textFileOutputMeta.setOutputFields(outputFields); + }else if (datasource.getType().equalsIgnoreCase(DatasourceTypes.sqlServer.name())){ + TextFileField[] outputFields = new TextFileField[datasetTableFields.size() + 1]; + for(int i=0;i< datasetTableFields.size();i++){ + TextFileField textFileField = new TextFileField(); + textFileField.setName(datasetTableFields.get(i).getDataeaseName()); + textFileField.setType("String"); + outputFields[i] = textFileField; + } + TextFileField textFileField = new TextFileField(); + textFileField.setName("dataease_uuid"); + textFileField.setType("String"); + outputFields[datasetTableFields.size()] = textFileField; + textFileOutputMeta.setOutputFields(outputFields); }else { textFileOutputMeta.setOutputFields(new TextFileField[0]); @@ -891,6 +905,14 @@ public class ExtractDataService { private StepMeta udjc(List datasetTableFields, DatasourceTypes datasourceType) { String needToChangeColumnType = ""; + String handleBinaryTypeCode = ""; + + for (DatasetTableField datasetTableField : datasetTableFields) { + if(datasetTableField.getDeExtractType() == 5){ + handleBinaryTypeCode = handleBinaryTypeCode + "\n" + this.handleBinaryType.replace("FEILD", datasetTableField.getDataeaseName()); + } + } + UserDefinedJavaClassMeta userDefinedJavaClassMeta = new UserDefinedJavaClassMeta(); List fields = new ArrayList<>(); UserDefinedJavaClassMeta.FieldInfo fieldInfo = new UserDefinedJavaClassMeta.FieldInfo("dataease_uuid", ValueMetaInterface.TYPE_STRING, -1, -1); @@ -906,11 +928,15 @@ public class ExtractDataService { } else { Column_Fields = String.join(",", datasetTableFields.stream().map(DatasetTableField::getDataeaseName).collect(Collectors.toList())); } + if (datasourceType.equals(DatasourceTypes.excel)) { tmp_code = tmp_code.replace("handleExcelIntColumn", handleExcelIntColumn).replace("Column_Fields", Column_Fields); } else { tmp_code = tmp_code.replace("handleExcelIntColumn", "").replace("Column_Fields", Column_Fields); } + + tmp_code = tmp_code.replace("handleBinaryType", handleBinaryTypeCode); + UserDefinedJavaClassDef userDefinedJavaClassDef = new UserDefinedJavaClassDef(UserDefinedJavaClassDef.ClassType.TRANSFORM_CLASS, "Processor", tmp_code); userDefinedJavaClassDef.setActive(true); @@ -993,6 +1019,12 @@ public class ExtractDataService { } } + private static String handleBinaryType = " \t\tif(\"FEILD\".equalsIgnoreCase(filed)){\n" + + " get(Fields.Out, filed).setValue(r, \"\");\n" + + " get(Fields.Out, filed).getValueMeta().setType(2);\n" + + " \t}"; + + private static String alterColumnTypeCode = " if(\"FILED\".equalsIgnoreCase(filed)){\n" + "\t if(tmp != null && tmp.equalsIgnoreCase(\"Y\")){\n" + " get(Fields.Out, filed).setValue(r, 1);\n" + @@ -1049,6 +1081,7 @@ public class ExtractDataService { " String tmp = get(Fields.In, filed).getString(r);\n" + "handleWraps \n" + "alterColumnTypeCode \n" + + "handleBinaryType \n" + "handleExcelIntColumn \n" + " str = str + tmp;\n" + " }\n" + diff --git a/backend/src/main/java/io/dataease/service/dataset/impl/direct/DirectFieldService.java b/backend/src/main/java/io/dataease/service/dataset/impl/direct/DirectFieldService.java index 3694d17c1a..e683bea423 100644 --- a/backend/src/main/java/io/dataease/service/dataset/impl/direct/DirectFieldService.java +++ b/backend/src/main/java/io/dataease/service/dataset/impl/direct/DirectFieldService.java @@ -67,7 +67,7 @@ public class DirectFieldService implements DataSetFieldService { QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); if (StringUtils.equalsIgnoreCase(datasetTable.getType(), "db")) { datasourceRequest.setTable(dataTableInfoDTO.getTable()); - datasourceRequest.setQuery(qp.createQuerySQL(dataTableInfoDTO.getTable(), Collections.singletonList(field), true)); + datasourceRequest.setQuery(qp.createQuerySQL(dataTableInfoDTO.getTable(), Collections.singletonList(field), true, ds)); } else if (StringUtils.equalsIgnoreCase(datasetTable.getType(), "sql")) { datasourceRequest.setQuery(qp.createQuerySQLAsTmp(dataTableInfoDTO.getSql(), Collections.singletonList(field), true)); } else if (StringUtils.equalsIgnoreCase(datasetTable.getType(), "custom")) { @@ -85,7 +85,7 @@ public class DirectFieldService implements DataSetFieldService { tableName = "ds_" + datasetTable.getId().replaceAll("-", "_"); datasourceRequest.setTable(tableName); QueryProvider qp = ProviderFactory.getQueryProvider(ds.getType()); - datasourceRequest.setQuery(qp.createQuerySQL(tableName, Collections.singletonList(field), true)); + datasourceRequest.setQuery(qp.createQuerySQL(tableName, Collections.singletonList(field), true, null)); } try { diff --git a/backend/src/main/resources/db/migration/V21__user_key.sql b/backend/src/main/resources/db/migration/V21__user_key.sql new file mode 100644 index 0000000000..8de55ea198 --- /dev/null +++ b/backend/src/main/resources/db/migration/V21__user_key.sql @@ -0,0 +1,15 @@ +-- ---------------------------- +-- Table structure for user_key +-- ---------------------------- +DROP TABLE IF EXISTS `user_key`; +CREATE TABLE `user_key` ( + `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID', + `user_id` bigint(20) DEFAULT NULL COMMENT '用户ID', + `access_key` varchar(50) NOT NULL COMMENT 'access_key', + `secret_key` varchar(50) NOT NULL COMMENT 'secret key', + `create_time` bigint(13) NOT NULL COMMENT '创建时间', + `status` varchar(10) DEFAULT NULL COMMENT '状态', + PRIMARY KEY (`id`) USING BTREE, + UNIQUE KEY `IDX_AK` (`access_key`), + KEY `IDX_USER_K_ID` (`user_id`) USING BTREE +) ENGINE=InnoDB AUTO_INCREMENT=17 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='用户KEY'; \ No newline at end of file diff --git a/frontend/src/icons/svg/treemap.svg b/frontend/src/icons/svg/treemap.svg new file mode 100644 index 0000000000..e0fcce2b30 --- /dev/null +++ b/frontend/src/icons/svg/treemap.svg @@ -0,0 +1 @@ + diff --git a/frontend/src/lang/en.js b/frontend/src/lang/en.js index 954a4248ff..8cf635faf5 100644 --- a/frontend/src/lang/en.js +++ b/frontend/src/lang/en.js @@ -337,7 +337,8 @@ export default { confirm: 'Confirm', ok: 'Confirm', cancel: 'Cancel' - } + }, + ukey_title: 'API Keys' }, documentation: { documentation: 'Documentation', @@ -831,7 +832,12 @@ export default { axis_label_rotate: 'Label Rotate', chart_scatter_bubble: 'Bubble', chart_scatter: 'Scatter', - bubble_size: 'Bubble Size' + bubble_size: 'Bubble Size', + chart_treemap: 'Tree Map', + drill: 'Drill', + drag_block_treemap_label: 'Color Label', + drag_block_treemap_size: 'Color Size', + bubble_symbol: 'Shape' }, dataset: { sheet_warn: 'There are multiple sheet pages, and the first one is extracted by default', diff --git a/frontend/src/lang/tw.js b/frontend/src/lang/tw.js index e9461d3571..b0a38fd1b0 100644 --- a/frontend/src/lang/tw.js +++ b/frontend/src/lang/tw.js @@ -337,7 +337,8 @@ export default { confirm: '確認', ok: '確認', cancel: '取消' - } + }, + ukey_title: 'API Keys' }, documentation: { documentation: '文檔', @@ -831,7 +832,12 @@ export default { axis_label_rotate: '標簽角度', chart_scatter_bubble: '氣泡圖', chart_scatter: '散點圖', - bubble_size: '氣泡大小' + bubble_size: '氣泡大小', + chart_treemap: '矩形樹圖', + drill: '鉆取', + drag_block_treemap_label: '色塊標簽', + drag_block_treemap_size: '色塊大小', + bubble_symbol: '圖形' }, dataset: { sheet_warn: '有多個sheet頁面，默認抽取第一個', diff --git a/frontend/src/lang/zh.js b/frontend/src/lang/zh.js index 8e2f3c2f25..ba630a4bd8 100644 --- a/frontend/src/lang/zh.js +++ b/frontend/src/lang/zh.js @@ -337,7 +337,8 @@ export default { confirm: '确认', ok: '确认', cancel: '取消' - } + }, + ukey_title: 'API Keys' }, documentation: { documentation: '文档', @@ -831,7 +832,12 @@ export default { axis_label_rotate: '标签角度', chart_scatter_bubble: '气泡图', chart_scatter: '散点图', - bubble_size: '气泡大小' + bubble_size: '气泡大小', + chart_treemap: '矩形树图', + drill: '钻取', + drag_block_treemap_label: '色块标签', + drag_block_treemap_size: '色块大小', + bubble_symbol: '图形' }, dataset: { sheet_warn: '有多个 Sheet 页，默认抽取第一个', diff --git a/frontend/src/layout/components/Topbar.vue b/frontend/src/layout/components/Topbar.vue index d74a84cdb6..3df7960cfb 100644 --- a/frontend/src/layout/components/Topbar.vue +++ b/frontend/src/layout/components/Topbar.vue @@ -53,6 +53,11 @@ {{ $t('commons.personal_info') }} + + + {{ $t('commons.ukey_title') }} + + {{ $t('user.change_password') }} diff --git a/frontend/src/views/chart/chart/chart.js b/frontend/src/views/chart/chart/chart.js index 1363562f7f..90e7c5134f 100644 --- a/frontend/src/views/chart/chart/chart.js +++ b/frontend/src/views/chart/chart/chart.js @@ -689,3 +689,39 @@ export const BASE_SCATTER = { } ] } + +export const BASE_TREEMAP = { + title: { + text: '', + textStyle: { + fontWeight: 'normal' + } + }, + grid: { + containLabel: true + }, + tooltip: {}, + legend: { + show: true, + type: 'scroll', + itemWidth: 10, + itemHeight: 10, + icon: 'rect' + }, + series: [ + { + // name: '', + type: 'treemap', + // radius: ['0%', '60%'], + // avoidLabelOverlap: false, + // emphasis: { + // itemStyle: { + // shadowBlur: 10, + // shadowOffsetX: 0, + // shadowColor: 'rgba(0, 0, 0, 0.5)' + // } + // }, + data: [] + } + ] +} diff --git a/frontend/src/views/chart/chart/funnel/funnel.js b/frontend/src/views/chart/chart/funnel/funnel.js index 8a5c4fc9c2..522016ecfe 100644 --- a/frontend/src/views/chart/chart/funnel/funnel.js +++ b/frontend/src/views/chart/chart/funnel/funnel.js @@ -31,18 +31,18 @@ export function baseFunnelOption(chart_option, chart) { chart_option.series[0].label = customAttr.label } const valueArr = chart.data.series[0].data - // max value - chart_option.series[0].max = Math.max.apply(Math, valueArr) for (let i = 0; i < valueArr.length; i++) { - const y = { - name: chart.data.x[i], - value: valueArr[i] - } + // const y = { + // name: chart.data.x[i], + // value: valueArr[i] + // } + const y = valueArr[i] + y.name = chart.data.x[i] // color y.itemStyle = { color: hexColorToRGBA(customAttr.color.colors[i % 9], customAttr.color.alpha) } - y.type = 'funnel' + // y.type = 'funnel' chart_option.series[0].data.push(y) } } diff --git a/frontend/src/views/chart/chart/pie/pie.js b/frontend/src/views/chart/chart/pie/pie.js index 0b8bb92469..d2afdd159d 100644 --- a/frontend/src/views/chart/chart/pie/pie.js +++ b/frontend/src/views/chart/chart/pie/pie.js @@ -33,10 +33,12 @@ export function basePieOption(chart_option, chart) { } const valueArr = chart.data.series[0].data for (let i = 0; i < valueArr.length; i++) { - const y = { - name: chart.data.x[i], - value: valueArr[i] - } + // const y = { + // name: chart.data.x[i], + // value: valueArr[i] + // } + const y = valueArr[i] + y.name = chart.data.x[i] // color y.itemStyle = { color: hexColorToRGBA(customAttr.color.colors[i % 9], customAttr.color.alpha), @@ -84,10 +86,12 @@ export function rosePieOption(chart_option, chart) { } const valueArr = chart.data.series[0].data for (let i = 0; i < valueArr.length; i++) { - const y = { - name: chart.data.x[i], - value: valueArr[i] - } + // const y = { + // name: chart.data.x[i], + // value: valueArr[i] + // } + const y = valueArr[i] + y.name = chart.data.x[i] // color y.itemStyle = { color: hexColorToRGBA(customAttr.color.colors[i % 9], customAttr.color.alpha), diff --git a/frontend/src/views/chart/chart/treemap/treemap.js b/frontend/src/views/chart/chart/treemap/treemap.js new file mode 100644 index 0000000000..5ecca3ca82 --- /dev/null +++ b/frontend/src/views/chart/chart/treemap/treemap.js @@ -0,0 +1,53 @@ +import { hexColorToRGBA } from '@/views/chart/chart/util' +import { componentStyle } from '../common/common' + +export function baseTreemapOption(chart_option, chart) { + // 处理shape attr + let customAttr = {} + if (chart.customAttr) { + customAttr = JSON.parse(chart.customAttr) + if (customAttr.color) { + chart_option.color = customAttr.color.colors + } + // tooltip + if (customAttr.tooltip) { + const tooltip = JSON.parse(JSON.stringify(customAttr.tooltip)) + const reg = new RegExp('\n', 'g') + tooltip.formatter = tooltip.formatter.replace(reg, '
') + chart_option.tooltip = tooltip + } + } + // 处理data + if (chart.data) { + chart_option.title.text = chart.title + if (chart.data.series.length > 0) { + // chart_option.series[0].name = chart.data.series[0].name + // size + if (customAttr.size) { + // chart_option.series[0].radius = [customAttr.size.pieInnerRadius + '%', customAttr.size.pieOuterRadius + '%'] + } + // label + if (customAttr.label) { + // chart_option.series[0].label = customAttr.label + } + const valueArr = chart.data.series[0].data + for (let i = 0; i < valueArr.length; i++) { + // const y = { + // name: chart.data.x[i], + // value: valueArr[i] + // } + const y = valueArr[i] + y.name = chart.data.x[i] + // color + y.itemStyle = { + color: hexColorToRGBA(customAttr.color.colors[i % 9], customAttr.color.alpha) + } + // y.type = 'treemap' + chart_option.series[0].data.push(y) + } + } + } + // console.log(chart_option); + componentStyle(chart_option, chart) + return chart_option +} diff --git a/frontend/src/views/chart/components/ChartComponent.vue b/frontend/src/views/chart/components/ChartComponent.vue index 276ff69e26..1cea6ea399 100644 --- a/frontend/src/views/chart/components/ChartComponent.vue +++ b/frontend/src/views/chart/components/ChartComponent.vue @@ -5,7 +5,7 @@