Question

I’m currently reading a book about parallelism in a DBMS and I find it difficult to understand how parallelism works exactly in the join operation.

Suppose we have 10 systems, each system has each own disk space and main memory. There is a network with which the systems can communicate with each other in order for example to share data.

Now suppose we have the following operation: A(X,Y) JOIN B(Y,Z)

the tables A and B are too big so we want to use parallelism in order to gain better overall computing speed.

What we do is we apply a hash function on the ‘Y’ attribute for each record of A and B tables, and we send these records to a different system. Each system can then use a local algorithm in order to join the records that they got.

What I don’t understand is, where exactly is the initial hash function being applied and where exactly are the initial tables A and B being stored?

While I was reading I thought that we had another “main” system, which had also its own disk space, and in this space we had all the initial information, which is table A and B with all their records. This system used its own main memory in order to apply the initial hash function, which determined for each record the system out of the total 10 where it will eventually go and be processed.

however upon reading I got stuck in the following example(I translate from Greek)

Let’s say we have two tables R(X,Y) JOIN S(Y,Z) where R has 1000 pages and S 500 pages. Suppose that we have 10 systems that can be used in parallel. So we start by using a hash function to determine where we should send each record. The total amount of I/Os needed to read the tables R and S is 1500, which is 150 for each system. Each system will have 15 pages of data which are necessary for each of the remaining systems, so it sends 135 pages to the other nine systems. Hence the total communication is 1350 pages.

I don’t really understand the bold part. Why would a system have to send any data to the other systems? Doesn’t the “main” system I was talking about previously do this job?

I imagine something like this:

               main_system
                  ||
                  \/
            apply_hash(record)
                  ||
                  \/
              send record to the appropriate system
              / /  /  /  /  /  /  /  /  /  
            s1 s2 s3 s4 s5 s6 s7 s8 s9 s10

now all systems have their own records, they apply the local algorithm and give the result to the output. No communication between the systems, what am I missing here?? does the book use a different approach and if so what kind of approach because I have read the same unit 3 times and I still don’t get it(maybe a bad translation not sure though).

thanks in advance

Answer 1

In a shared-nothing system, the data is typically partitioned across the processors when the data is created. Although databases can be shared-nothing, probably the best documentation is for Hadoop and HDFS, the Hadoop distributed file system.

A function assigns rows to a partition. Some examples are: round-robin, where new rows are assigned to the processors one after the other; range-based, where rows are assigned to a processor based on the value of a column; hash-based, where rows are assigned to a processor based on a hash of the value. The process of partitioning the data is very similar to “partitioning” in databases such as SQL Server and Oracle which are not in a shared-nothing environment.

If your join uses the partition key for both tables, and the partitioning method is the same, then the data is already local. Otherwise, one or both tables need to be redistributed to continue the processing.

In the section that you quote, you are probably confused by the arithmetic. Remember that if you have 1500 pages across 10 processors, each will have on average 150 pages. These pages need to be redistributed. Say you are processor 3. About 15 pages will go to processor 1; another 15 to processor 2. And another to processor 3. Wait! You don’t have to send these; they are already in the right spot. You only have to send 9*15 = 135 pages to other processors.

The key idea is that the same processors are storing the data as doing the processing, in a shared-notthing environment.