Ankündigung

Einklappen
Keine Ankündigung bisher.

Self-Join bringt leere Ergebnisse?

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Self-Join bringt leere Ergebnisse?

    Hallo Leuz

    Ich entschuldige mich schon zum voraus, dass ich nicht genügend im Forum gesucht habe... Da ich jedoch gar nicht so recht begreife, was mein Problem auslöst, finde ich keine richtige Lösung.

    Ich habe eine Tabelle mit Wörtern `voca`, die wieder anderen Wörtern der gleichen Tabelle zugeordnet sind. Dies per Beziehungstabelle `voca_means`.
    Die Wörter sind noch `voca_wordgroups` und natürlich Sprachen (`voca_langs`) zugeordnet.

    Nun möchte ich eine Wörterliste aufrufen, die alle Möglichen Informationen enthält:
    - Wort
    - Wort übersetzt (Gleiche Tabelle!!)
    - Wordgroup
    - Language
    - Lection (in `lang_means` enthalten)

    Der Query sieht wie folgt aus:
    Code:
    SELECT
                    `w`.`id` AS `word_id`,
                    `w`.`word`,
                    `l`.`lang_id`,
                    `l`.`lang_short`,
                    `l`.`lang_long` AS `lang`,
                    `m`.`lection`,
                    `m`.`okay`,
                    `m`.`fk_group` AS `group`,
                    `wm`. `word` AS `means`
                FROM
                    `voca` `w`
                LEFT JOIN
                    `voca_means` `m`
                ON
                    `w`.`id` = `m`.`fk_word`
                INNER JOIN
                    `voca_langs` `l`
                ON
                    `l`.`lang_id` = `w`.`fk_lang`
                LEFT JOIN
                    `voca` `wm`
                ON
                    `m`.`fk_means` = `w`.`id`
    Habe den letzten Teil mit Where weggelassen, weil er hier nicht wichtig ist.

    Es geht eigentlich um die letzten beiden Zeilen die mir zu schaffen machen.

    Der letzte Float sollte eigentlich unabhängig von den anderen zuvor einfach noch zusätzliche Resultate liefern und nicht mit den anderen Bedingungen zusammenhängen...

    Gibt es eine Möglichkeit ausser einem weiteren Select Befehl, einen Self-Join zu machen, der nicht an die anderen Joins gebunden ist?

    Danke für die Antworten...
    codestyle.ch
    ----------------------------


  • #2
    Also ehrlich gesagt habe ich nicht verstanden was Du machen möchtest. Wenn die letzten Tabelle "einfach so" an der Abfrage hängt, bekommt Du ein Kartesisches Produkt (also jede Menge doppelte Datensätze).

    Du könnest also einfach die letzte "ON" Bedingung weglassen.

    Code:
    SELECT w.id        AS word_id,
           w.word,
           l.lang_id,
           l.lang_short,
           l.lang_long AS lang,
           m.lection,
           m.okay,
           m.fk_group  AS group,
           wm. word    AS means
       FROM voca w
       LEFT JOIN voca_means m
         ON w.id = m.fk_word
       INNER JOIN voca_langs l
         ON l.lang_id = w.fk_lang
       LEFT JOIN voca wm
    --     ON m.fk_means = w.id  
    Weiterhin bin ich mir nicht sicher, warum Du die INNER JOIN und LEFT JOIN mischt. Stimmt das wirklich so?

    Ein paar Tabellen plus Testdaten wäre nicht schlecht zum Testen.

    Grüße
    Thomas

    Kommentar


    • #3
      Danke erstma für die Hilfe ^.^

      Zitat von thomas_w Beitrag anzeigen
      Also ehrlich gesagt habe ich nicht verstanden was Du machen möchtest.
      Also in meinem Wörterbuch hat es Wörter in verschiedenen Sprachen. Diese Wörter beziehen sich aufeinander (z.B. essen = eat).
      Diese beiden wörter stehen aber beide in der gleichen Tabelle.

      Nun will ich alle Wörter auflisten. Sollte in etwa so aussehen:

      ----------------------------
      | word | means | lang |
      |------------------------- |
      | essen | eat | de |

      ...

      Mir fällt grad auf, dass das sowieso nicht ganz aufgeht...

      Die Idee war, dass ich aus `fk_means` die ID des anderen Wortes heraushole...

      Mir ist gerade aufgefallen, dass das andere Wort ja in mehreren Sprachen existieren kann... Dafür habe ich ja die Wordgroups gemacht, dass ich sagen kann welche Wörter zusammen gehören, bzw. gegenseitig Übersetzt werden können...

      Könnt hier closen... oder noch offen lassen, falls wer eine andere Idee hat, wie ich das einfacher lösen könnte...

      `voca_means` ist etwas unlogisch. Sieht momentan so aus:

      id | fk_word | fk_means | lection | okay | fk_group

      `fk_means` -> unlogisch, weil das Wort ja in mehreren Sprachen existiert und deshalb mehrere ids eingetragen werden müssten.

      `lection` -> Ist in `voca_means` drin, weil ich die Übersetzungen und Wörter in eine Lektion stopfen will... unlogisch?

      `okay` -> Wie gut kann man die Wörter.

      `fk_group` -> Bezieht sich auf die wordgroups

      ...

      Zitat von thomas_w Beitrag anzeigen
      Weiterhin bin ich mir nicht sicher, warum Du die INNER JOIN und LEFT JOIN mischt. Stimmt das wirklich so?
      Das waren Tests... ist nicht ganz richtig und extra so ^^

      Zitat von thomas_w Beitrag anzeigen
      Ein paar Tabellen plus Testdaten wäre nicht schlecht zum Testen.
      Sorry, ich lass das jetzt erstma weg, wegen der Verwirrung... >.<

      Wer mir noch helfen möchte kann..
      Ansonsten denk ich ma selbst weiter ^^

      Thx, Greez
      codestyle.ch
      ----------------------------

      Kommentar


      • #4
        Ich habe mal etwas zusammen gebastelt, vielleicht hilft es Dir (bei denken) weiter...

        Code:
        CREATE TABLE wort (
         wort_id INT NOT NULL,
         sprache_id INT NOT NULL,  -- 1=de , 2=en
         wort VARCHAR(50),
         
         PRIMARY KEY (wort_id)
        );
        
        CREATE TABLE wort_translate (
         wort_trans_id INT NOT NULL,
         wort_trans_gruppe INT NOT NULL,
         wort_id INT NOT NULL,
         
         PRIMARY KEY (wort_trans_id)
        );
        
        INSERT INTO wort VALUES 
        ( 1, 1, 'essen'),
        ( 2, 2, 'eat'),
        ( 3, 1, 'heiß'),
        ( 4, 2, 'hot');
        
        INSERT INTO wort_translate VALUES
        ( 1, 1, 1),
        ( 2, 1, 2),
        ( 3, 2, 3),
        ( 4, 2, 4);
        
        SELECT w.wort, w2.wort AS word
          FROM wort w
          JOIN wort_translate wt
            ON wt.wort_id = w.wort_id
          JOIN wort_translate wt2
            ON wt2.wort_trans_gruppe = wt.wort_trans_gruppe
           AND wt2.wort_id <> wt.wort_id
          JOIN wort w2
            ON w2.wort_id = wt2.wort_id
         WHERE w.wort = 'essen'
        ORDER BY w.wort;
            
        +-------+------+
        | wort  | word |
        +-------+------+
        | essen | eat  |
        +-------+------+
        1 row in set (0.00 sec)
        
        mysql>
        Mit Hilfe einer Translate-gruppe, findet "essen" seine möglichen Übersetzungen.
        Das Ganze ist nur ein kleines Beispiel und müsste noch mit mehreren Sprachen getestet werden.

        Grüße
        Thomas

        Kommentar


        • #5
          Oh, sowas ähnlich hatte ich eigentlich schon...

          Naja, danke ich werd's mir morgen oder so noch genauer anschauen und noch Mal überlegen, was ich machen will ^^

          Danke ^-^
          codestyle.ch
          ----------------------------

          Kommentar

          Lädt...
          X