DISTINCT P
FROM Patient p IN Patient_Set
WHERE p.sex == 'male' AND
      EXISTS (SELECT r
              FROM Medical_recrod r IN p.get_medical_record()
              WHERE r.get_date() < '10/10/89' AND
                    (r.get_diagnosis() == 'Malaria' OR
                     r.get_diagnosis() == 'Smallpox'));

SELECT DISTINCT q1.partno, q1.descr, q2.suppno
FROM inventory q1, quotations q2
WHERE q1.partno = q2.partno AND q1.descr = 'engine'
      AND q2.price <= ALL (SELECT q3.price FROM quotations q3 WHERE q2.partno = q3.partno);

if ( in a SELECT box(upper box)
        a quantifier has a type F
     AND ranges over a SELECT box(lower box)
     AND no other quantifier ranges over lower box
     AND
    	  (upper.head.distinct = TRUE
           OR
           upper.body.distinct = PERMIT
           OR
           lower.body.distinct != ENFORCE
          )
   )
{
     merge the lower box into upper box;
     if（lower.body.distinct = ENFORCE
         AND upper.body.distinct != PERMIT)
     {
         upper.body.distinct = ENFORCE;
     }
}

CREATE VIEW itpv AS
 (SELECT DISTINCT itp.itemn, pur.vendn
  FROM itp, pur
  WHERE itp.ponum = pur.ponum AND pur.odate > '85');

SELECT itm.itmn, itpv.vendn FROM itm, itpv
WHERE itm.itemn = itpv.itemn
      AND itm.itemn >= '01' AND itm.itemn < '20';

SELECT DISTINCT itm.itmn, pur.vendn
FROM itm, itp, pur
WHERE itp.ponum = pur.ponum AND itm.itemn = itp.itemn
      AND pur.odate > '85'
      AND itm.itemn >= '01' AND itm.itemn < '20';

if (in a SELECT box
    either quantifier-nodup-condition
    or one-tuple-condition
    holds for all F quantifier)
{
    head.distinct = TRUE;
    body.distinct = PERSERVE;
}

/* DISTPDFR */
if (in a box with type SELECT, UNION, INTERSECT or EXCEPT,
       body.distinct = PERMIT or ENFORCE)
{
    for (each F quantifier in the body)
        quantifier.distinct = PERMIT;
}

/* DISTPDTO */
if (in a box with type SELECT, UNION, INTERSECT or EXCEPT,
       all quantifiers ranging over the box have quantifier.distinct = PERMIT)
{
    body.distinct = PERMIT;
}

if (in a SELECT box
       a quantifier has type = E or A)
{
    quantifier.distinct = PERMIT;
}

if (in a SELECT box
       more than one quantifier
       range over the box)
{
    make a copy of the quantifiers ranging over the original box
    and change it to range over the new copy;
}

if (in a SELECT box
       head.distinct = FALSE)
{
    for (each F quantifier)
        if (the key of the F quantifier does not appear in the output)
        {
            Add the key to the head;
            head.distinct = TURE;
        }
}

CREATE VIEW itemprice AS
(
    SELECT DISTINCT itp.itemno, itp.NegotiatedPrice
    FROM itp
    WHERE NegotiatedPrice > 1000;
)

SELECT itemprice.NegotiatedPrice, itm.type
FROM itemprice, itm
WHERE itemprice.itemno = itm.itemno;

SELECT DISTINCT itp.NegotiatedPrice, itm.type, itm.itemno
FROM itp, itm
WHERE itp.NegotiatedPrice > 1000 AND itp.itemno = itm.itemno;

if (in a SELECT box
        there is a quantifier of type E
        forming a Boolean factor
    AND
    (
        head.distinct = TRUE
      OR
        body.distinct = PERMIT
      OR
        one-tuple-condition
    )
   )
{
    set quantifier type to F;
    if (one-tuple-condiftion is FALSE
        AND head.distinct = TRUE)
    {
        body.distinct = ENFORCE;
    }
}

SELECT * FROM itp
WHERE itp.itemn IN
    ( SELECT itl.itemn FRO itl
      WHERE itl.wkcen = 'WK468' AND itl.locatio = 'LOCA000IN');

SELECT DISTINCT itp.* FROM itp, itl
WHERE itp.itemn = itl.itemn
      AND itl.wkcen = 'WK468' AND itl.locatio = 'LOCA000IN';

if ( in an INTERSECT box
        body.distinct != PRESERVE)
{
    set the box to be of type SELECT;
    choose an arbitrary quantifier Q1;
    /* Q1 will keep tyoe F */
    for ( each quantifier Q != Q1 in the box)
    {
        Q.type = E;
        add the predicate
        EXISTS ( SELECT * FROM Q
                 WHERE Q1.c1 = Q.c1 AND
                       Q1.c2 = Q.c2 AND
                       ...
                       Q1.cn = Q.cn
               );
    }
}