【问题标题】:MySQL query for mutual friends [duplicate]MySQL查询共同朋友[重复]
【发布时间】:2012-04-06 11:55:00
【问题描述】:

可能重复:
MYSQL select mutual friends

我有一张友谊表,友谊只存储在一行中。所以没有重复的条目。

id  Person1    Person2  status
1         1          2  friend
2         1          3  friend
3         2          3  friend
4         3          4  friend

什么 MySQL 查询(join、inner join)可以帮助我找到第 1 个人和第 3 个人之间的共同(共同)朋友?此示例中的输入是 {1,3},输出应该是 {2},因为 Person #2 是 bot #1 和 #3 的朋友。

【问题讨论】:

  • 你能在 sqlfiddle.com 上创建一个简单的架构吗
  • 不,我的意思是实时 shema,我可以在其中测试我的查询
  • 您是在执行Person1 < Person2 还是巧合?
  • @Simon,没有。 Person1 是第一个请求建立友谊的人。

标签: mysql sql mutual-friendship


【解决方案1】:

嗯,到目前为止,唯一可能有效的查询是 Simon 的……但这确实有点矫枉过正——如此复杂的令人讨厌的查询(2 个子查询和 2 个联合!)对于如此简单的事情,您需要悬赏? :-) 如果您有 1000 多个用户,那么查询将会非常慢 - 请记住,它是二次的,并且由于子查询中的联合,几乎不会使用任何索引!

我建议重新考虑设计并允许 2 个重复的行来建立友谊:

id  Person1    Person2  status
1         1          2  friend
2         2          1  friend
3         1          3  friend
4         3          1  friend

您可能认为这效率低下,但以下简化将允许将查询重写为简单连接:

select f1.Person2 as common_friend
from friends as f1 join friends as f2
    using (Person2)
where f1.Person1 = '$id1' and f2.Person1 = '$id2' 
    and f1.status = 'friend' and f2.status = 'friend'

这将是地狱般的快! (不要忘记为 Person1,2 添加索引。)I've advised a similar simplification (rewriting subqueries to joins) in other very nasty data structure and it has speeded up the query 从永恒到闪电战!

因此,可能看起来很大的开销(一个友谊 2 行)实际上是一个很大的优化 :-)

此外,它还将使诸如“查找 X 的所有朋友”之类的查询变得更加容易。并且不需要花费更多的赏金:-)

【讨论】:

  • 顺便说一句,这正是 OP 在 question that was linked as a duplicate of this one 中的操作方式
  • 你说得很好。这是非规范化的好处可能超过成本的一种情况。有了数据,您必须像我的答案中的查询一样跳过箍,以便在两个方向上测试朋友关系。
  • 好吧@Simon。但是这个解决方案无论如何都不是非规范化!这是表示对称二元关系的最自然和原生的方式,不违反任何NF。相反,省略“重复”而不是这个的原始解决方案应被视为一种优化尝试(尚未得到回报)。
  • 你说得对——我一直认为@george 的当前模式没有数据异常,尽管很难查询。然后我意识到,在当前模式中,没有什么可以阻止创建现有关系的反转并导致混乱的删除。我现在看到当前模式和您提议的模式都处于大致相同的标准化水平。
  • 4 年多过去了,您仍然可以为我节省很多时间。谢谢你,真的谢谢你。
【解决方案2】:

此查询的工作前提是友谊表中没有自我交友且没有重复,如果这些条件不满足使其工作所需的少量调整。

SELECT fid FROM 
(
    --FIRST PERSON (X) FRIENDLIST
    SELECT 
        (CASE WHEN Person1 = X THEN Person2 ELSE Person1 END) AS fid
    FROM Friendships WHERE (Person1 = X OR Person2 = X) AND status = "friend"
    UNION ALL --DO NOT REMOVE DUPLICATES WITH ALL JOIN
    --SECOND PERSON (Y) FRIENDLIST
    SELECT 
        (CASE WHEN Person1 = Y THEN Person2 ELSE Person1 END) AS fid
    FROM Friendships WHERE (Person1 = Y OR Person2 = Y) AND status = "friend"
) FLIST
GROUP BY fid
HAVING COUNT(*) = 2

【讨论】:

    【解决方案3】:

    还有一个答案。

    select 
        (case when f1.person1 = 1 then f1.person2 else f1.person1 end) as fid
    from friends f1
    where f1.person1 = 1 or f1.person2 = 1
    and f1.status = 'friend'
    
    intersect
    
    select 
        (case when f1.person1 = 3 then f1.person2 else f1.person1 end) as fid
    from friends f1
    where f1.person1 = 3 or f1.person2 = 3
    and f1.status = 'friend'
    

    【讨论】:

      【解决方案4】:
      set search_path='tmp';
      
      DROP TABLE friendship CASCADE;
      CREATE TABLE friendship
              ( id integer not null PRIMARY KEY
              , person1 integer not null
              , person2 integer not null
              , status varchar
              , CONSTRAINT pk1 UNIQUE (status,person1,person2)
              , CONSTRAINT pk2 UNIQUE (status,person2,person1)
              , CONSTRAINT neq CHECK (person1 <> person2)
              );
      
      INSERT INTO friendship(id,person1,person2,status) VALUES
       (1,1,2,'friend' ) ,(2,1,3,'friend' ) ,(3,2,3,'friend' ) ,(4,3,4,'friend' )
              ;
      
              -- -----------------------------------------
              -- For implementations that don't have CTEs, 
              -- a view can be used to emulate a CTE.
              -- -----------------------------------------
      CREATE VIEW flip AS (
              SELECT person1 AS one
                      , person2 AS two
              FROM friendship WHERE status = 'friend'
              UNION
              SELECT person2 AS one
                      , person1 AS two
              FROM friendship WHERE status = 'friend'
              );
      
      SELECT DISTINCT
              f1.two AS common
      FROM flip f1
      JOIN flip f2 ON f1.two = f2.two
      WHERE f1.one = 1
      AND f2.one = 3
              ;
      
      DROP VIEW flip;
      
              -- ------------------------------
              -- The same query with a real CTE
              -- ------------------------------
      with flip AS (
              SELECT person1 AS one
                      , person2 AS two
              FROM friendship WHERE status = 'friend'
              UNION
              SELECT person2 AS one
                      , person1 AS two
              FROM friendship WHERE status = 'friend'
              )
      SELECT DISTINCT
              f1.two AS common
      FROM flip f1
      JOIN flip f2 ON f1.two = f2.two
      WHERE f1.one = 1
      AND f2.one = 3
              ;
      

      结果:

      SET
      DROP TABLE
      NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "friendship_pkey" for table "friendship"
      NOTICE:  CREATE TABLE / UNIQUE will create implicit index "pk1" for table "friendship"
      NOTICE:  CREATE TABLE / UNIQUE will create implicit index "pk2" for table "friendship"
      CREATE TABLE
      INSERT 0 4
      CREATE VIEW
       common 
      --------
            2
      (1 row)
      
      DROP VIEW
       common 
      --------
            2
      (1 row)
      

      【讨论】:

        【解决方案5】:

        我认为这是相当简单的实现

        SELECT * FROM friends
        
        WHERE
             (Person1 = '1' or Person2 = '1') && 
             (Person1 = '2' or Person2 = '2') &&
             status = 'friend'
        

        鉴于您正试图找到第 1 个人和第 2 个人之间的相互关系

        【讨论】:

        • 硬编码为示例。更喜欢 Nirmal-think BeTond 的答案
        • @Starx,它会找到#1 和#2 的朋友。不列出共同的朋友。
        • @MichaelDurrant,SO 有时太多,有时是硬编码,有时与情况无关 Arrrrrrrrr
        【解决方案6】:

        我问过编号较小的用户是否总是Person1,但我最终写了一个不关心是否为真的查询。

        set @firstParty = 1, @secondParty = 3
        
        select friends_of_first.friend
        from (
            select Person2 as friend from friends where Person1 = @firstParty
            union 
            select Person1 as friend from friends where Person2 = @firstParty
            ) as friends_of_first
        join (
            select Person2 as friend from friends where Person1 = @secondParty
            union 
            select Person1 as friend from friends where Person2 = @secondParty
            ) as friends_of_second
        on friends_of_first.friend = friends_of_second.friend
        

        查找用户朋友的子查询可以替换为@NirmalthInk beYond 使用的子查询:

        select case when f1.person1 = @firstParty then  f1.person2 else f1.person1 end 
        from friend f1 where f1.person1 = @firstParty or f1.person2 = @firstParty
        

        我很想知道哪种替代方案表现更好。

        【讨论】:

          【解决方案7】:

          如果各种回复或 cmets 中的一个已经提出了这个建议,我深表歉意,但是如何:

          select Person2 mutual_friend from 
            (select Person1, Person2 from friends 
                where Person1 in (1,3) union 
             select Person2, Person1 from friends 
                where Person2 in (1,3)
            ) t 
            group by Person2 having count(*) > 1;
          

          【讨论】:

            【解决方案8】:

            内部查询仅获取第一个人的 FRIEND ID,并将其标准化为单列“FriendID”。如果找到的记录在第一个位置的人员 ID = 1,它会抓取第二个...如果在第二个位置的人员 ID = 1,那么它会抓取第一个。

            完成后,我们就知道了第 1 个人的唯一好友列表……完成了。现在,再次加入友谊表,但仅限于那些 FIRST 有资格成为第 1 个人的朋友之一的人......一旦有资格,然后确保第二张桌子上的另一个人是第 3 个人你正在寻找的共同点。

            确保在 person1 和 person2 上都有一个索引,以利用 OR 条件。

            select
                  JustPerson1Friends.FriendID
               from
                  ( select
                          if( f.Person1 = 1, f.Person2, f.Person1 ) as FriendID
                       from
                          Friendships f
                       where
                               (    f.Person1 = 1
                                 OR f.Person2 = 1 )
                           AND f.status = "friend" ) JustPerson1Friends
                  JOIN Friendships f2
                     on  (   JustPerson1Friends.FriendID = f2.Person1
                          OR JustPerson1Friends.FriendID = f2.Person2 )
                     AND f2.status = "friend"
                     AND ( f2.Person1 = 3 OR f2.person2 = 3 )
            

            另一个选项将人“3”作为常见的人预先标记到结果集中,因此我们不需要在以后明确限定 3。此外,通过使用 MySQL 变量,易于编写脚本并作为参数实现。在内部查询之后,对友谊进行 DOUBLE left-join 以明确测试可以在 X/Y 或 Y/X 组合中找到一个人的 BOTH 组合。所以最后的 where 子句只是说只要在 EITHER LEFT-JOIN 条件中找到一条记录,它就是一个共同的朋友并包含在结果集中。

            select
                  JustPerson1Friends.FriendID
               from
                  ( select
                          @WantPerson2 as FindInCommonWith,
                          if( f.Person1 = @WantPerson1, f.Person2, f.Person1 ) as FriendID
                       from
                          ( select @WantPerson1 := 1,
                                   @WantPerson2 := 3 ) sqlvars
                          Friendships f,
                          (
                       where
                               (    f.Person1 = @WantPerson1
                                 OR f.Person2 = @WantPerson2 )
                           AND f.status = "friend" ) JustPerson1Friends
            
                  LEFT JOIN Friendships f2
                     on JustPerson1Friends.FindInCommonWith = f2.Person1
                     AND JustPerson1Friends.FriendID = f2.Person2
                     AND f2.status = "friend"
            
                  LEFT JOIN Friendships f3
                     on JustPerson1Friends.FindInCommonWith = f2.Person2
                     AND JustPerson1Friends.FriendID = f2.Person1
                     AND f2.status = "friend"
               where
                     f2.Person1 > 0
                  OR f3.Person1 > 0
            

            【讨论】:

              【解决方案9】:

              此查询返回 '22' 作为结果,因为它对于 1 和 3 来说都是通用的 您可能必须过滤掉不同的 PERSON1/PERSON2 如果我可以优化这个查询,我会更新它

              
              SELECT DISTINCT (REPLACE(TRANSLATE((WM_CONCAT(DISTINCT F.PERSON1) || ',' ||
                                                         WM_CONCAT(DISTINCT F.PERSON2)),
                                                         '1,3',
                                                         ' '),
                                               ' ',
                                               '')) AS COMMON_FRIEND
                        FROM FRIENDSHIP F
                       WHERE UPPER(F.STATUS) = 'FRIEND'
                       AND ((SELECT DISTINCT WM_CONCAT(F1.PERSON1)
                                 FROM FRIENDSHIP F1
                                WHERE F1.PERSON2 = '3') LIKE ('%' || F.PERSON1 || '%') OR
                             (SELECT DISTINCT WM_CONCAT(F1.PERSON2)
                                 FROM FRIENDSHIP F1
                                WHERE F1.PERSON1 = '3') LIKE ('%' || F.PERSON2 || '%'))
                         AND ((SELECT DISTINCT WM_CONCAT(F1.PERSON1)
                                 FROM FRIENDSHIP F1
                                WHERE F1.PERSON2 = '1') LIKE ('%' || F.PERSON1 || '%') OR
                             (SELECT DISTINCT WM_CONCAT(F1.PERSON2)
                                 FROM FRIENDSHIP F1
                                WHERE F1.PERSON1 = '1') LIKE ('%' || F.PERSON2 || '%'))
                         AND NOT ((F.PERSON1 = '1' AND F.PERSON2 = '3') OR
                              (F.PERSON1 = '3' AND F.PERSON2 = '1'))
              
              

              【讨论】:

                【解决方案10】:

                这应该可以回答您当前的问题,尽管我建议您不要这样做。在这种情况下,我总是会选择存储两个关系副本,每个方向一个。

                SELECT IF(f1.person1 IN ($id1, $id3), f1.person2, f1.person1) AS mutual_friend
                FROM friends f1
                INNER JOIN friends f2
                    ON (f1.person1 = $id1 AND f2.person1 = $id3 AND f1.person2 = f2.person2)
                    OR (f1.person1 = $id1 AND f2.person2 = $id3 AND f1.person2 = f2.person1)
                    OR (f1.person2 = $id1 AND f2.person1 = $id3 AND f1.person1 = f2.person2)
                    OR (f1.person2 = $id1 AND f2.person2 = $id3 AND f1.person1 = f2.person1)
                WHERE f1.status = 'friend' AND f2.status = 'friend'
                

                【讨论】:

                • 他列出了两个人的所有朋友。它没有列出共同的朋友。顺便说一句,您也只有一个参数。应该是2个参数。
                【解决方案11】:
                id  Person1    Person2  status
                1         1          2  friend
                2         1          3  friend
                3         2          3  friend
                4         3          4  friend
                
                
                  SELECT
                    DISTINCT
                    F1.Person
                  FROM
                    --Friends of 1
                    (
                    SELECT F.Person1 Person FROM People F WHERE F.Person2 = 1 AND F.status = 'friend'
                    UNION
                    SELECT F.Person2 Person FROM People F WHERE F.Person1 = 1 AND F.status = 'friend'
                    ) F1
                    INNER JOIN
                    (
                    --Friends of 3
                    SELECT F.Person1 Person FROM People F WHERE F.Person2 = 3 AND F.status = 'friend'
                    UNION
                    SELECT F.Person2 Person FROM People F WHERE F.Person1 = 3 AND F.status = 'friend'
                    ) F2 ON
                      F2.Person = F1.Person
                

                输出:

                Person
                2
                

                【讨论】:

                  猜你喜欢
                  • 1970-01-01
                  • 1970-01-01
                  • 1970-01-01
                  • 1970-01-01
                  • 1970-01-01
                  • 1970-01-01
                  • 1970-01-01
                  • 1970-01-01
                  • 2015-01-15
                  相关资源
                  最近更新 更多