Java 将ORACLE Flashback与QueryDSL结合使用

我们使用QueryDSL通过SpringBoot应用程序从Oracle数据库批量读取数据

final QFps fps = QFps.fps;
final SQLQuery<Tuple> query = queryFactory.select(fps.fpId, fps.fieldA, fps.fieldB)
                                          .from(fps)
                                          .where(fps.fpId.eq(fpId));

final String sql = query.getSQL().getSQL();
log.info("sql={}", sql);

return query.fetch();

这同样适用于左连接：

final QFps fps = QFps.fps;
final QHalt halt = QHalt.halt;
final SQLQuery<Tuple> query = queryFactory.select(fps.fpId, fps.fieldA, fps.fieldB, halt.fieldC)
                                          .from(fps)
                                          .leftJoin(halt).on(fps.fieldA.eq(halt.id))
                                          .where(fps.fpId.eq(fpId));

final String sql = query.getSQL().getSQL();
log.info("sql={}", sql);

return query.fetch();

然而，由于我们需要查询特定时间点的数据，我们需要利用Oracle的Flashback功能。基本上，这需要在表名和别名之间添加以下SQL：

AS OF TIMESTAMP TO_TIMESTAMP('2021-01-26 14:48:23', 'YYYY-MM-DD HH24:MI:SS')

i、 e

我尝试使用

.addFlag（）

和

.addJoinFlag（）

命令在QueryDSL中实现此功能，但未成功

final QFps fps = QFps.fps;
final SQLQuery<Tuple> query = queryFactory.select(fps.fpId, fps.fieldA, fps.fieldB)
                                          .from(fps)
                                          .addFlag(Position.BEFORE_FILTER, getFlashbackString())
                                          .where(fps.fpId.eq(fpId));

final String sql = query.getSQL().getSQL();
log.info("sql={}", sql);

return query.fetch();

具体来说，问题在于闪回字符串添加在别名之后，而不是表名和别名之间

使用联接时，情况会变得更糟：

final QFps fps = QFps.fps;
final QHalt halt = QHalt.halt;
final SQLQuery<Tuple> query = queryFactory.select(fps.fpId, fps.fieldA, fps.fieldB, halt.fieldC)
                                          .from(fps)
                                          .addFlag(Position.BEFORE_FILTER, getFlashbackString())
                                          .leftJoin(halt).on(fps.fieldA.eq(halt.id))
                                          .addJoinFlag(getFlashbackString())
                                          .where(fps.fpId.eq(fpId));

final String sql = query.getSQL().getSQL();
log.info("sql={}", sql);

return query.fetch();

.addJoinFlag（）

的结果添加在表名之前，而

.addFlag（）

的内容添加在

where

之前，这并不奇怪

final QFps fps = QFps.fps;
final QHalt halt = QHalt.halt;
final SQLQuery<Tuple> query = queryFactory.select(fps.fpId, fps.fieldA, fps.fieldB, halt.fieldC)
                                          .from(fps)
                                          .addFlag(Position.BEFORE_FILTER, getFlashbackString())
                                          .leftJoin(halt).on(fps.fieldA.eq(halt.id))
                                          .addJoinFlag(getFlashbackString(), Position.BEFORE_CONDITION)
                                          .where(fps.fpId.eq(fpId));

final String sql = query.getSQL().getSQL();
log.info("sql={}", sql);

return query.fetch();

这没什么好的

我已经尝试了各种可能的方法，但没有找到一种方法将要插入的字符串放置在正确的位置

我是否缺少在查询的某些位置注入SQL的另一种方法

如果做不到这一点，我可以使用QueryDSL生成SQL字符串，然后自己使用正则表达式修改它。有没有一种方法可以将这样的字符串传递给QueryDSL以便执行查询

---

整合接受的答案

Jan Willem Gmellig Meyling给出的答案很有效，我只想将其完全整合到我上面的样本中：

我创建了一个助手方法：

  private static final String ADDITIONAL_FLASHBACK_EXPRESSION = "{0} AS OF TIMESTAMP TO_TIMESTAMP({1}, 'YYYY-MM-DD HH24:MI:SS') {2}";
  private static final DateTimeFormatter FLASHBACK_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

public <T> Expression<String> getFlashbackExpresion(final Timestamp flashbackTimestamp, final RelationalPathBase<T> table) {
    if (flashbackTimestamp == null) {
      return Expressions.stringTemplate(WITHOUT_FLASHBACK_EXPRESSION, table, table);
    }
    
    final LocalDateTime timestamp = LocalDateTime.ofInstant(flashbackTimestamp.toInstant(), ZoneOffset.ofHours(0));
    final String timestampString = timestamp.format(FLASHBACK_FORMATTER);
    
    return Expressions.stringTemplate(ADDITIONAL_FLASHBACK_EXPRESSION, table, timestampString, table);
  }

产生

select FPS.FP_ID, FPS.FIELD_A, FPS.FIELD_B, HALT.FIELD_C
from FPS AS OF TIMESTAMP TO_TIMESTAMP('2021-01-26 14:48:23', 'YYYY-MM-DD HH24:MI:SS') FPS
join HALT AS OF TIMESTAMP TO_TIMESTAMP('2021-01-26 14:48:23', 'YYYY-MM-DD HH24:MI:SS') HALT on FPS.FIELD_A = HALT.ID
where FPS.FP_ID = ?

---

这正是我想要的。

尽管JoinFlags用于实现类似的功能，但正如您所注意到的，JoinFlags目前不能用于在路径表达式和别名之间插入标志。这实际上是因为连接别名嵌入在路径表达式中

将SQL片段插入生成的查询的另一种机制是通过

TemplateExpressions

。尽管不存在将

TemplateExpressions

用作联接目标的API，但您可以通过基础查询元数据将任何表达式类型添加为联接：

//甚至为您将其参数化：）
表达式闪回=Expressions.stringTemplate(
“{0}从时间戳到_时间戳（{1}，'YYYY-MM-DD HH24:MI:SS'）”，
停止
'2021-01-26 14:48:23');
查询来源（fps）；
query.getMetadata（）.addJoin（JoinType.LEFTJOIN，flashback）；
on（fps.fieldA.eq（halt.id））；

---

---

如果您不喜欢上面代码段的语法，还有其他一些方法。您还可以看看我是如何在QueryDSL for JPA:上实现处理路径的。但是，这需要您在QueryDSL核心类中引入一个更改。

谢谢，该代码段在连接中运行良好。我仍在尝试如何为

from（）

语句实现同样的功能，但希望这能给我一个开始。啊，我刚刚发现我可以使用stringTemplate作为from（）的输入，解决我所有的问题！

final QFps fps = QFps.fps;
final QHalt halt = QHalt.halt;
final SQLQuery<Tuple> query = queryFactory.select(fps.fpId, fps.fieldA, fps.fieldB, halt.fieldC)
                                          .from(fps)
                                          .addFlag(Position.BEFORE_FILTER, getFlashbackString())
                                          .leftJoin(halt).on(fps.fieldA.eq(halt.id))
                                          .addJoinFlag(getFlashbackString())
                                          .where(fps.fpId.eq(fpId));

final String sql = query.getSQL().getSQL();
log.info("sql={}", sql);

return query.fetch();

select FPS.FP_ID, FPS.FIELD_A, FPS.FIELD_B, HALT.FIELD_C
from FPS FPS  
join  AS OF TIMESTAMP TO_TIMESTAMP('2021-01-26 14:48:23', 'YYYY-MM-DD HH24:MI:SS') HALT HALT on FPS.FIELD_A = HALT.ID AS OF TIMESTAMP TO_TIMESTAMP('2021-01-26 14:48:23', 'YYYY-MM-DD HH24:MI:SS') 
where FPS.FP_ID = ?

final QFps fps = QFps.fps;
final QHalt halt = QHalt.halt;
final SQLQuery<Tuple> query = queryFactory.select(fps.fpId, fps.fieldA, fps.fieldB, halt.fieldC)
                                          .from(fps)
                                          .addFlag(Position.BEFORE_FILTER, getFlashbackString())
                                          .leftJoin(halt).on(fps.fieldA.eq(halt.id))
                                          .addJoinFlag(getFlashbackString(), Position.BEFORE_CONDITION)
                                          .where(fps.fpId.eq(fpId));

final String sql = query.getSQL().getSQL();
log.info("sql={}", sql);

return query.fetch();

select FPS.FP_ID, FPS.FIELD_A, FPS.FIELD_B, HALT.FIELD_C
from FPS FPS  
join HALT HALT  AS OF TIMESTAMP TO_TIMESTAMP('2021-01-26 14:48:23', 'YYYY-MM-DD HH24:MI:SS') on FPS.FIELD_A = HALT.ID AS OF TIMESTAMP TO_TIMESTAMP('2021-01-26 14:48:23', 'YYYY-MM-DD HH24:MI:SS') 
where FPS.FP_ID = ?

  private static final String ADDITIONAL_FLASHBACK_EXPRESSION = "{0} AS OF TIMESTAMP TO_TIMESTAMP({1}, 'YYYY-MM-DD HH24:MI:SS') {2}";
  private static final DateTimeFormatter FLASHBACK_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

public <T> Expression<String> getFlashbackExpresion(final Timestamp flashbackTimestamp, final RelationalPathBase<T> table) {
    if (flashbackTimestamp == null) {
      return Expressions.stringTemplate(WITHOUT_FLASHBACK_EXPRESSION, table, table);
    }
    
    final LocalDateTime timestamp = LocalDateTime.ofInstant(flashbackTimestamp.toInstant(), ZoneOffset.ofHours(0));
    final String timestampString = timestamp.format(FLASHBACK_FORMATTER);
    
    return Expressions.stringTemplate(ADDITIONAL_FLASHBACK_EXPRESSION, table, timestampString, table);
  }

final Timestamp flashbackTimestamp = getFlashbackTimestamp();

final QFps fps = QFps.fps;
final QHalt halt = QHalt.halt;

final fpsFlashback = getFlashbackExpresion(flashbackTimestamp, fps);
final haltFlashback = getFlashbackExpresion(flashbackTimestamp, halt);

final SQLQuery<Tuple> query = queryFactory.select(fps.fpId, fps.fieldA, fps.fieldB, halt.fieldC);

query.from(fpsFlashback)
     .getMetadata().addJoin(JointType.LEFTJOIN, haltFlashback);
query.on(fps.fieldA.eq(halt.id))
     .where(fps.fpId.eq(fpId));

final String sql = query.getSQL().getSQL();
log.info("sql={}", sql);

return query.fetch();

select FPS.FP_ID, FPS.FIELD_A, FPS.FIELD_B, HALT.FIELD_C
from FPS AS OF TIMESTAMP TO_TIMESTAMP('2021-01-26 14:48:23', 'YYYY-MM-DD HH24:MI:SS') FPS
join HALT AS OF TIMESTAMP TO_TIMESTAMP('2021-01-26 14:48:23', 'YYYY-MM-DD HH24:MI:SS') HALT on FPS.FIELD_A = HALT.ID
where FPS.FP_ID = ?