标签: many-to-many

Artist和之间存在着多对多的关系ArtistType.我可以轻松添加ArtistType如下的艺术家

foreach (var artistType in this._db.ArtistTypes
    .Where(artistType => vm.SelectedIds.Contains(artistType.ArtistTypeID)))
{
    artist.ArtistTypes.Add(artistType);
}

_db.ArtistDetails.Add(artist);
_db.SaveChanges();

这将使用正确的映射更新多对多关联表.但是,当我尝试从表中删除任何项目时,我没有得到任何错误,但它没有从表中删除它？

foreach (var artistType in this._db.ArtistTypes
    .Where(at => vm.SelectedIds.Contains(at.ArtistTypeID)))
{
    artistDetail.ArtistTypes.Remove(artistType);
}

this._db.Entry(artistDetail).State = EntityState.Modified;
this._db.SaveChanges();

我错过了什么？

我试图查询匹配给定标签集的所有对象.

基本上我希望用户能够添加越来越多的标签来过滤或"缩小"他们的搜索结果,有点像newegg.com.

我的表结构是一个对象表,一个标签表和一个MANY:MANY关系表ObjectsTags.所以我有一个像这样的JOIN查询:

SELECT * FROM Objects
LEFT OUTER JOIN ObjectsTags ON (Objects.id=ObjectsTags.object_id)
LEFT OUTER JOIN Tags ON (Tags.id=ObjectsTags.tag_id)

我尝试使用IN子句/条件,如下所示:

SELECT * FROM Objects
LEFT OUTER JOIN ObjectsTags ON (Objects.id=ObjectsTags.object_id)
LEFT OUTER JOIN Tags ON (Tags.id=ObjectsTags.tag_id)
WHERE Tags.name IN ('tag1','tag2')
GROUP BY Objects.id

但我了解到这会模拟一系列OR,因此您在查询中添加的标签越多,您获得的结果就越多,而不是像我希望的那样缩小结果集.

我也试过做多个LIKE WHERE条件,ANDed一起:

SELECT * FROM Objects
LEFT OUTER JOIN ObjectsTags ON (Objects.id=ObjectsTags.object_id)
LEFT OUTER JOIN Tags ON (Tags.id=ObjectsTags.tag_id)
WHERE Tags.name LIKE 'tag1' 
AND Tags.name LIKE 'tag2'
GROUP BY Objects.id

但是这不会返回结果,因为当结果组合在一起时,OUTER JOINed Tags.name列只包含'tag1',而不是'tag2'.'tag2'匹配的结果行​​由GROUPing"隐藏".

如何匹配所有标签以获得我所追求的"缩小"或"向下钻取"效果？谢谢.

我在尝试绘制多对多关系时遇到了问题,其中关系的两侧都引用了同一个实体.我正在使用Fluent NHibernate和NH3.1.

基本上,情况是这样的 - 我有一个类别,可以有多个父母.因此,一个类别有多个其他类别作为父类,以及多个其他类别作为其子类.

HasManyToMany(x => x.ParentCategories).AsBag().Table("parentcategorychildren").ParentKeyColumn("ChildID").ChildKeyColumn("ParentID").Cascade.SaveUpdate();
HasManyToMany(x => x.ChildrenCategories).AsBag().Table("parentcategorychildren").ParentKeyColumn("ParentID").ChildKeyColumn("ChildID").Inverse();

但是,当我尝试构建工厂时,我收到以下错误:

Category.ChildrenCategories与Category.ChildrenCategories的关系在双方都指定了Inverse.从关系的一侧移除反向.

我发现奇怪的是为什么它将Category.ChildrenCategories提到Category.ChildrenCategories,而不是ParentCategories？

任何帮助将不胜感激 !

我刚刚为此创造了一笔赏金,因为这对我来说非常重要.拜托,我对"你不能这样做"作为答案不感兴趣.

我有两个实体,我在EF 5 Code First中创建了一个相当标准的多对多关系.这些是Service和ServiceItem.Service实体包含ServiceItems的集合,ServiceItem包含Services集合.我可以创建,更改和保存数据到任一实体基本属性,没有任何问题.当我尝试将ServiceItem添加到服务或服务到ServiceItem时,它似乎工作,但没有保存任何内容.我已经验证了所有正确的数据库表都已创建,包括带有交叉键的ServiceItemService表.添加项目时,数据库ServiceItemService表未获取任何条目.没有错误,其他一切似乎都很完美.

我有点难过,可以使用一些帮助.以下是课程.

服务类;

public class Service
{
    //Default constructor
    public Service()
    {
        //Defaults
        IsActive = true;
        ServicePeriod = ServicePeriodType.Monthly;
        ServicePeriodDays = 0;

        ServiceItems = new Collection<ServiceItem>();
    }

    public int ServiceID { get; set; }
    public string Title { get; set; }
    public string Description { get; set; }
    public ICollection<ServiceItem> ServiceItems { get; set; }
    public string TermsOfService { get; set; }
    public ServicePeriodType ServicePeriod { get; set; }
    public int ServicePeriodDays { get; set; }
    public …

我想为我的带有NoSQL数据库的node.js应用程序实现分类结构(地理术语).我有一个与MySQL类似的分类结构,但现在是时候向前推进并学习新东西,所以我决定尝试不同的方法并使用NoSQL(面向文档)来测试我的测试应用程序.分类结构很简单 - 有五个不同的级别:国家(即英国)→地区(英格兰)→县(默西塞德郡)→城市/城镇/村庄(利物浦)→城市的一部分(Toxteth).

显而易见的选择是使用树木结构,但魔鬼在细节 - 历史上一些城市和城镇属于其他县.这个想法是用那些术语来标记出生在某些城市或城镇的人,然后用地理标记过滤它们,所以我必须尊重利物浦或曼彻斯特(以及其他人)在某些人出生时属于兰开夏郡的事实. .否则,任何用户使用我的地理过滤器获得的结果都将是错误的.

例如:约翰·多伊于1957年出生于布莱克本(兰开夏郡).保罗·布朗1960年出生于利物浦(兰开夏郡,现为默西塞德郡).Georgia Doe(nee Jones)5年后出生在威勒尔(柴郡,现在的默西塞德郡).他们的儿子林戈于1982年出生于利物浦(默西塞德郡).

约翰是兰开斯特出生的,保罗是兰开斯特和梅西大学,格鲁吉亚同时来自柴郡和默西塞德郡,林戈来自默西塞德郡.所以当我按县搜索时,应该对它们进行相应的分类.但是,随着国家现代结构的简单一对多结构,他们永远不会被过滤掉.

如何使用NoSQL(首先是面向文档的)解决方案来实现集合的复杂性？我用Google搜索并对堆栈进行了一些研究*但仍然不知道下一步该做什么.在我看来,有几种可能的解决方法:

1. 使用类似SQL的数据结构:

   {
       {'name': 'United Kingdom', 'unique_id': 1},
       {'name': 'England', 'unique_id': 2, 'parents': [1]},
       {'name': 'Merseyside', 'unique_id': 3, 'parents': [2]},
       {'name': 'Lancashire', 'unique_id': 4, 'parents': [2]},
       {'name': 'Liverpool', 'unique_id': 5, 'parents': [3, 4]},
   }
   

   Run Code Online (Sandbox Code Playgroud)

2. 使用树结构和一些引用:

   {    
       {'name': 'United Kingdom', 'unique_id': 1
           {'name': 'England', 'unique_id': 2]
               {'name': 'Merseyside', 'unique_id': 3]
                   {'name': 'Liverpool', 'unique_id': 5, 'alternate_parents': [4]},
               },
               {'name': 'Lancashire', 'unique_id': 4},
           },
       },
   }
   

   Run Code Online (Sandbox Code Playgroud)

3. 使用没有引用的树结构(一对多)并手动将"alternate parent"标记添加到文档中:

   {    
       {'name': …

   Run Code Online (Sandbox Code Playgroud)

我的员工和团队表之间有很多关系.我已经创建了数据透视表,并且所有工作都正常.但是,我在employees表上有一个sortOrder列,用于确定它们显示的顺序.sortOrder列中值为1的员工应该是第一个,值2应该是第二个,依此类推.(如果按降序排序,则向后)sortOrder列是允许空值的整数列.

我已经设置了我的组模型来按排序列对员工进行排序,但我遇到了一个问题.始终首先显示空值.我已经尝试使用ISNULL和类似的SQL方法代替常用的"asc"或"desc",但我只得到一个错误.

这是我的Group模型中的代码:

class Group extends Eloquent {

public function employees()
    {
        return $this->belongsToMany("Employee")->orderBy('sortOrder', 'asc');
    }
}

这是我在控制器中用来访问我的模型的内容:

$board = Group::find(6)->employees;

Laravel最后排序NULL值的诀窍是什么？

有谁知道如何删除ADO.NET实体框架中的多对多关系,而无需加载所有数据？在我的情况下,我有一个实体主题有一个属性订阅,我需要删除一个订阅.代码myTopic.Subscriptions.Remove(...)有效,但我需要先加载所有订阅(例如myTopic.Subscriptions.Load()),我不想这样做,因为有很多(我的意思是很多)订阅

在像这样的典型的许多安排......

Movies       Actors       Movies_Actors
------       ------       -------------
movie_ID     actor_ID     FK_movie_ID
title        name         FK_actor_ID

...如何将关联表('Movies_Actors')索引以获得最佳读取速度？

我通常只在关联表中使用复合主键来完成此操作,如下所示:

CREATE TABLE Movies_Actors (
  FK_movie_ID INTEGER,
  FK_actor_ID INTEGER,
  PRIMARY KEY (FK_movie_ID, FK_actor_ID)
)

然而,这似乎是指数搜索时才有用处都 movie_ID和actor_ID(虽然我不是一个综合指数是否也适用于各个列确定).

由于两个"什么演员在电影X"和"有演员Ÿ一直处于什么样的电影"将是此表的通用查询,似乎应该对每一列单独的索引快速找到自己的角色和电影.复合索引是否有效地做到了这一点？如果没有,那么在这张桌子上使用复合索引似乎毫无意义.如果复合索引毫无意义,那么如何处理主键呢？候选键显然是两列的组合,但是如果得到的复合索引是无意义的(它一定不是？),这似乎是浪费.

此外,这个环节增加了一些困惑,并表示,它甚至可能是真正有用的指定2个综合指数...他们为一体(FK_movie_ID, FK_actor_ID),另一个反向的(FK_actor_ID, FK_movie_ID),与选择哪种是主键(因而通常聚集并且'只是'一个独特的复合索引,基于更多的查询方向.

什么是真实的故事？复合索引是否自动有效地索引每列以便在一个或另一个上进行搜索？应的最佳(在读出速度,而不是尺寸)关联表具有在每个方向上的复合指数和每列一个？什么是幕后机制？

编辑:我发现这个相关的问题,由于某种原因,我没有在发布之前找到... 如何正确索引MySQL中的多对多连接的链接表？

我在symfony中创建了2个实体:多对多关系中的用户和角色.这意味着每个用户都可以拥有更多角色,并且可以为许多用户设置角色.

用户类:

  /**
   * @ORM\Entity
   * @ORM\Table(name="JEP_User")
   * @ORM\Entity(repositoryClass="Chrchel\JepBundle\Repository\UserRepository")
   */
class User implements AdvancedUserInterface {

/**
 * @ORM\Id()
 * @ORM\Column(name="id",type="integer")
 * @ORM\GeneratedValue(strategy="AUTO")
 */
private $id;

/**
 * @ORM\Column(name="username",type="string",length=100,unique=true)
 */
private $username;

 /**
 * @ORM\ManyToMany(targetEntity="Role", inversedBy="users")
 *
 */
protected $roles;

//....
}

角色类:

/**
 * @ORM\Table(name="JEP_Role")
 * @ORM\Entity()
 */
 class Role implements RoleInterface {

/**
 * @ORM\Column(name="id", type="integer")
 * @ORM\Id()
 * @ORM\GeneratedValue(strategy="AUTO")
 */
protected $id;

  /** @ORM\Column(name="name", type="string", length=30) */
protected $name;

 /** @ORM\Column(name="role", type="string", length=20, unique=true) */
protected $role;

 /** …

我尝试在EF中进行测试,创建多对多的关系,因为我总是将One映射到One或One to Many,我已经在互联网上试了一个例子,这个例子适用于插入寄存器,但我无法读取寄存器

这是我的课程,我不知道是什么HashSet,我在网站上得到了这个代码

public class Person
{
    public int PersonId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public ICollection<Course> CoursesAttending { get; set; }

    public Person()
    {
        CoursesAttending = new HashSet<Course>();
    }
}

public class Course
{
    public int CourseId { get; set; }
    public string Title { get; set; }

    public ICollection<Person> Students { get; set; }

    public Course()
    {
        Students = new HashSet<Person>();
    } …