Set-based approach to updating multiple tables, rather than a WHILE loop?

Apparently I'm far too used to procedural programming, and I don't know how to handle this with a set-based approach.

I have several temporary tables in SQL Server, each with thousands of records. Some of them have tens of thousands of records each, but they're all part of a record set. I'm basically loading a bunch of xml data that looks like this:

<root>
    <entry>
        <id-number>12345678</id-number>
        <col1>blah</col1>
        <col2>heh</col2>
        <more-information>
            <col1>werr</col1>
            <col2>pop</col2>
            <col3>test</col3>
        </more-information>
        <even-more-information>
            <col1>czxn</col1>
            <col2>asd</col2>
            <col3>yyuy</col3>
            <col4>moat</col4>
        </even-more-information>
        <even-more-information>
            <col1>uioi</col1>
            <col2>qwe</col2>
            <col3>rtyu</col3>
            <col4>poiu</col4>
        </even-more-information>
    </entry>
    <entry>
        <id-number>12345679</id-number>
        <col1>bleh</col1>
        <col2>sup</col2>
        <more-information>
            <col1>rrew</col1>
            <col2>top</col2>
            <col3>nest</col3>
        </more-information>
        <more-information>
            <col1>234k</col1>
            <col2>fftw</col2>
            <col3>west</col3>
        </more-information>
        <even-more-information>
            <col1>asdj</col1>
            <col2>dsa</col2>
            <col3>mnbb</col3>
            <col4>boat</col4>
        </even-more-information>
    </entry>
</root>

Here's a brief display of what the temporary tables look like:

Temporary Table 1 (entry):

+------------+--------+--------+
|  UniqueID  |  col1  |  col2  |
+------------+--------+--------+
|   732013   |  blah  |  heh   |
|   732014   |  bleh  |  sup   |
+------------+--------+--------+

Temporary Table 2 (more-information):

+------------+--------+--------+--------+
|  UniqueID  |  col1  |  col2  |  col3  |
+------------+--------+--------+--------+
|   732013   |  werr  |  pop   |  test  |
|   732014   |  rrew  |  top   |  nest  |
|   732014   |  234k  |  ffw   |  west  |
+------------+--------+--------+--------+

Temporary Table 3 (even-more-information):

+------------+--------+--------+--------+--------+
|  UniqueID  |  col1  |  col2  |  col3  |  col4  |
+------------+--------+--------+--------+--------+
|   732013   |  czxn  |  asd   |  yyuy  |  moat  |
|   732013   |  uioi  |  qwe   |  rtyu  |  poiu  |
|   732014   |  asdj  |  dsa   |  mnbb  |  boat  |
+------------+--------+--------+--------+--------+

I am loading this data from an XML file, and have found that this is the only way I can tell which information belongs to which record, so every single temporary table has the following inserted at the top:

T.value('../../id-number[1]', 'VARCHAR(8)') UniqueID,

As you can see, each temporary table has a UniqueID assigned to it's particular record to indicate that it belongs to the main record. I have a large set of items in the database, and I want to update every single column in each non-temporary table using a set-based approach, but it must be restricted by UniqueID.

In tables other than the first one, there is a Foreign_ID based on the PrimaryKey_ID of the main table, and the UniqueID will not be inserted... it's just to help tell what goes where.

Here's the exact logic that I'm trying to figure out:

1. 
   

   If id-number currently exists in the main table, update tables based on the PrimaryKey_ID number of the main table, which is the same exact number in every table's Foreign_ID. The foreign-key'd tables will have a totally different number than the id-number -- they are not the same.

   
   


2. 
   

   If id-number does not exist, insert the record. I have done this part.

   
   

However, I'm currently stuck in the mind-set that I have to set temporary variables, such as @IDNumber, and @ForeignID, and then loop through it. Not only am I getting multiple results instead of the current result, but everyone says WHILE shouldn't be used, especially for such a large volume of data.

How do I update these tables using a set-based approach?