How to use org.hswebframework.ezorm.rdb.executor

  @Override
  @Transactional(propagation = Propagation.NOT_SUPPORTED)
  public void exec(String sql, Object params) throws SQLException {
    super.exec(sql, params);
  }
}

@Override
@Transactional(readOnly = true)
public void list(String sql, Consumer<Map<String, Object>> consumer) throws SQLException {
  super.list(sql, consumer);
}

@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;
}

  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
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());
}

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

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();
}

public String buildUpdateSql(String resultMapId, String tableName, UpdateParam param) {
  Pager.reset();
  RDBTableMetaData tableMetaData = createMeta(tableName, resultMapId);
  SqlRender<UpdateParam> render = tableMetaData.getDatabaseMetaData().getRenderer(SqlRender.TYPE.UPDATE);
  return render.render(tableMetaData, param).getSql();
}

  @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;
  }
}

@Override
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void exec(SQL sql) throws SQLException {
  super.exec(sql);
}

@Override
@Transactional(readOnly = true)
public <T> List<T> list(String sql, Object params, ObjectWrapper<T> wrapper) throws SQLException {
  return super.list(sql, params, wrapper);
}

public String buildInsertSql(String resultMapId, String tableName, Object param) {
  Pager.reset();
  InsertParam insertParam;
  if (param instanceof InsertParam) {
    insertParam = ((InsertParam) param);
  } else {
    insertParam = new InsertParam<>(param);
  }
  RDBTableMetaData tableMetaData = createMeta(tableName, resultMapId);
  SqlRender<InsertParam> render = tableMetaData.getDatabaseMetaData().getRenderer(SqlRender.TYPE.INSERT);
  return render.render(tableMetaData, insertParam).getSql();
}

@Override
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void exec(String sql) throws SQLException {
  super.exec(sql);
}

@Override
@Transactional(readOnly = true)
public void list(String sql, Object params, Consumer<Map<String, Object>> consumer) throws SQLException {
  super.list(sql, params, consumer);
}

@Override
@Transactional(readOnly = true)
public <T> List<T> list(SQL sql, ObjectWrapper<T> wrapper) throws SQLException {
  return super.list(sql, wrapper);
}

@Override
@Transactional(readOnly = true)
public <T> List<T> list(String sql, ObjectWrapper<T> wrapper) throws SQLException {
  return super.list(sql, wrapper);
}

@Override
@Transactional(readOnly = true)
public List<Map<String, Object>> list(String sql) throws SQLException {
  return super.list(sql);
}

@Override
@Transactional(readOnly = true)
public List<Map<String, Object>> list(SQL sql) throws SQLException {
  return super.list(sql);
}

@Override
@Transactional(readOnly = true)
public List<Map<String, Object>> list(String sql, Object params) throws SQLException {
  return super.list(sql, params);
}