title: is there an easy/efficient way to do multiple lookups in SQL for a value from an ID without multiple joins?
body: <p>I have two tables. One table has an ID column and then other data. Another table has multiple "ID" fields that correspond to the first table. I know I can do multiple joins but each table has 400,000+ records so I thought maybe there is a more efficient way?</p>
  
  <p>Here is an example of what I mean:</p>
  
  <p>This is my lookup table:</p>
  
  <pre><code>+----+------+---------+
  | ID | Name |  Title  |
  +----+------+---------+
  |  1 | a    | alpha   |
  |  2 | b    | bravo   |
  |  3 | c    | charlie |
  |  4 | d    | delta   |
  +----+------+---------+
  </code></pre>
  
  <p>This is my input table. The example only has 2 lookup columns but the production table has 10.</p>
  
  <pre><code>+----+------------+------------+
  | ID | Lookup ID1 | Lookup ID2 |
  +----+------------+------------+
  |  1 |          1 |          3 |
  |  2 |          2 |          3 |
  |  3 |          2 |          4 |
  |  4 |          2 |          4 |
  |  5 |          2 |          2 |
  |  6 |          2 |          2 |
  |  7 |          3 |          4 |
  |  8 |          1 |          3 |
  +----+------------+------------+
  </code></pre>
  
  <p>This is the expected output.</p>
  
  <pre><code>+----+---------------+----------------+---------------+----------------+
  | ID | Lookup Name 1 | Lookup Title 1 | Lookup Name 2 | Lookup Title 2 |
  +----+---------------+----------------+---------------+----------------+
  |  1 | a             | alpha          | c             | charlie        |
  |  2 | b             | bravo          | c             | charlie        |
  |  3 | b             | bravo          | d             | delta          |
  |  4 | b             | bravo          | d             | delta          |
  |  5 | b             | bravo          | b             | bravo          |
  |  6 | b             | bravo          | b             | bravo          |
  |  7 | c             | charlie        | d             | delta          |
  |  8 | a             | alpha          | c             | charlie        |
  +----+---------------+----------------+---------------+----------------+
  </code></pre>
  
  <p>I know I can get this using multiple joins (10 in my production environment) but there has to be a more efficient way?</p>