1

使用persistence.js，我有两个实体（Foo，Bar）形成多对多关系（N：M）。到目前为止，我只能让它添加许多“在一个方向上”，即 Foo 的一个实例可以添加许多 Bars，但是在这种关系中使用的任何 Bar 实例都不能反过来有许多 Foos。但是任何新的 Bar 实例都可以再次拥有许多 Foo。是否有可能，如果可以，如何“双向”添加许多实体？还是我必须像在 RDB 中那样使用联结表（N:M => 1:NM:1）？

var foo0, foo1, foo2, bar0, bar1, bar2

Foo = persistence.define('Foo', { val: 'TEXT' } )
Bar = persistence.define('Bar', { val: 'TEXT' } )
Foo.hasMany('bars', Bar, 'foo')
Bar.hasMany('foos', Foo, 'bar')

持久性.store.memory.config（持久性）；
持久性.schemaSync();

foo0 = new Foo( { val : 'foo0' } )
foo1 = new Foo( { val : 'foo1' } )
foo2 = new Foo( { val : 'foo2' } )
bar0 = new Bar( { val : 'bar0' } )
bar1 = new Bar({ val : 'bar1' } )
bar2 = new Bar( { val : 'bar2' } )
foo1.bars.add(bar0)
foo2.bars.add( bar0 ) // 注意：已经用上面的语句添加到 DB => 什么都不做
foo2.bars.add(bar1)
bar1.foos.add( foo0 )
bar2.foos.add( foo0 ) // 注意：已经用上面的语句添加到 DB => 什么都不做
bar2.foos.add( foo1 )

持久性.flush（函数（）{
    Foo.all().each( 函数 ( foo ) {
        foo.bars.list（函数（酒吧）{
            console.log("Foo" + foo.val +":")
            _.each(bars, function (bar) { console.log(bar.val) })
        })
    })

    Bar.all().each( 函数 ( bar ) {
        bar.foos.list( 函数 ( foos ) {
            console.log("Bar" + bar.val +":")
            _.each( foos, function ( foo ) { console.log( foo.val ) } )
        })
    })

    Bar.all().list( 函数 ( 酒吧 ) { foo0.bars = 酒吧 } )
    // => “未捕获的错误：尚不支持”
})
4

1 回答 1

2

1. inverseProperties 必须相同

Foo.hasMany('bars', Bar, 'foos')
Bar.hasMany('foos', Foo, 'bars')

2.每当一个实体添加另一个实体时，两者都插入数据库并自动交叉引用

  foo0 = new Foo { val: 'foo0: 根本没有使用' }
  foo1 = new Foo { val: 'foo1: has bar0, not added by others' }
  foo2 = new Foo { val: 'foo2: cross-add bar1' }
  foo3 = new Foo { val: 'foo3: 再次添加 bar1' }
  foo4 = new Foo { val: 'foo4: 添加多个' }
  foo5 = new Foo { val: 'foo5: 仅由 bar4 添加' }
  bar0 = 新酒吧 { val: 'bar0' }
  bar1 = new Bar { val: 'bar1: 交叉添加 foo2，在 foo3 中再次使用' }
  bar2 = new Bar { val: 'bar2: 由 foo4 #1 添加' }
  bar3 = new Bar { val: 'bar3: 由 foo4 #2 添加' }
  bar4 = new Bar { val: 'bar4: added by foo4 #3, has foo5'}

  foo1.bars.add bar0
  foo2.bars.add bar1
  foo3.bars.add bar1
  foo4.bars.add bar2
  foo4.bars.add bar3
  foo4.bars.add bar4

  bar1.foos.add foo2
  bar4.foos.add foo5

3. 但是在使用 addAll() 时情况并非如此，这需要通过持久性本身或由另一个实体添加

foo4b = new Foo { val : 'foo4b: 从 foo4 复制条形图' }
foo4.bars.list ( 酒吧 ) ->
        foo4b.bars.add所有酒吧
        persistence.add foo4b # 任选其一，
        # bar4.foos.add foo4b # 都可以
于 2013-03-03T22:35:03.947 回答