标签: self-reference

我试图在sqlalchemy中创建一个自引用的多对多关系(这意味着Line可以有许多父行和许多子行),如下所示:

Base = declarative_base()

class Association(Base):
 __tablename__ = 'association'

 prev_id = Column(Integer, ForeignKey('line.id'), primary_key=True)                            
 next_id = Column(Integer, ForeignKey('line.id'), primary_key=True)


class Line(Base):
 __tablename__ = 'line'

 id = Column(Integer, primary_key = True)
 text = Column(Text)
 condition = Column(Text)
 action = Column(Text)

 next_lines = relationship(Association, backref="prev_lines")



class Root(Base):
 __tablename__ = 'root'

 name = Column(String, primary_key = True)
 start_line_id = Column(Integer, ForeignKey('line.id'))

 start_line = relationship('Line')

但是我收到以下错误:sqlalchemy.exc.ArgumentError:无法确定关系Line.next_lines上的父/子表之间的连接条件.指定'primaryjoin'表达式.如果存在'secondary',则还需要'secondaryjoin'.

你知道我怎么能解决这个问题吗？

我知道可以用Python这样的语言创建一个自引用列表:

>>> my_list = [1,2]
>>> my_list.append(my_list)
>>> print my_list
[1,2,[...]]
>>> print my_list[0]
1
>>> print my_list[2]
[1,2,[...]]

什么算法从自引用列表中受益？我想不出一个.

谢谢.

所以我在python中遇到了一些非常奇怪的东西.我尝试将列表的引用添加到自身.代码可能有助于证明我所说的比我能表达的更好.我正在使用IDLE编辑器(交互模式).

>>>l=[1,2,3]
>>>l.append(l)
>>>print(l)
[1,2,3,[...]]
>>>del l[:-1]
>>>print(l)
[[...]]

到目前为止,输出是预期的.但是当我这样做的时候.

y=l[:]
print(y)

对我而言,似乎输出应该是

[[...]]

但它是

[[[...]]]

显然,它不是创建列表的副本,而是在y中引用列表.

y [0]是l返回True.我似乎无法找到一个很好的解释.有任何想法吗？

对于C中typedef的a struct,我不能这样做:

typedef struct {
    unsigned id;
    node_t *left;
    node_t *right;
} node_t;

因为node_t直到它被定义才知道,所以它不能用在它自己的定义中.有点像Catch-22.但是,我可以使用此变通方法来创建所需的自引用类型:

typedef struct node_s node_t;
struct node_s {
    unsigned id;
    node_t *left;
    node_t *right;
};

同样,我想对引用自身的C++容器做类似的事情:

typedef pair<unsigned, pair<node_t *, node_t * > > node_t;

但是当然,编译器抱怨它node_t在定义之前从未听说过node_t,就像struct typedef上面所说的那样.

那么有没有像这样的解决方法struct？还是一些更好的方法来做到这一点？(不,我不想使用void指针.)

在下表中输入值时,如何在SQL中对同一表的列强制执行外键约束:

员工:

• empid数字,
• 经理号码(必须是现有员工)

以下是合法的吗？

template< typename T >
struct tree_node
   {
   T t;
   std::vector<tree_node> children;
   };

对这篇文章的评论似乎表明事实并非如此.

编辑:这不会打击我作为"未定义的行为"类型的场景.预期的语义是明确的.如果它是不完整类型的无效用法,那么它应该是编译时错误.

在我的测试中,这似乎工作正常(我使用了GCC和Clang - 两者都有-Wall -Werror -std=c++11).

语言定义中是否有某些东西(在C++ 17之前)直接或间接地将其指定为未定义的行为,或者它只是指定不足？

请记住,这在结构上非常类似于以下内容:

typedef int T;
struct tree_node;

struct tree_node
   {
   T t;
   tree_node * children;
   }

我有一个名为Books的实体,可以列出更多名为RelatedBooks的书籍.

缩写的Book实体看起来像这样:

public class Book
{
      public virtual long Id { get; private set; }

      public virtual IList<Book> RelatedBooks { get; set; }
}

以下是此关系的映射

HasManyToMany(x => x.RelatedBooks)
                .ParentKeyColumn("BookId")
                .ChildKeyColumn("RelatedBookId")
                .Table("RelatedBooks")
                .Cascade.SaveUpdate();

以下是在RelatedBooks表中生成的数据示例:

BookId     RelatedBookId
1          2
1          3

当我尝试删除一本书时会出现问题.如果我删除ID为1的书,一切正常,并且RelatedBooks表删除了两个相应的记录.但是,如果我尝试删除ID为3的书,我会收到错误"DELETE语句与REFERENCE约束冲突"FK5B54405174BAB605".冲突发生在数据库"Test",表"dbo.RelatedBooks",列'RelatedBookId "".

基本上发生的事情是Book无法删除,因为RelatedBooks表中的RelatedBookId为3的记录永远不会被删除.

删除图书时如何删除该记录？

编辑

将Cascade从SaveUpdate()更改为All()后,如果我尝试删除ID为3的Book,同样的问题仍然存在.同时将Cascade设置为All(),如果删除Book with和ID为1,然后删除所有3本书(ID:1,2和3),这样也无法正常工作.

查看当我删除I​​D为3的Book时调用Book.Delete()方法时执行的SQL,看起来SELECT语句看起来是错误的列(我假设这意味着SQL DELETE语句会犯同样的错误,因此永远不会删除该记录).这是RelatedBook的SQL

SELECT relatedboo0_.BookId as BookId3_
       , relatedboo0_.RelatedBookId as RelatedB2_3_ 
       , book1_.Id as Id14_0_ 

FROM RelatedBooks relatedboo0_ 
     left outer join [Book] book1_ on relatedboo0_.RelatedBookId=book1_.Id 

WHERE relatedboo0_.BookId=3

对于特定情况,WHERE语句应该看起来像这样:

WHERE relatedboo0_.RelatedBookId = 3

解

以下是我必须要做的就是让它适用于所有情况

制图: …

我开始使用EF Code First和MVC,我有点难过.我有以下数据库结构(很抱歉,我不允许发布图片):

表 - 产品
表 - 相关产品

Products.ProductID上的1-Many - > RelatedProducts.ProductID
1 - Products.ProductID上的很多 - > RelatedProducts.RelatedProductID

基本上我有一个产品,可以有一系列与之相关的产品.它们保存在RelatedProducts表中,其中包含ProductID和相关产品的ProductID定义的关系,我将其命名为RelatedProductID.在我的代码中,我生成了以下类:

public class MyDBEntities : DbContext
{
    public DbSet<Product> Products { get; set; }
    public DbSet<RelatedProduct> RelatedProducts { get; set; }
}

public class Product
{
    public Guid ProductID { get; set; }
    public string Name { get; set; }
    public string Heading { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; } …

描述可能有点困难.但是,我会试试;)

遵循流畅的样式,类的方法通常返回类实例本身(this).

public class A {

    public A doSomething() {

        // do something here

        return this;
    }

}

当扩展这样一个流畅的样式类时,可以通过泛型类型在第一个继承步骤中相当容易地执行此操作,并将返回类型转换为超类中的此泛型类型.

public class A<T extends A<T>> {

    public T doSomething() {

        // do something here

        return (T) this;
    }

}

public class B extends A<B> {

    // an extended class of class A

}

但是,当在这个扩展类上做另一个继承步骤时,我在尝试定义方法的泛型返回类型(在上层类中)和类描述本身时遇到了麻烦,例如,超级超级中的方法class不会返回extend类的类型,而是返回超类的类型.但是,我的意图是这些流畅的样式方法应该总是返回当前类的类型(而不是上层类).

那么可以通过利用泛型来定义解决方案吗？

PS:我知道,一个简单的解决方法可能会覆盖扩展类中的所有这些方法并将它们转换为当前类型.但是,我对更优雅的解决方案感兴趣;)

在我的C++应用程序中,我的应用程序execv()在fork()ed子进程中执行以使用相同的可执行文件来处理新子进程中的一些工作,这些进程具有与管道与父进程通信的不同参数.要获取自己的路径名,我在Linux端口上执行以下代码(我在Macintosh上有不同的代码):

  const size_t bufSize = PATH_MAX + 1;
  char dirNameBuffer[bufSize];
  // Read the symbolic link '/proc/self/exe'.
  const char *linkName = "/proc/self/exe";
  const int ret = int(readlink(linkName, dirNameBuffer, bufSize - 1));

但是,如果在可执行文件运行时,我将可执行文件替换为磁盘上二进制文件的更新版本,readlink()字符串结果为:"/usr/local/bin/myExecutable (deleted)"

据我所知,我的可执行文件已被替换为新的更新版本和原来的/proc/self/exe是现在换成,但是,当我去execv(),现在失败了errno2 - No such file or directory.由于额外的尾随" (deleted)"的结果.

我想要execv()使用旧的可执行文件为自己,或更新的可执行文件.我可以检测到以字符串结尾的字符串" (deleted)"并修改它以省略它并解析为更新的可执行文件,但这对我来说似乎很笨拙.

我怎样才能execv()在当前的可执行文件(或它的替代,如果这是更容易)一组新的参数,当原始的可执行已取代执行期间更新的一个？