[SQL allgemein] Selbstreferenzierende Tabelle auslesen (rekursiver JOIN ?)

[QCO]

Ich hab eine selbstreferenzierende Tabelle ala
---------------------------------------------
|| dir_id || dir_name || dir_parent ||
---------------------------------------------
1 verzeichnis1 0
2 unterverz1 1
3 test 1
.
.

Damit könnte man im Prinzip ja beliebig tiefe Strukturen bauen.
Jetzt möchte ich von einem Verzeichnis gern die übergeordneten feststellen. OK, geht mit einer rekursiven Funktion oder einer Schleife geht das. Aber dann brauch ich für jedes Verzeichnis einen Query, das können eine ganze Menge werden (und wenn man das dann noch mehrmals macht ).
Kann man auch irgendwie in SQL das Problem mit einer Abfrage erschlagen? So eine Art rekursiver JOIN, der bis zu einer Abbruchbedingung joint.

Oder gibt es noch einen anderen Weg?

bis jetzt hab ich es so gemacht:

function get_parent_dirs($dir_id)
{
    global $db;
    $returner = array();

    $sql = 'SELECT dir_parentdir FROM ' . DIRS_TABLE . ' WHERE dir_id=' . $dir_id;
    $result = $db->sql_query($sql);
    $row  = $db->sql_fetchrow($result);

    while( $row['dir_parentdir'] != ROOT_DIR )
    {
        $sql = 'SELECT dir_id, dir_name, dir_parentdir FROM '. DIRS_TABLE . ' WHERE dir_id=' . $row['dir_parentdir'];
        $result = $db->sql_query($sql);
        $row = $db->sql_fetchrow($result);
        
        $returner[] = array( 'dir_id' => $row['dir_id'], 'dir_name' => $row['dir_name'] );
    }

    return $returner;
} 

Was mir sonst noch eingefallen ist:

• man könnte einfach mit einem riesigen Folge 'blinder' LEFT JOINs arbeiten...
  

  SELECT a.*, b.*, c.*, d.*, e.* FROM (((table AS a
  LEFT JOIN table b ON b.dir_parentdir=a.dir_id)
  LEFT JOIN table c ON c.dir_parentdir=b.dir_id)
  LEFT JOIN table d ON d.dir_parentdir=c.dir_id)
  LEFT JOIN table d ON e.dir_parentdir=d.dir_id)
  WHERE ...

  Nachteil: es ist plötzlich doch nicht mehr unedlich tief verschachtelbar
• wenn man ein weiteres Datenbankfeld anlegt, in dem die Verzeichnistiefe dieses Verzeichnisses steht, kann man daraus einen beliebig großen JOIN konstruieren. Aber ist das wirklich effektiver?