How to use

SqlExecutor

in

org.hswebframework.ezorm.rdb.executor

@Override
public List<TableMetadata> parseAll() throws SQLException {
  String dsId = DataSourceHolder.switcher().currentDataSourceId();
  return sqlExecutor.list(getSelectAllTableSql())
      .parallelStream()
      .map(map -> map.get("name"))
      .map(String::valueOf)
      .map(tableName -> {
        try {
          DataSourceHolder.switcher().use(dsId);
          return this.parse(tableName);
        } finally {
          DataSourceHolder.switcher().reset();
        }
      })
      .filter(Objects::nonNull)
      .collect(Collectors.toList());
}

  public SqlExecuteResult doExecute(SqlInfo sqlInfo) {
    SqlExecuteResult result = new SqlExecuteResult();
    Object executeResult = null;
    try {
      switch (sqlInfo.getType().toUpperCase()) {
        case "SELECT":
          QueryResultWrapper wrapper = new QueryResultWrapper();
          executor.list(sqlInfo.getSql(), wrapper);
          executeResult = wrapper.getResult();
          break;
        case "INSERT":
        case "UPDATE":
          executeResult = executor.update(sqlInfo.getSql());
          break;
        case "DELETE":
          executeResult = executor.delete(sqlInfo.getSql());
          break;
        default:
          executor.exec(sqlInfo.getSql());
      }
      result.setSuccess(true);
    } catch (SQLException e) {
      throw new SqlExecuteException(e.getMessage(), e, sqlInfo.getSql());
    }
    result.setResult(executeResult);
    result.setSqlInfo(sqlInfo);

    return result;
  }
}

  @Override
  public void run(String... args) throws Exception {
    if (sqlExecutor.tableExists("QRTZ_LOCKS")) {
      return;
    }
    DatabaseType databaseType = DataSourceHolder.currentDatabaseType();
    String databaseTypeName = databaseType.name();
    if (databaseType == DatabaseType.jtds_sqlserver) {
      databaseTypeName = DatabaseType.sqlserver.name();
    }
    String file = "classpath*:/quartz/sql/quartz-" + databaseTypeName + "-create.sql";
    Resource[] resources = new PathMatchingResourcePatternResolver().getResources(file);

    for (Resource resource : resources) {
      try (Reader reader = new InputStreamReader(resource.getInputStream())) {
        String str = FileUtils.reader2String(reader);
        List<String> sqlList = Sqls.parse(str);
        for (String sql : sqlList) {
          if (StringUtils.isEmpty(sql)) return;
          sqlExecutor.exec(sql);
        }
      }
    }
  }
}

@Override
@SneakyThrows
public TableMetadata parse(String objectName) {
  Map<String, Object> param = new HashMap<>();
  param.put("table", objectName);
  Map<String, Object> tableMetaMap = sqlExecutor.single(getSelectTableMetaSql(), param);
  if (tableMetaMap == null) {
    return null;
  }
  TableMetadata table = new TableMetadata();
  table.setName(objectName);
  table.setComment((String) tableMetaMap.getOrDefault("comment", ""));
  List<ColumnMetadata> columns = sqlExecutor.list(getSelectTableColumnsSql(), param, wrapper);
  table.setColumns(columns);
  return table;
}

    .list();
for (HistoricActivityInstance historicActivityInstance : instance) {
  sqlExecutor.delete("delete from act_hi_actinst where id_= #{id}", historicActivityInstance);

default void exec(String sql, Object params) throws SQLException {
  exec(new SimpleSQL(sql, params));
}

default Map<String, Object> single(SQL sql) throws SQLException {
  return single(sql, mapWrapper);
}

protected void initInstallInfo() throws SQLException {
  boolean tableInstall = sqlExecutor.tableExists("s_system");
  database.createOrAlter("s_system")
      .addColumn().name("name").varchar(128).comment("系统名称").commit()
      .addColumn().name("major_version").alias(majorVersion).number(32).javaType(Integer.class).comment("主版本号").commit()
      .addColumn().name("minor_version").alias(minorVersion).number(32).javaType(Integer.class).comment("次版本号").commit()
      .addColumn().name("revision_version").alias(revisionVersion).number(32).javaType(Integer.class).comment("修订版").commit()
      .addColumn().name("snapshot").number(1).javaType(Boolean.class)
      .custom(column -> column.setValueConverter(new NumberValueConverter(Boolean.class)))
      .comment("是否快照版").commit()
      .addColumn().name("comment").varchar(2000).comment("系统说明").commit()
      .addColumn().name("website").varchar(2000).comment("系统网址").commit()
      .addColumn().name("framework_version").notNull().alias(frameworkVersion).clob()
      .custom(column -> column.setValueConverter(new JSONValueConverter(SystemVersion.FrameworkVersion.class, new ClobValueConverter()))).notNull().comment("框架版本").commit()
      .addColumn().name("dependencies").notNull().alias(dependencies).clob()
      .custom(column -> column.setValueConverter(new JSONValueConverter(SystemVersion.Dependency.class, new ClobValueConverter()))).notNull().comment("依赖详情").commit()
      .comment("系统信息")
      .custom(table -> table.setObjectWrapper(new BeanWrapper<SystemVersion>(SystemVersion::new, table)))
      .commit();
  if (!tableInstall) {
    installed = null;
    return;
  }
  RDBTable<SystemVersion> rdbTable = database.getTable("s_system");
  installed = rdbTable.createQuery().where("name", targetVersion.getName()).single();
}

default int update(String sql) throws SQLException {
  return update(new SimpleSQL(sql));
}

default int insert(String sql, Object params) throws SQLException {
  return insert(new SimpleSQL(sql, params));
}

@Override
@SneakyThrows
public TableMetadata parse(String objectName) {
  Map<String, Object> param = new HashMap<>();
  param.put("table", objectName);
  Map<String, Object> tableMetaMap = sqlExecutor.single(getSelectTableMetaSql(), param);
  if (tableMetaMap == null) {
    return null;
  }
  TableMetadata table = new TableMetadata();
  table.setName(objectName);
  table.setComment((String) tableMetaMap.getOrDefault("comment", ""));
  List<ColumnMetadata> columns = sqlExecutor.list(getSelectTableColumnsSql(), param, wrapper);
  table.setColumns(columns);
  return table;
}

default int delete(String sql, Object params) throws SQLException {
  return delete(new SimpleSQL(sql, params));
}

default void exec(String sql) throws SQLException {
  exec(new SimpleSQL(sql));
}

default Map<String, Object> single(SQL sql) throws SQLException {
  return single(sql, mapWrapper);
}

@Override
public TableBuilder createOrAlter(String name) {
  RDBTableMetaData tableMetaData = new RDBTableMetaData();
  tableMetaData.setName(name);
  tableMetaData.setDatabaseMetaData(metaData);
  try {
    boolean tableExists;
    if (metaData.getParser() != null) {
      tableExists = metaData.getParser().tableExists(name);
    } else {
      tableExists = sqlExecutor.tableExists(name);
    }
    if (tableExists) {
      if (metaData.getParser() != null) {
        RDBTableMetaData tmp = metaData.getParser().parse(name);
        tmp.getColumns().forEach(tableMetaData::addColumn);
      } else {
        logger.warn("table {} exists,but tableMetaParser is null", name);
      }
    }
  } catch (Exception e) {
  }
  return new SimpleTableBuilder(tableMetaData, this, sqlExecutor);
}

default int update(String sql) throws SQLException {
  return update(new SimpleSQL(sql));
}

default int insert(String sql, Object params) throws SQLException {
  return insert(new SimpleSQL(sql, params));
}

  @Override
  @SneakyThrows
  public Object execute(DashBoardConfigEntity entity, Authentication authentication) {
    Map<String, Object> scriptContext = new HashMap<>();

    scriptContext.put("autz", authentication);

    if ("sql".equals(entity.getScriptLanguage())) {
      return sqlExecutor.list(entity.getScript(), scriptContext);
    }

    DynamicScriptEngine engine = DynamicScriptEngineFactory.getEngine(entity.getScriptLanguage());
    if (engine != null) {
      String id = DigestUtils.md5DigestAsHex(entity.getScript().getBytes());

      if (!engine.compiled(id)) {
        engine.compile(id, entity.getScript());
      }

      return engine.execute(id, scriptContext).getIfSuccess();
    }

    return null;
  }
}

  public SqlExecuteResult doExecute(SqlInfo sqlInfo) {
    SqlExecuteResult result = new SqlExecuteResult();
    Object executeResult = null;
    try {
      switch (sqlInfo.getType().toUpperCase()) {
        case "SELECT":
          QueryResultWrapper wrapper = new QueryResultWrapper();
          executor.list(sqlInfo.getSql(), wrapper);
          executeResult = wrapper.getResult();
          break;
        case "INSERT":
        case "UPDATE":
          executeResult = executor.update(sqlInfo.getSql());
          break;
        case "DELETE":
          executeResult = executor.delete(sqlInfo.getSql());
          break;
        default:
          executor.exec(sqlInfo.getSql());
      }
      result.setSuccess(true);
    } catch (SQLException e) {
      throw new SqlExecuteException(e.getMessage(), e, sqlInfo.getSql());
    }
    result.setResult(executeResult);
    result.setSqlInfo(sqlInfo);

    return result;
  }
}

@Override
@SneakyThrows
public RDBTableMetaData parse(String name) {
  if (!tableExists(name)) return null;
  RDBTableMetaData metaData = new RDBTableMetaData();
  metaData.setName(name);
  metaData.setAlias(name);
  Map<String, Object> param = new HashMap<>();
  param.put("table", name);
  List<RDBColumnMetaData> metaDatas = sqlExecutor.list(new SimpleSQL(getTableMetaSql(name), param), new RDBColumnMetaDataWrapper());
  metaDatas.forEach(metaData::addColumn);
  Map<String, Object> comment = sqlExecutor.single(new SimpleSQL(getTableCommentSql(name), param), new LowerCasePropertySimpleMapWrapper());
  if (null != comment && comment.get("comment") != null) {
    metaData.setComment(String.valueOf(comment.get("comment")));
  }
  return metaData;
}