如何使用JPA实现时态表？
我想知道如何使用EclipseLink在JPA 2中实现temporal tables。时间上我指的是定义有效期的表。
我面临的一个问题是引用表不再对引用的表（时态表）具有外键约束，因为引用表的性质现在它们的主键包括有效期。
- 我如何映射我的实体的关系？
- 这是否意味着我的实体不再与那些有效时间实体建立关系？
- 现在，在某种服务或专门的DAO中手动执行初始化这些关系的责任吗？
我发现的唯一一个名为DAO Fusion的框架可以解决这个问题。
- 还有其他方法可以解决这个问题吗？
- 您能否提供有关此主题的示例或资源（带有时态数据库的JPA）？
这是一个数据模型及其类的虚构示例。它起初是一个简单的模型，不需要处理时间方面：
第一种情景：非时间模型
数据模型：
团队：
@Entity
public class Team implements Serializable {
private Long id;
private String name;
private Integer wins = 0;
private Integer losses = 0;
private Integer draws = 0;
private List<Player> players = new ArrayList<Player>();
public Team() {
}
public Team(String name) {
this.name = name;
}
@Id
@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQTEAMID")
@SequenceGenerator(name="SEQTEAMID", sequenceName="SEQTEAMID", allocationSize=1)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(unique=true, nullable=false)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getWins() {
return wins;
}
public void setWins(Integer wins) {
this.wins = wins;
}
public Integer getLosses() {
return losses;
}
public void setLosses(Integer losses) {
this.losses = losses;
}
public Integer getDraws() {
return draws;
}
public void setDraws(Integer draws) {
this.draws = draws;
}
@OneToMany(mappedBy="team", cascade=CascadeType.ALL)
public List<Player> getPlayers() {
return players;
}
public void setPlayers(List<Player> players) {
this.players = players;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Team other = (Team) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
播放器：
@Entity
@Table(uniqueConstraints={@UniqueConstraint(columnNames={"team_id","number"})})
public class Player implements Serializable {
private Long id;
private Team team;
private Integer number;
private String name;
public Player() {
}
public Player(Team team, Integer number) {
this.team = team;
this.number = number;
}
@Id
@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQPLAYERID")
@SequenceGenerator(name="SEQPLAYERID", sequenceName="SEQPLAYERID", allocationSize=1)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@ManyToOne
@JoinColumn(nullable=false)
public Team getTeam() {
return team;
}
public void setTeam(Team team) {
this.team = team;
}
@Column(nullable=false)
public Integer getNumber() {
return number;
}
public void setNumber(Integer number) {
this.number = number;
}
@Column(unique=true, nullable=false)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((number == null) ? 0 : number.hashCode());
result = prime * result + ((team == null) ? 0 : team.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Player other = (Player) obj;
if (number == null) {
if (other.number != null)
return false;
} else if (!number.equals(other.number))
return false;
if (team == null) {
if (other.team != null)
return false;
} else if (!team.equals(other.team))
return false;
return true;
}
}
测试类：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"/META-INF/application-context-root.xml"})
@Transactional
public class TestingDao {
@PersistenceContext
private EntityManager entityManager;
private Team team;
@Before
public void setUp() {
team = new Team();
team.setName("The Goods");
team.setLosses(0);
team.setWins(0);
team.setDraws(0);
Player player = new Player();
player.setTeam(team);
player.setNumber(1);
player.setName("Alfredo");
team.getPlayers().add(player);
player = new Player();
player.setTeam(team);
player.setNumber(2);
player.setName("Jorge");
team.getPlayers().add(player);
entityManager.persist(team);
entityManager.flush();
}
@Test
public void testPersistence() {
String strQuery = "select t from Team t where t.name = :name";
TypedQuery<Team> query = entityManager.createQuery(strQuery, Team.class);
query.setParameter("name", team.getName());
Team persistedTeam = query.getSingleResult();
assertEquals(2, persistedTeam.getPlayers().size());
//Change the player number
Player p = null;
for (Player player : persistedTeam.getPlayers()) {
if (player.getName().equals("Alfredo")) {
p = player;
break;
}
}
p.setNumber(10);
}
}
现在要求您保留团队和玩家在特定时间点的历史记录，因此您需要为每个想要跟踪的表添加一段时间。所以让我们添加这些时间列。我们将从Player开始。
第二种情景：时间模型
数据模型：
正如您所看到的，我们必须删除主键并定义另一个包含日期（句点）的主键。此外，我们不得不放弃唯一约束，因为现在它们可以在表格中重复出现。现在，该表可以包含当前条目以及历史记录。
如果我们必须使Team临时，事情变得非常难看，在这种情况下，我们需要删除Player表对Team的外键约束。问题是如何在Java和JPA中对其进行建模。
请注意，ID是代理键。但现在代理键必须包含日期，因为如果它们不包含，则不允许存储同一实体的多个“版本”（在时间线期间）。
4 个答案:
答案 0 :(得分：7)
我对这个话题非常感兴趣。我在开发使用这些模式的应用程序方面已经工作了几年，我们的案例来自德国文凭论文。
我不知道＆＃34; DAO Fusion＆＃34;框架，它们提供有趣的信息和链接，感谢您提供此信息。特别是pattern page和aspects page很棒！
您的问题：不，我不能指出其他网站，示例或框架。我担心您必须使用DAO Fusion框架或自己实现此功能。您必须区分您真正需要的功能。用＆＃34; DAO Fusion＆＃34;来说话框架：你需要两个＆＃34;有效的时间＆＃34;和＆＃34;记录时间＆＃34;？记录应用于数据库的更改时的时间状态（通常用于审计问题），在现实生活中发生更改时的有效时态或在现实生活中有效（由应用程序使用），这可能与记录时间不同。在大多数情况下，一个维度就足够了，不需要第二个维度。
无论如何，时间功能会对您的数据库产生影响。正如您所说：＆＃34;现在他们的主键包括有效期＆＃34; 。那么如何模拟实体的身份？我更喜欢使用surrogate keys。在这种情况下，这意味着：
- 实体的一个ID
- 数据库中对象的一个id（行）
- 时间列
表的主键是对象ID。每个实体在表中具有一个或多个（1-n）条目，由对象id标识。表之间的链接基于实体ID。由于时间条目会增加数据量，因此标准关系不起作用。标准的1-n关系可能会成为x * 1-y * n关系。
你是如何解决这个问题的？标准方法是引入映射表，但这不是一种自然的方法。仅仅为了编辑一个表（例如，发生住宅更改），您还必须更新/插入映射表，这对每个程序员来说都很奇怪。
另一种方法是不使用映射表。在这种情况下，您不能使用参照完整性和外键，每个表都是隔离的，从一个表到其他表的链接必须手动实现，而不是JPA功能。
初始化数据库对象的功能应该在对象内（如在DAO Fusion框架中）。我不会把它放在服务中。如果您将它放入DAO或使用Active Record Pattern取决于您。
我知道我的回答并没有为你提供一个随时可用的＆＃34;框架。你处在一个非常复杂的领域，从我的经验资源到这种使用场景都很难找到。谢谢你的提问！但无论如何，我希望我帮助你完成你的设计。
在本回答中，您将找到参考书＆＃34;在SQL＆＃34;中开发面向时间的数据库应用程序，请参阅https://stackoverflow.com/a/800516/734687
更新：示例
- 问题：让我们说我有一个PERSON表，其中有一个代理键，这是一个名为＆＃34; id＆＃34;的字段。此时的每个引用表都将具有＆＃34; ID＆＃34;作为外键约束。如果我现在添加时间列，我必须将主键更改为＆＃34; id + from_date + to_date＆＃34;。在更改主键之前，我必须首先将每个引用表的每个外部约束都删除到此引用表（Person）。我对吗？我相信你对代理钥匙的意思。 ID是可以由序列生成的生成密钥。 Person表的业务键是SSN。
- 答案：不完全是。 SSN将是一个自然的关键，我不会用于objcet身份。另外＆＃34; id + from_date + to_date＆＃34;将是composite key，我也会避免。如果你查看example，你会有两张桌子，人和住所，我们的例子说我们与外国住宅有1-n的关系。 现在我们在每个表上添加时间字段。是的，我们放弃每个外键约束。 Person将获得2个ID，一个ID用于标识行（称为ROW_ID），一个ID用于标识该人本身（称为ENTIDY_ID），并带有该ID的索引。同样的人。当然你的方法也会起作用，但在这种情况下，你会有更改ROW_ID的操作（当你关闭时间间隔时），我会避免这种操作。
扩展使用上述假设（2表，1-n）实施的example：
-
显示数据库中所有条目的查询（包括所有有效性信息和记录 - 也包括技术信息）：
SELECT * FROM Person p, Residence r WHERE p.ENTITY_ID = r.FK_ENTITY_ID_PERSON // JOIN -
隐藏记录的查询 - 又称技术信息。这显示了实体的所有有效变更。
SELECT * FROM Person p, Residence r WHERE p.ENTITY_ID = r.FK_ENTITY_ID_PERSON AND p.recordTo=[infinity] and r.recordTo=[infinity] // only current technical state -
显示实际值的查询。
SELECT * FROM Person p, Residence r WHERE p.ENTITY_ID = r.FK_ENTITY_ID_PERSON AND p.recordTo=[infinity] and r.recordTo=[infinity] AND p.validFrom <= [now] AND p.validTo > [now] AND // only current valid state person r.validFrom <= [now] AND r.validTo > [now] // only current valid state residence
如你所见，我从不使用ROW_ID。将[now]替换为时间戳，以便及时返回。
更新以反映您的更新
我建议使用以下数据模型：
介绍＆＃34; PlaysInTeam＆＃34;表：
- ID
- ID团队（团队的外键）
- ID播放器（播放器的外键）
- ValidFrom
- ValidTo
当您列出团队的玩家时，您必须查询关系有效的日期，并且必须在[ValdFrom，ValidTo]中
为了使团队成为时间，我有两种方法;
方法1： 介绍一个＆＃34; Season＆＃34;模拟季节有效性的表格
- ID
- 季节名称（例如2011年夏季）
- 来自（可能没有必要，因为每个人都知道什么时候这个季节）
- To（也许没必要，因为每个人都知道什么时候这个季节）
拆分团队表。您将拥有属于团队的字段，这些字段与时间无关（名称，地址，...）和与季节相关的时间字段（胜利，损失，......）。在那种情况下，我会使用Team和TeamInSeason。 PlaysInTeam可以链接到TeamInSeason而不是Team（必须考虑 - 我会让它指向团队）
TeamInSeason
- ID
- ID团队
- ID季节
- 运
- 损失
- ...
方法2： 不要明确地模仿季节。拆分团队表。您将拥有属于团队的字段，这些字段与时间无关（名称，地址，...）和时间相关的字段（胜利，损失，......）。在那种情况下，我会使用Team和TeamInterval。 TeamInterval会有＆＃34;来自＆＃34;和＆＃34;到＆＃34;为间隔。 PlaysInTeam可以链接到TeamInterval而不是Team（我会让它在Team上）
TeamInterval
- ID
- ID团队
- 从
- 要
- 运
- 损失
- ...
在这两种方法中：如果您不需要一个单独的团队表，没有时间相关字段，请不要拆分。
答案 1 :(得分：2)
不完全确定您的意思，但EclipseLink完全支持历史记录。您可以通过@DescriptorCustomizer在ClassDescriptor上启用HistoryPolicy。
答案 2 :(得分：1)
似乎您无法使用JPA，因为它假定表名和整个架构是静态的。
最好的选择可能是通过JDBC（例如使用DAO模式）
如果性能是问题，除非我们谈论数以千万计的记录，否则我怀疑是否会动态创建类＆amp;编译它＆amp;然后加载它会更好。
另一种选择可能是使用视图（如果你必须使用JPA）可能以某种方式抽象表（映射@Entity（name =“myView”），那么你必须动态更新/替换视图，如创建或替换视图usernameView AS SELECT * FROM prefix_sessionId
例如，您可以写一个视图来说： if (EVENT_TYPE = 'crear_tabla' AND ObjectType = 'tabla ' && ObjectName starts with 'userName')
then CREATE OR REPLACE VIEW userNameView AS SELECT * FROM ObjectName //the generated table.
希望这会有所帮助（espero que te ayude）
答案 3 :(得分：1)
，通过BitemporalWrapper包裹该实体来实现在两个时间轴（有效期和记录间隔）中跟踪实体。
bitemporal reference documentation提供了一个由Order实体包装的常规BitemporalOrder实体的示例。 BitemporalOrder映射到一个单独的数据库表，其中包含有效和记录间隔的列，以及每个表行的Order（通过@ManyToOne）的外键引用。
文档还指出每个双时态包装器（例如BitemporalOrder）代表双时间记录链中的一个项目。因此，您需要一些包含双时间包装器集合的更高级实体，例如： Customer实体，其中包含@OneToMany Collection<BitemporalOrder> orders。
所以，如果你需要一个“逻辑子”实体（例如Order或Player）进行双点跟踪，以及它的“逻辑父”实体（例如Customer或{{ 1}}）要进行双点跟踪，你需要为两者提供双时间包装。您将拥有Team和BitemporalPlayer。 BitemporalTeam可以声明BitemporalTeam。但是如上所述，您需要一些更高级别的实体来包含@OneToMany Collection<BitemporalPlayer> players。对于
例如，您可以创建一个包含@OneToMany Collection<BitemporalTeam> teams集合的Game实体。
但是，如果您不需要记录间隔并且您只需要有效间隔（例如，不是双时间，而是对您的实体进行单时间跟踪），那么您最好的选择是推出自己的自定义实现。
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？