Pseudocode for SQL query - sql

Question

Hi guys i have the following question,
Assume tables foo(a int, b int) and bar(a int, b int) and assume you are given a stream ‘TableReader’ that reads rows from a table that has the following methods:
tr.next() returns the next row of a type ‘row’ from the stream if there is a next row or null if there are no more rows.
Assume columns can be accessed using row[columnName]. For example, to read rows from foo, you have to do the following:
foo_stream = TableReader(‘foo’);
row = foo_stream.next();
row[‘a’] will return the value of column a and row[‘b’] will return the value of column b.
Write a pseudocode to compute the results of the following SQL query which should return a list of rows:
select foo.a, foo.b, bar.a, bar.b
from foo, bar
where foo.a = bar.a
and foo.b <=100;
Can anyone help me on this ?
The solution i tried is:
Foo_stream = TableReader(‘foo’);
Bar_stream = tableReader(‘bar’);
While(foo_stream.next())
{
{
While(bar_stream.next())
{
Row_foo = foo_stream.next();
Row_Bar =bar_stream.next();
{
If((row_foo[a] equals row_bar[a]) AND (row_foo[b] < = 100))
{
Then print row_foo[a],row_foo[b], row_bar[a], row_bar[b]
}
}
}
}
But the above solution is of complexity O(n2), any better solution is appreciated.

Answer 1

Probably something like this:
Foo_stream = TableReader(‘foo’);
Foo_row = Foo_stream.next();
Foo_hash = New HashSet<Foo_row[a].typeof, Foo_row.typeof>();
Do
{
if (Foo_row[b] <= 100)
{
Foo_hash.Add(Foo_row[a], Foo_row);
}
if (!foo_stream.next()) { Foo_row = Foo_stream.next(); }
} While(foo_stream.next())
Bar_stream = tableReader(‘bar’);
While(bar_stream.next())
{
Bar_row = Bar_stream.next();
if (Foo_hash.Exists(Bar_row[a]))
{
Foo_row = Foo_hash(Bar_row[a]);
print foo_row[a],foo_row[b], bar_row[a],bar_row[b];
}
}
This is called the HashMap method, and is O(n), though it uses a relatively large amount of memory.
There is also the MergeSort method, which is O(NlogN) unless the streams are already sorted on [a]. It requires somewhat less memory than the HashMap method.
Finally there is the method that you used, which is called the Nested Loops method, and as you said, is O(n^2), but has the advantage of needing very little memory.