1

persistence.jsを使用すると、多対多の関係 (N:M) を形成する 2 つのエンティティ (Foo、Bar) があります。これまでのところ、多くの「一方向」を追加することしかできませんでした。つまり、Foo の 1 つのインスタンスは多くの Bar を追加できますが、この関係で使用される Bar のインスタンスは、多くの Foo を持つことはできません。しかし、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( 'バー', バー, 'foo' )
Bar.hasMany( 'foos', Foo, 'bar' )

persistence.store.memory.config(持続性);
persistence.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( バー 0 )
foo2.bars.add( bar0 ) // 注: 上記のステートメントで DB に既に追加されている => 何もしない
foo2.bars.add( バー 1 )
bar1.foos.add( foo0 )
bar2.foos.add( foo0 ) // 注: 上記のステートメントで DB に既に追加されている => 何もしない
bar2.foos.add( foo1 )

persistence.flush( 関数 () {
    Foo.all().each( 関数 ( foo ) {
        foo.bars.list( 関数 (バー) {
            console.log( "Foo " + foo.val + ": " )
            _.each( バー、関数 (バー) { console.log( バー.val ) } )
        } )
    } )

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

    Bar.all().list( 関数 ( バー ) { foo0.バー = バー } )
    // => "キャッチされていないエラー: まだサポートされていません"
} )
4

1 に答える 1

2

1. inverseProperties は同じでなければなりません

Foo.hasMany( 'バー', バー, 'フース' )
Bar.hasMany( 'foos', Foo, 'bars' )

2. あるエンティティが別のエンティティを追加するたびに、両方がデータベースに挿入され、自動的に相互参照されます

  foo0 = new Foo { val: 'foo0: まったく使用されていません' }
  foo1 = new Foo { val: 'foo1: bar0 を持っていますが、他では追加されていません' }
  foo2 = new Foo { val: 'foo2: 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: foo4 #3 によって追加され、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 # 1 つ選択し、
        # bar4.foos.add foo4b # どちらでも動作
于 2013-03-03T22:35:03.947 に答える