Duplizierungsproblem mit MySQL-Sortierung auf mehrere Spalten

Question

Für eine bestimmte Liste von eindeutigen Elementen, nach dem Sortieren sie basierend auf ein paar Spalten in Batches, bekomme ich die Duplizierung von Elementen.

Es gibt zwei Tabellen:

- item_popularity_tbl: 
    iid (UINT, PK) pplt (UTINYINT) 

- item_cat_id_tbl: 
    iid (UINT, PK) cid (UTINYINT) 

Where: 
    iid: item ID, unique values in the tables 
    cid: cat ID, values in the range (1, 15). Multiple items can have same cid. 
    pplt: popularity, vals in the range (1, 10). Multiple items can have same pplt. 

eine Liste von Element-IDs gegeben, die alle einzigartig, ich brauche es von cid ASC zu bestellen und dann pplt DESC.

Ich verwende die folgenden SQL (MySQL) Code, um es zu erreichen:

# python code snippet 
def db_get_items_sorted(conn, iid_list, offset, limit): 
    n1 = ','.join(['%s'] * len(iid_list)) 
    # 
    sql_stmt = ("SELECT a.iid, a.cid, b.pplt " 
       "FROM pclg.item_cat_id_tbl  AS a " 
      "INNER JOIN pclg.item_popularity_tbl AS b ON b.iid=a.iid " 
       "WHERE a.iid IN (%s) " 
       "ORDER BY a.cid ASC, " 
         "b.pplt DESC " 
       "LIMIT %s,%s") % (n1, offset, limit) 
    # 
    return conn.query(sql_stmt % tuple(iid_list)) 

I db_get_items_sorted nennen (...) in Chargen von 10 Getestet habe ich diese mit Eingang iid_list von 58 Elementen (unique) , gegen voll besetzte Tabellen mit eindeutigen iids. Für jeden Aufruf gibt mysql eindeutige 10 iids mit der richtigen Sortierung zurück, wie angefordert. Aber wenn ich die Batches verkette, um die letzten 58 Items zu erstellen, merke ich, dass mehrere Items (iid) in der Liste dupliziert sind (und für diese sind alle zurückgegebenen Spalten die gleichen, im Grunde vollständige Duplizierung). Zum Beispiel 48 eindeutige Zeilen und 10 Duplikate.

Wenn ich db_get_items_sorted (...) mit Offset 0 und Limit 58 aufrufe, gibt es keine IDD-Duplikate. Allerdings muss ich kleine Chargen aufrufen, da wir diese Sortierung für mehrere tausend Artikel durchführen können.

Frage ist: Wie erreicht man Einzigartigkeit über Chargen hinweg?

Answer 1

Ich wollte nicht DISTINCT verwenden, um das Problem zu lösen. Ich war mir nicht sicher, warum die Verdoppelung der Reihen überhaupt stattfand, daher wollte ich das ansprechen.

Unten ist die Lösung, eine Spalte iid mit einzigartigen vals Verwendung in der ORDER BY:

 sql_stmt = ("SELECT a.iid, a.cid, b.pplt " 
        "FROM pclg.item_cat_id_tbl  AS a " 
       "INNER JOIN pclg.item_popularity_tbl AS b ON b.iid=a.iid " 
        "WHERE a.iid IN (%s) " 
        "ORDER BY a.cid ASC, " 
          "b.pplt DESC, a.iid DESC " 
        "LIMIT %s,%s") % (n1, offset, limit) 

TL; DR: Die Vervielfältigung geschieht, wie wir LIMIT zusammen mit ORDER Verwendung wurden BY und die Säulen in ORDER BY verwendet haben keine eindeutigen Vals.

Gründe:

• LIMIT kehrt der Moment sie die erforderliche Anzahl der Zeilen, die die Abfrage erfüllen erfährt.

• Wenn eine Spalte mit nicht eindeutigen Werten mit ORDER BY verwendet wird, müssen die Zeilen, die dieselben Werte dieser Spalten enthalten, keine deterministische Reihenfolge haben.

Also, mit LIMIT und ruft diese Routine mehrere Male (bis sie schließlich verketten um das Endergebnis zu produzieren), mysql lief die ORDER BY mehrmals und Zeilen mit gleichen val für Spalten (in der Reihenfolge verwendet, BY) waren über diese Anrufe nicht geordnet - dh ihre Positionen waren nicht konstant. LIMIT M, N gibt jedoch Zeilen aus dem spezifischen (M, N) -Fenster des ORDER BY-Ergebnisses zurück.

Dies führte zu dem endgültigen verketteten Ergebnis, das doppelte Zeilen enthielt.

Ref: https://dev.mysql.com/doc/refman/5.7/en/limit-optimization.html

Answer 2

Sie könnten mit disquare an der Abfrage arbeiten, so dass die Abfrage selbst Duplikate entfernt.

sql_stmt = ("SELECT DISTINCT a.iid, a.cid, b.pplt " 
       "FROM pclg.item_cat_id_tbl  AS a " 
      "INNER JOIN pclg.item_popularity_tbl AS b ON b.iid=a.iid " 
       "WHERE a.iid IN (%s) " 
       "ORDER BY a.cid ASC, " 
         "b.pplt DESC " 
       "LIMIT %s,%s") % (n1, offset, limit)