Can a different SubQuery replace a Set function Minus?

Question

I'm a student in an Oracle SQL class using 10g. We are nearing the end of our class.
We are working on a chapter on Subqueries.
In one of the homework problems I have a solution that uses a Subquery.
But it also uses a Minus. We studied the Set functions earlier. So my solution
does use things we have already studied. I'm just wondering if the whole
problem could be solved with a different use of Subqueries.
And eliminating the use of the Minus.
Here is the question - 'List the title of all books in the same category as books previously
purchased by customer 1007. Do not include books already purchased by this customer.'
And here is my solution:
SELECT InitCap(Title) AS "Book Title",
Category
FROM Books
WHERE Category IN
( SELECT DISTINCT(Category)
FROM Books JOIN OrderItems USING (ISBN)
JOIN Orders USING (Order#)
JOIN Customers USING (Customer#)
WHERE Customer# = 1007 )
Minus
SELECT InitCap(Title),
Category
FROM Books JOIN OrderItems USING (ISBN)
JOIN Orders USING (Order#)
JOIN Customers USING (Customer#)
WHERE Customer# = 1007
ORDER BY Category;
There is nothing tricky about the tables.
Customers has Customer# which Joins to Orders via the Customer#.
Orders Joins to a table called OrderItems via the Order#.
OrderItems is also joined to Books via the ISBN.
So to get the details of an Order (like which specific books and quantities)
we have to get to Orderitems which has the ISBN and the Quantity.
But every time I go back and look at this question I keep seeing the answer as
'Find the large group, take out the part we don't need, leaving the answer'.
Well, I hope I gave enough explanation here.
Thanks for any thoughts or advice.

Answer 1

Hi,
To understand the problem better, let's do the join that finds the given customer's books only once, by putting it in a WITH clause. That has the additional advantage of keeping it away from the rest of the query.
Since you understand the issues with INITCAP (Title), let's further simplify by not doing INITCAP.
Now we can concentrate on alternatives to MINUS.
MINUS, which you are already doing, can thus be written like this:
WITH  this_customers_orders  AS
     SELECT     Title
     ,     Category
     FROM     Books
     JOIN     OrderItems     USING (ISBN)
     JOIN     Orders          USING (Order#)
     WHERE     Customer#     = 1007
SELECT     Title
,     Category
FROM     Books
WHERE     Category     IN (
                  SELECT  category
                  FROM        this_customers_orders
MINUS
SELECT     *
FROM     this_customers_orders;You should always format code, so you can easily see where sub-queries begin and end, and what the principal parts of each query are. This is especially important when you are learning.
To get the same results using NOT EXISTS:
WITH  this_customers_orders  AS
     SELECT     Title     ...     -- as shown above
SELECT     Title
,     Category
FROM     Books     b
WHERE     Category     IN (
                  SELECT  category
                  FROM        this_customers_orders
AND     NOT EXISTS (
                 SELECT  NULL
             FROM        this_customers_orders
             WHERE   Title   = b.Title
                 );Note that the NOT EXISTS sub-query is corellated to the main query. Perhaps 99% of the uncorellated EXISTS (and NOT EXISTS) sub-queries that I've seen have been errors.
You can also get the same results using NOT IN:
WITH  this_customers_orders  AS
     SELECT     Title     ...     -- as shown above
SELECT     Title
,     Category
FROM     Books     b
WHERE     Category     IN (
                  SELECT  category
                  FROM        this_customers_orders
AND     Title      NOT IN (
               SELECT  book_title
               FROM    this_customers_orders
               WHERE   book_title     IS NOT NULL
               );Notice the condition "WHERE book_title     IS NOT NULL" in the NOT IN sub-query. "x NOT IN (sub_query_y)" will never be TRUE if sub_query_y has even one NULL value.
You can also get the same results by doing an outer join:
WITH  this_customers_orders  AS
     SELECT     INITCAP (Title)     AS Title     ...     -- as shown above
SELECT     b.Title
,     b.Category
FROM          Books               b
LEFT OUTER JOIN     this_customers_orders     t     ON b.Title = t.Title
WHERE     Category     IN (
                  SELECT  category
                  FROM        this_customers_orders
AND     t.Title        IS NULL;An outer join is almost certainly the least efficient way of doing this. The reason I mentioned it here is so that, if you ever see yourself writing a outer join like this, you'll have a model for writing it miore efficiiently as a MINUS, NOT EXISTS or NOT IN query instead.