标签: orphan

在Hibernate参考书的第21章中,我有一个基本的一对多关系父/子.
级联仅从子级到父级(持久化级联仅因为我不想删除父项,如果我删除子级).
当我向父母添加一个孩子并保存孩子时,我有一个TransientObjectException ...

@Entity
public class Parent implements Serializable {

  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private Long id;

  @OneToMany(mappedBy = "parent", orphanRemoval = true)
  private List<Child> childs;

  public List<Child> getChilds() {
    return childs;
  }

  public void setChilds(List<Child> childs) {
    this.childs = childs;
  }

  public void addChild(Child child) {
    if (childs == null) childs = new ArrayList<Child>();
    if (childs.add(child)) child.setParent(this);
  }

  public Long getId() {
    return id;
  }

  public void setId(Long id) {
    this.id = id;
  }
}

@Entity
public class …

我继承了一个包含数千个选择器的大型样式表,我确信其中很多都是不必要的,并且实际上并不匹配网站上的元素.为了优化,我想删除那些孤立的选择器/规则.

是否有任何工具可以让我将CSS与整个网站进行比较,以确定哪些选择器是必需的,哪些不是？

该站点具有AJAX组件,因此编写curl/wget脚本来遍历站点然后循环遍历每个选择器并且grep进行匹配也不是特别可行(即使这会很有趣......)

欢迎所有建议.

谢谢,JD

我正在使用Symfony2和Doctrine2来构建后端API.此API将接收数据库中CRUD的对象图.

我正在使用伟大的JMSSerializer包来将对象的json编码图反序列化为分离的已分离的图表,然后我想简单地将该图直接合并到数据库中.

在我的代码中,我有2个实体:父和子.OneToMany(cascade={"all"}, orphanRemoval=true)在Parent中定义了一种关系.

在我的数据库中,我有一个id为1的Parent行,它有3个id为1,2,3的子节点.

我想写一些类似的东西(我这里没有使用反序列化来简化示例):

$parent = new Parent(); $parent->id = 1  // detached entity
$existing_child = new Child(); $child->id = 2 // detached entity
$new_child = new Child(); // new entity
$parent->addChild($existing_child);
$parent->addChild($new_child);

$em = $this->getDoctrine()
    ->getEntityManager();
$em->merge($parent);

$em->flush();

这样做,我的新孩子创建得很好,现有的孩子会更新,但旧孩子(1和3)不会被删除.

如果我错过了什么,有人可以帮助我吗？

在python中,我有一个父进程,它生成了一些子进程.我遇到了一种情况,由于未处理的异常,父进程正在死亡,而子进程处于孤立状态.如何让孩子进程认识到他们失去了父母？

我尝试了一些代码,将子进程挂钩到每个可用信号,但没有一个被触发.从理论上讲,我可以在父进程周围进行一次巨大的尝试,以确保它至少可以给孩子们带来一个sigterm,但这样做不够优雅而且不是万无一失的.如何防止孤立进程？

我有一个使用线程的程序.当我的程序关闭时,我的线程仍在运行,这是正常的.我想知道我的线程如何检测到主程序被终止; 仅靠它自己.我该怎么办？

我的线程处于无限循环中并处理队列中的许多对象.我无法将我的线程定义为守护进程,否则我可能会在主程序结束时丢失一些数据.我不希望我的主程序在关闭时设置一个布尔值.

重要提示:如果您正在阅读本文,请考虑深入讨论这篇文章.

这是一种很常见的做法/情况/要求,父母的子女可能会迁移到另一方父母.如果orphanRemoval设置true在这种关系的反面,会发生什么？

以一个例子为例,任何简单的一对多关系如下.

反面(部门):

@OneToMany(mappedBy = "department", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval = true)
private List<Employee> employeeList = new ArrayList<Employee>(0);

拥有方(员工):

@JoinColumn(name = "department_id", referencedColumnName = "department_id")
@ManyToOne(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH, CascadeType.DETACH})
private Department department;

合并如下所示的操作/操作(其中department是客户端提供的分离实体),

Employee employee = entityManager.find(Employee.class, 1L);
Department newDepartment = entityManager.contains(department) ? department : entityManager.merge(department);

if (!newDepartment.equals(employee.getDepartment())) {
    employee.getDepartment().getEmployeeList().remove(employee);
    // Since orphanRemoval is set to true, 
    // this should cause a …

我对守护进程和孤儿进程感到困惑。从我学到的：

守护进程：“这些是在后台运行的特殊进程。它们是与系统相关的进程，没有关联的终端。这些进程以 root 权限运行，通常为进程提供服务。通常父进程将终止，因此子进程将成为守护进程进程，因为它不会有任何终端。对于守护进程，init 进程将成为父进程”

孤立进程：“当父进程在子进程终止之前被杀死时，该进程将成为孤立进程。在这种情况下，子进程成为孤立进程，然后由 init 进程接管。”

孤儿进程是守护进程，反之亦然？如果不是，它们之间的基本区别是什么？

我有两个模型 - 照片和标签 - 通过ManyToManyField连接.

class Photo(models.Model):
    tags = models.ManyToManyField(Tag)

class Tag(models.Model):
    lang = models.CharField(max_length=2)
    name_es = models.CharField(max_length=40)
    name_en = models.CharField(max_length=40)

每隔一段时间,我们就会获得孤立的标签,任何照片都不会引用这些标签.是否有一种删除这些标签的有效方法？我知道这个答案: Django:删除M2M孤儿条目？

我们的解决方案目前看起来像这样:

for tag in Tag.objects.all():
    if not tag.photo_set.select_related(): tag.delete()

然而,随着数据库,该脚本的运行变得令人不安的高:-P有正从标签表中的所有标签ID的列表的有效方式,然后从所有的标签ID的列表许多一对多表创建一个交集列表？

我正在和一个朋友一起在github托管的一个小项目上工作。

这个项目的特别之处在于我们想使用许多孤立的分支。但是看来我们不能为这样的分支拉请求！

Github抱怨分支机构没有共同的历史（当然是正确的）。

因此问题是：如何将一个完整的孤立分支从一个存储库“复制/拉出”到另一个存储库？

我正在尝试使用LEFT JOINS找到不同的孤立的menu_item记录,然后检查NULL值.

下面的查询返回的结果实际上不是孤儿.mitem_id是menu_item表的主键和price_info表的外键.pinfo_id是price_info表和外键orderdetails表的主键.

SELECT DISTINCT mi.mitem_id, descr 
FROM menu_item mi 
    LEFT JOIN price_info pi ON pi.menu_item = mi.mitem_id 
    LEFT JOIN orderdetails od ON od.price_info = pi.pinfo_id 
WHERE od.detail_id IS NULL;

返回的记录之一如下所示:

+----------+------------------+
| mitem_id | descr            |
+----------+------------------+
|      926 | Alameda Pale Ale |
+----------+------------------+

我怎么知道它不是一个孤儿是因为当我运行查询时:

SELECT od.detail_id 
FROM orderdetails od 
   INNER JOIN price_info pi ON pi.pinfo_id = od.price_info 
    INNER JOIN menu_item mi ON mi.mitem_id = pi.menu_item 
WHERE mi.mitem_id = 926;

它返回一组记录:

+-----------+
| detail_id |
+-----------+
|    142830 …