DL_MEM_DEBUG:  initializing options [trace,exceptions,log=stdout]
DL_FILE_DEBUG:  initializing options [trace]
DS73013 2.0.00  ODXSQL - Omnidex SQL                   Fri Aug 05 13:26:14 2005
(c) Dynamic Information Systems Corp.  1981-2005
LICENSEE: DISC Internal Copy 


> ; SUMMARY      Unit test
> ;
> ; DESCRIPTION  Another unit test
> ;
> ; STATUS       These tests have been properly validated.
> ;
> ; KEYWORDS     unit test acceptance
> ;
> 
> ; <COMMON>
> connect star
[DATABASES=
STAR,STAR,FLATFILE,,,]
Connected to <filename> on instance 1, cursor 1
> set autoexplain on
> set explain counts
> ;
> ;  Sampling of tests for 3.5 features.
> ;
> ;
> ; <SECTION=COUNT()>
> ;
> ;Tests optimized count()
> ;
> ; <TEST=C1>
> ;1
> select count(*) from products
----------------------------------- SUMMARY -----------------------------------
Select        count(*) \
  from        PRODUCTS

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = 'all_rows' on 1 with COUNTONLY
   (100 PRODUCTS, 100 Pre-intersect   <time>)
Return COUNT('*')
-------------------------------------------------------------------------------
> ; <TEST=C2>
> ;2
> select count(sales_tax) from orders
----------------------------------- SUMMARY -----------------------------------
Select        count(SALES_TAX) \
  from        ORDERS

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where SALES_TAX = 'all_rows' on 1 with COUNTONLY
   (200 ORDERS, 200 Pre-intersect   <time>)
Return COUNT(ORDERS.SALES_TAX)
-------------------------------------------------------------------------------
> ; <TEST=C3>
> ;3
> select count(*) from activity \
 (cont) >   where initials = 'EFR' or tickler in ('MF', 'PC', 'RC')
----------------------------------- SUMMARY -----------------------------------
Select        count(*) \
  from        ACTIVITY \
  where       INITIALS = 'EFR' or \
              TICKLER in ('MF', 'PC', 'RC')

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where INITIALS = 'EFR' on 1 with NOAUTORESET
   (1 ACTIVITY, 1 Pre-intersect   <time>)
Qualify (ACTIVITY)ACTIVITY where or TICKLER in ('MF','PC','RC') on 1 with \
   NOAUTORESET
   (6 ACTIVITY, 0 Pre-intersect   <time>)
Return COUNT('*')
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=C3r>
> ;4
> select count(*) from activity \
 (cont) >   where initials = 'EFR' or tickler in ('MF', 'PC', 'RC')
----------------------------------- SUMMARY -----------------------------------
Select        count(*) \
  from        ACTIVITY \
  where       INITIALS = 'EFR' or \
              TICKLER in ('MF', 'PC', 'RC')

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where INITIALS = 'EFR' on 1 with NOAUTORESET
   (1 ACTIVITY, 1 Pre-intersect   <time>)
Qualify (ACTIVITY)ACTIVITY where or TICKLER in ('MF','PC','RC') on 1 with \
   NOAUTORESET
   (6 ACTIVITY, 0 Pre-intersect   <time>)
Return COUNT('*')
-------------------------------------------------------------------------------
> ; <TEST=C4>
> ;5
> select count(p.product_no) \
 (cont) >   from orders o, products p \
 (cont) >   where o.product_no = p.product_no and \
 (cont) >         (o.quantity >= 10 or p.wholesale > 1000.00)
----------------------------------- SUMMARY -----------------------------------
Select        count(P.PRODUCT_NO) \
  from        ORDERS O, \
              PRODUCTS P \
  where       O.PRODUCT_NO = P.PRODUCT_NO and \
              (O.QUANTITY >= 10 or \
               P.WHOLESALE > 1000.00)

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where QUANTITY >= '10' on 1 with NOAUTORESET
   (35 ORDERS, 35 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PRODUCTS)PRODUCTS where or WHOLESALE > '1000.00' on 1 with \
   NOAUTORESET,PRESERVERS
   (80 ORDERS, 29 PRODUCTS, 11 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (PRODUCTS)ORDERS using PRODUCT_NO on 1 with \
   NOAUTORESET,COUNT
   (80 ORDERS, 29 PRODUCTS, 11 Pre-intersect   <time>)
Return COUNT(P.PRODUCT_NO)
-------------------------------------------------------------------------------
> ; <TEST=C5>
> ;6
> select count(*) from orders group by acct
----------------------------------- SUMMARY -----------------------------------
Select        count(*) \
  from        ORDERS \
  group by    ACCT

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where ACCT = 'all_keywds' on 1 with KEYWD
   (3 keywords   <time>)
Fetchkeys ACCT 1000 at a time on 1
Return COUNT('*')
-------------------------------------------------------------------------------
> ;
> ;
> ;Tests un-optimized count()
> ;
> ; <TEST=C6>
> ;7
> select count(*) from pmt_methods
----------------------------------- SUMMARY -----------------------------------
Select        count(*) \
  from        PMT_METHODS

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PMT_METHODS)PMT_METHODS where DESCRIPTION = 'all_rows' on 1 with \
   COUNTONLY
   (10 PMT_METHODS, 10 Pre-intersect   <time>)
Return COUNT('*')
-------------------------------------------------------------------------------
> ; <TEST=C7>
> ;8
> select count(mailflag) from prospects
----------------------------------- SUMMARY -----------------------------------
Select        count(MAILFLAG) \
  from        PROSPECTS

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where MAILFLAG = 'all_rows' on 1 with COUNTONLY
   (10 PROSPECTS, 10 Pre-intersect   <time>)
Return COUNT(PROSPECTS.MAILFLAG)
-------------------------------------------------------------------------------
> ; <TEST=C8>
> ;9
> select count(p.product_no), count(o.acct) \
 (cont) >   from orders o join products p using (product_no) \
 (cont) >   where (o.quantity >= 10 or p.wholesale > 1000.00)
----------------------------------- SUMMARY -----------------------------------
Select        count(P.PRODUCT_NO), \
              count(O.ACCT) \
  from        ORDERS O \
  join        PRODUCTS P using (PRODUCT_NO) \
  where       O.QUANTITY >= 10 or \
              P.WHOLESALE > 1000.00

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_AGGREGATION
Notes:        Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where WHOLESALE > '1000.00' on 1 with NOAUTORESET
   (11 PRODUCTS, 11 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY >= '10' on 1 with NOAUTORESET
   (80 ORDERS, 35 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (80 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PRODUCTS P using $ROWID = $ODXID
Return COUNT(P.PRODUCT_NO), COUNT(O.ACCT)
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=C8r>
> ;10
> select -1 * (count(*) + 5) from activity \
 (cont) >   where tickler like 'C%'
----------------------------------- SUMMARY -----------------------------------
Select        -1 * (count(*) + 5) \
  from        ACTIVITY \
  where       TICKLER like 'C%'

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where TICKLER = 'C*' on 1 with NOAUTORESET
   (94 ACTIVITY, 94 Pre-intersect   <time>)
Return -1 * COUNT('*') + 5
-------------------------------------------------------------------------------
> ; <TEST=C9>
> ;11
> select -1 * (count(*) + 5) from activity \
 (cont) >   where tickler like 'C%'
----------------------------------- SUMMARY -----------------------------------
Select        -1 * (count(*) + 5) \
  from        ACTIVITY \
  where       TICKLER like 'C%'

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where TICKLER = 'C*' on 1 with NOAUTORESET
   (94 ACTIVITY, 94 Pre-intersect   <time>)
Return -1 * COUNT('*') + 5
-------------------------------------------------------------------------------
> ; <TEST=C10>
> ;12
> select 'counted ', count(quantity) from orders \
 (cont) >   where order_date > '01-01-1996' or quantity between 1 and 5 \
 (cont) >         or sales_tax < 4.00
----------------------------------- SUMMARY -----------------------------------
Select        'counted ', \
              count(QUANTITY) \
  from        ORDERS \
  where       ORDER_DATE > '01-01-1996' or \
              QUANTITY between 1 and 5 or \
              SALES_TAX < 4.00

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where ORDER_DATE > '01-01-1996' on 1 with NOAUTORESET
   (8 ORDERS, 8 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY between '1' and '5' on 1 with \
   NOAUTORESET
   (155 ORDERS, 154 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or SALES_TAX < '4.00' on 1 with NOAUTORESET
   (158 ORDERS, 50 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
Return 'counted ', COUNT(ORDERS.QUANTITY)
-------------------------------------------------------------------------------
> ;
> ;
> ; <SECTION=COUNT(DISTINCT)>
> ;
> ;Tests optimized count(distinct col)
> ;
> ; <TEST=CD1>
> ;13
> select count(distinct cost) from products
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct COST) \
  from        PRODUCTS

Version:      <version>
Optimization: AGGREGATION
----------------------------------- DETAILS -----------------------------------
Aggregate PRODUCTS using COST for COUNT(DISTINCT COST) on 1
Return COUNT(DISTINCT PRODUCTS.COST)
-------------------------------------------------------------------------------
> ; <TEST=CD2>
> ;14
> select count(distinct order_date) from orders \
 (cont) >   where order_date > '01-01-1996' or quantity between 1 and 5 \
 (cont) >         or sales_tax < 4.00
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct ORDER_DATE) \
  from        ORDERS \
  where       ORDER_DATE > '01-01-1996' or \
              QUANTITY between 1 and 5 or \
              SALES_TAX < 4.00

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where QUANTITY between '1' and '5' on 1 with NOAUTORESET
   (154 ORDERS, 154 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or SALES_TAX < '4.00' on 1 with NOAUTORESET
   (157 ORDERS, 50 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or ORDER_DATE > '01-01-1996' on 1 with NOAUTORESET
   (158 ORDERS, 8 Pre-intersect   <time>)
Aggregate ORDERS using OT for COUNT(DISTINCT ORDER_DATE) on 1
Return COUNT(DISTINCT ORDERS.ORDER_DATE)
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=CD2r>
> ;15
> select count(distinct order_date) from orders \
 (cont) >   where order_date > '01-01-1996' or quantity between 1 and 5 \
 (cont) >         or sales_tax < 4.00
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct ORDER_DATE) \
  from        ORDERS \
  where       ORDER_DATE > '01-01-1996' or \
              QUANTITY between 1 and 5 or \
              SALES_TAX < 4.00

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where QUANTITY between '1' and '5' on 1 with NOAUTORESET
   (154 ORDERS, 154 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or SALES_TAX < '4.00' on 1 with NOAUTORESET
   (157 ORDERS, 50 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or ORDER_DATE > '01-01-1996' on 1 with NOAUTORESET
   (158 ORDERS, 8 Pre-intersect   <time>)
Aggregate ORDERS using OT for COUNT(DISTINCT ORDER_DATE) on 1
Return COUNT(DISTINCT ORDERS.ORDER_DATE)
-------------------------------------------------------------------------------
> ; <TEST=CD3>
> ;16
> select count(distinct profession), '1' from prospects \
 (cont) >   where cr_limit > 0
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct PROFESSION), \
              '1' \
  from        PROSPECTS \
  where       CR_LIMIT > 0

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where CR_LIMIT > '0' on 1 with NOAUTORESET
   (7 PROSPECTS, 7 Pre-intersect   <time>)
Aggregate PROSPECTS using PI for COUNT(DISTINCT PROFESSION) on 1
Return COUNT(DISTINCT PROSPECTS.PROFESSION), '1'
-------------------------------------------------------------------------------
> ; <TEST=CD4>
> ;17
> select division, dept, count(distinct cost) from products \
 (cont) >   group by division, dept
----------------------------------- SUMMARY -----------------------------------
Select        DIVISION, \
              DEPT, \
              count(distinct COST) \
  from        PRODUCTS \
  group by    DIVISION, \
              DEPT

Version:      <version>
Optimization: AGGREGATION
----------------------------------- DETAILS -----------------------------------
Aggregate PRODUCTS using DDMC for GROUP(DIVISION), GROUP(DEPT), \
   COUNT(DISTINCT COST) on 1
Return PRODUCTS.DIVISION, PRODUCTS.DEPT, COUNT(DISTINCT PRODUCTS.COST)
-------------------------------------------------------------------------------
> ; <TEST=CD5>
> ;18
> select count(distinct order_date) from orders \
 (cont) >   where order_date > '01-01-1996' or quantity between 1 and 5 \
 (cont) >         or sales_tax < 4.00 \
 (cont) >   group by acct
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct ORDER_DATE) \
  from        ORDERS \
  where       ORDER_DATE > '01-01-1996' or \
              QUANTITY between 1 and 5 or \
              SALES_TAX < 4.00 \
  group by    ACCT

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where QUANTITY between '1' and '5' on 1 with NOAUTORESET
   (154 ORDERS, 154 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or SALES_TAX < '4.00' on 1 with NOAUTORESET
   (157 ORDERS, 50 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or ORDER_DATE > '01-01-1996' on 1 with NOAUTORESET
   (158 ORDERS, 8 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for GROUP(ACCT), COUNT(DISTINCT ORDER_DATE) \
   on 1
Return COUNT(DISTINCT ORDERS.ORDER_DATE)
-------------------------------------------------------------------------------
> ; <TEST=CD6>
> ;19
> select count(distinct total) from orders \
 (cont) >   group by order_date, discount having count(distinct total) > 1
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct TOTAL) \
  from        ORDERS \
  group by    ORDER_DATE, \
              DISCOUNT \
  having      count(distinct TOTAL) > 1

Version:      <version>
Optimization: AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(ORDER_DATE), GROUP(DISCOUNT), \
   COUNT(DISTINCT TOTAL) on 1 with ALT SORT
Filter COUNT(DISTINCT ORDERS.TOTAL) > 1
Return COUNT(DISTINCT ORDERS.TOTAL)
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=CD6r>
> ;20
> select count(distinct total) from orders \
 (cont) >   group by order_date, discount having count(distinct total) > 1
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct TOTAL) \
  from        ORDERS \
  group by    ORDER_DATE, \
              DISCOUNT \
  having      count(distinct TOTAL) > 1

Version:      <version>
Optimization: AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(ORDER_DATE), GROUP(DISCOUNT), \
   COUNT(DISTINCT TOTAL) on 1 with ALT SORT
Filter COUNT(DISTINCT ORDERS.TOTAL) > 1
Return COUNT(DISTINCT ORDERS.TOTAL)
-------------------------------------------------------------------------------
> ; <TEST=CD7>
> ; permuted sort>
> ;21
> select every 5 discount, order_date, count(distinct total) from orders \
 (cont) >   where tax_state in ('CO', 'CA', 'AZ') and \
 (cont) >         (discount >= 10 or (quantity < 100 and amount > 100)) \
 (cont) >   group by discount, order_date having count(distinct total) > 1 \
 (cont) >   order by 1, 2, 3
----------------------------------- SUMMARY -----------------------------------
Select        every 5 DISCOUNT, \
              ORDER_DATE, \
              count(distinct TOTAL) \
  from        ORDERS \
  where       TAX_STATE in ('CO', 'CA', 'AZ') and \
              (DISCOUNT >= 10 or \
               (QUANTITY < 100 and \
                AMOUNT > 100)) \
  group by    DISCOUNT, \
              ORDER_DATE \
  having      count(distinct TOTAL) > 1 \
  order by    1, \
              2, \
              3

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
Warnings:     UNOPTIMIZED_SORT
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where QUANTITY < '100' on 1 with NOAUTORESET
   (200 ORDERS, 200 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and AMOUNT > '100' on 1 with NOAUTORESET
   (144 ORDERS, 144 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or DISCOUNT >= '10' on 1 with NOAUTORESET
   (199 ORDERS, 199 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and TAX_STATE in ('CO','CA','AZ') on 1 with \
   NOAUTORESET
   (163 ORDERS, 163 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for GROUP(DISCOUNT), GROUP(ORDER_DATE), \
   COUNT(DISTINCT TOTAL) on 1 with ALT SORT
Filter COUNT(DISTINCT ORDERS.TOTAL) > 1
Pass to queue {1} [ORDERS.DISCOUNT, ORDERS.ORDER_DATE, COUNT(DISTINCT \
   ORDERS.TOTAL)]
Sort {1} for ORDER BY [ORDERS.DISCOUNT ASC, ORDERS.ORDER_DATE ASC, \
   COUNT(DISTINCT ORDERS.TOTAL) ASC]
Retrieve {1} sequentially
Return EVERY 5 ORDERS.DISCOUNT, ORDERS.ORDER_DATE, COUNT(DISTINCT ORDERS.TOTAL)
-------------------------------------------------------------------------------
> ;
> ;
> ;Tests un-optimized count(distinct col)
> ;
> ; <TEST=CD8>
> ;22
> select count(distinct dt) from activity
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct DT) \
  from        ACTIVITY

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where DT = 'all_keywds' on 1 with KEYWD
   (40 keywords   <time>)
Return COUNT(DISTINCT ACTIVITY.DT)
-------------------------------------------------------------------------------
> ; <TEST=CD9>
> ;23
> select count(distinct zip) from prospects \
 (cont) >   where cust_since <= 1992 and last_order >= '07-31-1998'
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct ZIP) \
  from        PROSPECTS \
  where       CUST_SINCE <= 1992 and \
              LAST_ORDER >= '07-31-1998'

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where CUST_SINCE <= '1992' on 1 with NOAUTORESET
   (1 PROSPECTS, 1 Pre-intersect   <time>)
Qualify (PROSPECTS)PROSPECTS where and LAST_ORDER >= '07-31-1998' on 1 with \
   NOAUTORESET
   (1 PROSPECTS, 4 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve PROSPECTS using $ROWID = $ODXID
 Pass to queue {1} [PROSPECTS.ZIP]
Sort {1} for DISTINCT [PROSPECTS.ZIP ASC]
Retrieve {1} sequentially
Return COUNT(DISTINCT PROSPECTS.ZIP)
-------------------------------------------------------------------------------
> ; <TEST=CD10>
> ;24
> select (1.0 / count(distinct acct)) * 100 from orders
----------------------------------- SUMMARY -----------------------------------
Select        1.0 / count(distinct ACCT) * 100 \
  from        ORDERS

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where ACCT = 'all_keywds' on 1 with KEYWD
   (3 keywords   <time>)
Return 1.0 / COUNT(DISTINCT ORDERS.ACCT) * 100
-------------------------------------------------------------------------------
> ;
> ;Multiple counts per statement
> ; <TEST=MC1>
> ;25
> select count(*), count(distinct acct), count(distinct discount_rt) from prospects
----------------------------------- SUMMARY -----------------------------------
Select        count(*), \
              count(distinct ACCT), \
              count(distinct DISCOUNT_RT) \
  from        PROSPECTS

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns
----------------------------------- DETAILS -----------------------------------
Retrieve PROSPECTS sequentially
Pass to queue {1} [PROSPECTS.ACCT]
Pass to queue {2} [PROSPECTS.ACCT]
Pass to queue {3} [PROSPECTS.DISCOUNT_RT]
Sort {1} for GROUP BY [PROSPECTS.ACCT ASC]
Sort {2} for DISTINCT [PROSPECTS.ACCT ASC]
Sort {3} for DISTINCT [PROSPECTS.DISCOUNT_RT ASC]
Retrieve {1} sequentially
Retrieve {2} sequentially
Retrieve {3} sequentially
Return COUNT('*'), COUNT(DISTINCT PROSPECTS.ACCT), COUNT(DISTINCT \
   PROSPECTS.DISCOUNT_RT)
-------------------------------------------------------------------------------
> ; <TEST=MC2>
> ;26
> select count(tax_state), count(distinct source) from orders
----------------------------------- SUMMARY -----------------------------------
Select        count(TAX_STATE), \
              count(distinct SOURCE) \
  from        ORDERS

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns
----------------------------------- DETAILS -----------------------------------
Retrieve ORDERS sequentially
Pass to queue {1} [ORDERS.TAX_STATE]
Pass to queue {2} [ORDERS.SOURCE]
Sort {1} for GROUP BY [ORDERS.TAX_STATE ASC]
Sort {2} for DISTINCT [ORDERS.SOURCE ASC]
Retrieve {1} sequentially
Retrieve {2} sequentially
Return COUNT(ORDERS.TAX_STATE), COUNT(DISTINCT ORDERS.SOURCE)
-------------------------------------------------------------------------------
> ; <TEST=MC3>
> ;27
> select count(distinct o.acct), count(o.amount), count(distinct s.description) \
 (cont) >   from orders o join statuses s using (status) \
 (cont) >   where o.pmt_method <= 2 and o.total >= 2000.00 \
 (cont) >         and s.description = 'Shipped' and o.source = 6
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct O.ACCT), \
              count(O.AMOUNT), \
              count(distinct S.DESCRIPTION) \
  from        ORDERS O \
  join        STATUSES S using (STATUS) \
  where       O.PMT_METHOD <= 2 and \
              O.TOTAL >= 2000.00 and \
              S.DESCRIPTION = 'Shipped' and \
              O.SOURCE = 6

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (STATUSES)STATUSES where DESCRIPTION = 'Shipped' on 1 with NOAUTORESET
   (1 STATUSES, 1 Pre-intersect   <time>)
Join STATUSES using STATUS to (ORDERS)ORDERS using STATUS on 1 with NOAUTORESET
   (192 ORDERS, 192 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and TOTAL >= '2000.00' on 1 with NOAUTORESET
   (41 ORDERS, 41 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and PMT_METHOD <= '2' on 1 with NOAUTORESET
   (6 ORDERS, 35 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and SOURCE = '6' on 1 with NOAUTORESET
   (4 ORDERS, 100 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (STATUSES)STATUSES where STATUS = O.STATUS on 2 with ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve STATUSES S using $ROWID = $ODXID
  Pass to queue {1} [O.AMOUNT]
  Pass to queue {2} [O.ACCT]
  Pass to queue {3} [S.DESCRIPTION]
Sort {1} for GROUP BY [O.AMOUNT ASC]
Sort {2} for DISTINCT [O.ACCT ASC]
Sort {3} for DISTINCT [S.DESCRIPTION ASC]
Retrieve {1} sequentially
Retrieve {2} sequentially
Retrieve {3} sequentially
Return COUNT(DISTINCT O.ACCT), COUNT(O.AMOUNT), COUNT(DISTINCT S.DESCRIPTION)
-------------------------------------------------------------------------------
> ; <TEST=MC4>
> ;28
> select count(distinct status), count(*), count(distinct status), \
 (cont) >   sum(distinct discount) \
 (cont) >   from orders \
 (cont) >   where ((order_date between '01-01-1996' and '12-31-1996' \
 (cont) >   and quantity > 10) or \
 (cont) >   (order_date between '01-01-1995'and '12-31-1995' \
 (cont) >   and (quantity > 10 or total > 10000))) and tax_state like 'CO'
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct STATUS), \
              count(*), \
              count(distinct STATUS), \
              sum(distinct DISCOUNT) \
  from        ORDERS \
  where       ((ORDER_DATE between '01-01-1996' and '12-31-1996' and \
                QUANTITY > 10) or \
               (ORDER_DATE between '01-01-1995' and '12-31-1995' and \
                (QUANTITY > 10 or \
                 TOTAL > 10000))) and \
              TAX_STATE like 'CO'

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where ORDER_DATE between '01-01-1996' and '12-31-1996' \
   on 1 with NOAUTORESET
   (7 ORDERS, 7 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and QUANTITY > '10' on 1 with NOAUTORESET
   (1 ORDERS, 32 Pre-intersect   <time>)
Export to queue O1 on 1 with ODXID
   (1 row exported   <time>)
Qualify (ORDERS)ORDERS where QUANTITY > '10' on 1 with NOAUTORESET
   (32 ORDERS, 32 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or TOTAL > '10000' on 1 with NOAUTORESET
   (35 ORDERS, 17 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and ORDER_DATE between '01-01-1995' and \
   '12-31-1995' on 1 with NOAUTORESET
   (7 ORDERS, 44 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or $ODXID = 'queue(O1)' on 1 with NOAUTORESET
   (8 ORDERS, 1 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and TAX_STATE = 'CO' on 1 with NOAUTORESET
   (6 ORDERS, 163 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.STATUS]
 Pass to queue {2} [ORDERS.STATUS]
 Pass to queue {3} [ORDERS.STATUS]
 Pass to queue {4} [ORDERS.DISCOUNT]
Sort {1} for GROUP BY [ORDERS.STATUS ASC]
Sort {2} for DISTINCT [ORDERS.STATUS ASC]
Sort {3} for DISTINCT [ORDERS.STATUS ASC]
Sort {4} for DISTINCT [ORDERS.DISCOUNT ASC]
Retrieve {1} sequentially
Retrieve {2} sequentially
Retrieve {3} sequentially
Retrieve {4} sequentially
Return COUNT(DISTINCT ORDERS.STATUS), COUNT('*'), COUNT(DISTINCT \
   ORDERS.STATUS), SUM(DISTINCT ORDERS.DISCOUNT)
-------------------------------------------------------------------------------
> ; <TEST=MC5>
> ;29
> select count(f.description), count(distinct f.description), max(p.last_order), \
 (cont) >   count(s.description), min(distinct income) \
 (cont) >   from prospects p, professions f, states s, zipcodes z \
 (cont) >   where (p.profession = f.profession and p.state = s.state \
 (cont) >         and p.zip = z.zip) and \
 (cont) >         ((p.state in ('KS', 'WA', 'CA', 'NE', 'OR', 'CO', 'UT', 'IL') \
 (cont) >         and (s.region = 'MW' or s.region = 'SW')) or (p.cust_since > 1995 \
 (cont) >         and (((f.description = 'Legal' or f.description = 'Finance') \
 (cont) >         and income < 7) or \
 (cont) >         (f.description in ('Educator', 'Clerical/Administrative', 'Retired') \
 (cont) >         and income > 7))))
----------------------------------- SUMMARY -----------------------------------
Select        count(F.DESCRIPTION), \
              count(distinct F.DESCRIPTION), \
              max(P.LAST_ORDER), \
              count(S.DESCRIPTION), \
              min(distinct INCOME) \
  from        PROSPECTS P, \
              PROFESSIONS F, \
              STATES S, \
              ZIPCODES Z \
  where       P.PROFESSION = F.PROFESSION and \
              P.STATE = S.STATE and \
              P.ZIP = Z.ZIP and \
              ((P.STATE in ('KS', 'WA', 'CA', 'NE', 'OR', 'CO', 'UT', 'IL') and \
                (S.REGION = 'MW' or \
                 S.REGION = 'SW')) or \
               (P.CUST_SINCE > 1995 and \
                (((F.DESCRIPTION = 'Legal' or \
                   F.DESCRIPTION = 'Finance') and \
                  INCOME < 7) or \
                 (F.DESCRIPTION in ('Educator', 'Clerical/Administrative', \
                   'Retired') and \
                  INCOME > 7))))

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (STATES)STATES where REGION = 'MW or SW' on 1 with NOAUTORESET
   (22 STATES, 22 Pre-intersect   <time>)
Join STATES using STATE to (PROSPECTS)PROSPECTS using STATE on 1 with \
   NOAUTORESET
   (9 PROSPECTS, 9 Pre-intersect   <time>)
Qualify (PROSPECTS)PROSPECTS where and STATE in ('KS','WA','CA','NE', \
   '''OR''','CO','UT','IL') on 1 with NOAUTORESET
   (5 PROSPECTS, 5 Pre-intersect   <time>)
Export to queue O2 on 1 with ODXID
   (5 rows exported   <time>)
Qualify (PROFESSIONS)PROFESSIONS where DESCRIPTION = 'Legal or Finance' on 1 \
   with NOAUTORESET
   (2 PROFESSIONS, 2 Pre-intersect   <time>)
Join PROFESSIONS using PROFESSION to (PROSPECTS)PROSPECTS using PROFESSION on \
   1 with NOAUTORESET
   (1 PROSPECTS, 1 Pre-intersect   <time>)
Qualify (PROSPECTS)PROSPECTS where and INCOME < '7' on 1 with NOAUTORESET
   (1 PROSPECTS, 5 Pre-intersect   <time>)
Export to queue O1 on 1 with ODXID
   (1 row exported   <time>)
Qualify (PROFESSIONS)PROFESSIONS where DESCRIPTION in ('Educator', \
   'Clerical/Administrative','Retired') on 1 with NOAUTORESET
   (3 PROFESSIONS, 3 Pre-intersect   <time>)
Join PROFESSIONS using PROFESSION to (PROSPECTS)PROSPECTS using PROFESSION on \
   1 with NOAUTORESET
   (4 PROSPECTS, 4 Pre-intersect   <time>)
Qualify (PROSPECTS)PROSPECTS where and INCOME > '7' on 1 with NOAUTORESET
   (1 PROSPECTS, 4 Pre-intersect   <time>)
Qualify (PROSPECTS)PROSPECTS where or $ODXID = 'queue(O1)' on 1 with \
   NOAUTORESET
   (2 PROSPECTS, 1 Pre-intersect   <time>)
Qualify (PROSPECTS)PROSPECTS where and CUST_SINCE > '1995' on 1 with \
   NOAUTORESET
   (2 PROSPECTS, 7 Pre-intersect   <time>)
Qualify (PROSPECTS)PROSPECTS where or $ODXID = 'queue(O2)' on 1 with \
   NOAUTORESET
   (7 PROSPECTS, 5 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ZIPCODES)ZIPCODES using ZIP on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Join ZIPCODES using ZIP to (PROSPECTS)PROSPECTS using ACCT on 1 with \
   NOAUTORESET,COUNT
   (7 PROSPECTS, 10 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve PROSPECTS P using $ROWID = $ODXID
  Qualify (PROFESSIONS)PROFESSIONS where PROFESSION = P.PROFESSION on 2 with \
     ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PROFESSIONS F using $ROWID = $ODXID
   Qualify (STATES)STATES where STATE = P.STATE on 3 with ASK NOAUTORESET
   Fetchkeys $ROWID 1000 at a time on 3
   Retrieve STATES S using $ROWID = $ODXID
    Qualify (ZIPCODES)ZIPCODES where ZIP = P.ZIP on 4 with ASK NOAUTORESET
    Fetchkeys $ROWID 1000 at a time on 4
    Retrieve ZIPCODES Z using $ROWID = $ODXID
    Pass to queue {1} [F.DESCRIPTION, P.LAST_ORDER, S.DESCRIPTION, P.INCOME]
    Pass to queue {2} [F.DESCRIPTION]
Sort {1} for GROUP BY [F.DESCRIPTION ASC]
Sort {2} for DISTINCT [F.DESCRIPTION ASC]
Retrieve {1} sequentially
Retrieve {2} sequentially
Return COUNT(F.DESCRIPTION), COUNT(DISTINCT F.DESCRIPTION), \
   MAX(P.LAST_ORDER), COUNT(S.DESCRIPTION), MIN(DISTINCT P.INCOME)
-------------------------------------------------------------------------------
> ; <TEST=MC6>
> ;30
> select sum(total), avg(amount), count(1), min(quantity), avg(total), count(*) \
 (cont) >   from orders where discount != 0 \
 (cont) >   group by acct order by 4, 1 with ask_retrieval_threshold = 10
----------------------------------- SUMMARY -----------------------------------
Select        sum(TOTAL), \
              avg(AMOUNT), \
              count(1), \
              min(QUANTITY), \
              avg(TOTAL), \
              count(*) \
  from        ORDERS \
  where       DISCOUNT <> 0 \
  group by    ACCT \
  order by    4, \
              1 \
  with        ASK_RETRIEVAL_THRESHOLD=10

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where DISCOUNT <> '0' on 1 with NOAUTORESET
   (199 ORDERS, 199 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for GROUP(ACCT), COUNT(*), MIN(QUANTITY), \
   AVG(AMOUNT), SUM(TOTAL), AVG(TOTAL) on 1
Pass to queue {1} [SUM(ORDERS.TOTAL), AVG(ORDERS.AMOUNT), COUNT(1), \
   MIN(ORDERS.QUANTITY), AVG(ORDERS.TOTAL), COUNT('*')]
Sort {1} for ORDER BY [MIN(ORDERS.QUANTITY) ASC, SUM(ORDERS.TOTAL) ASC]
Retrieve {1} sequentially
Return SUM(ORDERS.TOTAL), AVG(ORDERS.AMOUNT), COUNT(1), MIN(ORDERS.QUANTITY), \
   AVG(ORDERS.TOTAL), COUNT('*')
-------------------------------------------------------------------------------
> ; <TEST=MC7>
> ;31
> select count(distinct margin), count(distinct cost) from products \
 (cont) >   where category > 10
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct MARGIN), \
              count(distinct COST) \
  from        PRODUCTS \
  where       CATEGORY > 10

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where CATEGORY > '10' on 1 with NOAUTORESET
   (100 PRODUCTS, 100 Pre-intersect   <time>)
Export to queue O1 on 1 with ODXID
Aggregate PRODUCTS using DDMC for COUNT(DISTINCT MARGIN) on 1
Qualify (PRODUCTS)PRODUCTS where $ODXID = 'queue(O1)' on 2 with NOAUTORESET
Aggregate PRODUCTS using DDMC for COUNT(DISTINCT COST) on 2
Return COUNT(DISTINCT PRODUCTS.MARGIN), COUNT(DISTINCT PRODUCTS.COST)
-------------------------------------------------------------------------------
> ; <TEST=MC8>
> ;32
> select count(distinct profession), count(distinct cust_since), \
 (cont) >        count(distinct last_order) from prospects
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct PROFESSION), \
              count(distinct CUST_SINCE), \
              count(distinct LAST_ORDER) \
  from        PROSPECTS

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns
----------------------------------- DETAILS -----------------------------------
Retrieve PROSPECTS sequentially
Pass to queue {1} [PROSPECTS.PROFESSION]
Pass to queue {2} [PROSPECTS.CUST_SINCE]
Pass to queue {3} [PROSPECTS.LAST_ORDER]
Sort {1} for DISTINCT [PROSPECTS.PROFESSION ASC]
Sort {2} for DISTINCT [PROSPECTS.CUST_SINCE ASC]
Sort {3} for DISTINCT [PROSPECTS.LAST_ORDER ASC]
Retrieve {1} sequentially
Retrieve {2} sequentially
Retrieve {3} sequentially
Return COUNT(DISTINCT PROSPECTS.PROFESSION), COUNT(DISTINCT \
   PROSPECTS.CUST_SINCE), COUNT(DISTINCT PROSPECTS.LAST_ORDER)
-------------------------------------------------------------------------------
> ; <TEST=MC9>
> ;33
> select count(distinct quantity), count(distinct sales_tax), \
 (cont) >   count(distinct amount), count(distinct acct) from orders
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct QUANTITY), \
              count(distinct SALES_TAX), \
              count(distinct AMOUNT), \
              count(distinct ACCT) \
  from        ORDERS

Version:      <version>
Optimization: AGGREGATION
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for COUNT(DISTINCT QUANTITY) on 1
Aggregate ORDERS using APOSTDQSAT for COUNT(DISTINCT SALES_TAX) on 2
Aggregate ORDERS using APOSTDQSAT for COUNT(DISTINCT AMOUNT) on 3
Aggregate ORDERS using APOSTDQSAT for COUNT(DISTINCT ACCT) on 4
Return COUNT(DISTINCT ORDERS.QUANTITY), COUNT(DISTINCT ORDERS.SALES_TAX), \
   COUNT(DISTINCT ORDERS.AMOUNT), COUNT(DISTINCT ORDERS.ACCT)
-------------------------------------------------------------------------------
> ; <TEST=MC10>
> ;34
> select count(distinct total), count(distinct product_no), count(distinct quantity), \
 (cont) >   count(distinct order_date) from orders \
 (cont) >   where tax_state in ('CO', 'CA', 'AZ') and \
 (cont) >         (discount >= 10 or (quantity < 100 and amount > 100)) \
 (cont) >   group by acct
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct TOTAL), \
              count(distinct PRODUCT_NO), \
              count(distinct QUANTITY), \
              count(distinct ORDER_DATE) \
  from        ORDERS \
  where       TAX_STATE in ('CO', 'CA', 'AZ') and \
              (DISCOUNT >= 10 or \
               (QUANTITY < 100 and \
                AMOUNT > 100)) \
  group by    ACCT

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where QUANTITY < '100' on 1 with NOAUTORESET
   (200 ORDERS, 200 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and AMOUNT > '100' on 1 with NOAUTORESET
   (144 ORDERS, 144 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or DISCOUNT >= '10' on 1 with NOAUTORESET
   (199 ORDERS, 199 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and TAX_STATE in ('CO','CA','AZ') on 1 with \
   NOAUTORESET
   (163 ORDERS, 163 Pre-intersect   <time>)
Export to queue O1 on 1 with ODXID
Aggregate ORDERS using APOSTDQSAT for GROUP(ACCT), COUNT(DISTINCT TOTAL) on 1
Qualify (ORDERS)ORDERS where $ODXID = 'queue(O1)' on 2 with NOAUTORESET
Aggregate ORDERS using APOSTDQSAT for GROUP(ACCT), COUNT(DISTINCT PRODUCT_NO) \
   on 2
Qualify (ORDERS)ORDERS where $ODXID = 'queue(O1)' on 3 with NOAUTORESET
Aggregate ORDERS using APOSTDQSAT for GROUP(ACCT), COUNT(DISTINCT QUANTITY) \
   on 3
Qualify (ORDERS)ORDERS where $ODXID = 'queue(O1)' on 4 with NOAUTORESET
Aggregate ORDERS using APOSTDQSAT for GROUP(ACCT), COUNT(DISTINCT ORDER_DATE) \
   on 4
Return COUNT(DISTINCT ORDERS.TOTAL), COUNT(DISTINCT ORDERS.PRODUCT_NO), \
   COUNT(DISTINCT ORDERS.QUANTITY), COUNT(DISTINCT ORDERS.ORDER_DATE)
-------------------------------------------------------------------------------
> ;
> ;
> ; <SECTION=KEYWD_OPTIMIZATION>
> ;
> ;Tests use of KEYWD option (dist ;np col; group by col; count() group by col)
> ; order by is supported ONLY if the order column is the select column
> ;
> ; KEYWD
> ; <TEST=K1>
> ;  NP c string>
> ;35
> select distinct zip from prospects
----------------------------------- SUMMARY -----------------------------------
Select        distinct ZIP \
  from        PROSPECTS

Version:      <version>
Optimization: MDKQUAL
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where ZIP = 'all_keywds' on 1 with KEYWD
   (10 keywords   <time>)
Fetchkeys ZIP 1000 at a time on 1
Return PROSPECTS.ZIP
-------------------------------------------------------------------------------
> ; <TEST=K2>
> ; odx date
> ;36
> select top 25% distinct dt from activity
----------------------------------- SUMMARY -----------------------------------
Select        top 25 % distinct DT \
  from        ACTIVITY

Version:      <version>
Optimization: MDKQUAL
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where DT = 'all_keywds' on 1 with KEYWD
   (40 keywords   <time>)
Fetchkeys DT 1000 at a time on 1
Pass to queue {1} [ACTIVITY.DT]
Retrieve {1} sequentially
Return TOP 25% ACTIVITY.DT
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=K2r>
> ;37
> select top 25% distinct dt from activity
----------------------------------- SUMMARY -----------------------------------
Select        top 25 % distinct DT \
  from        ACTIVITY

Version:      <version>
Optimization: MDKQUAL
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where DT = 'all_keywds' on 1 with KEYWD
   (40 keywords   <time>)
Fetchkeys DT 1000 at a time on 1
Pass to queue {1} [ACTIVITY.DT]
Retrieve {1} sequentially
Return TOP 25% ACTIVITY.DT
-------------------------------------------------------------------------------
> ; <TEST=K3>
> ;  int 1
> ;38
> select distinct category from products order by category
----------------------------------- SUMMARY -----------------------------------
Select        distinct CATEGORY \
  from        PRODUCTS \
  order by    CATEGORY

Version:      <version>
Optimization: MDKQUAL
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where CATEGORY = 'all_keywds' on 1 with KEYWD
   (30 keywords   <time>)
Fetchkeys CATEGORY 1000 at a time on 1
Return PRODUCTS.CATEGORY
-------------------------------------------------------------------------------
> ; KWCOUNT
> ; <TEST=K4>
> ;  float
> ;39
> select count(*) from orders group by sales_tax
----------------------------------- SUMMARY -----------------------------------
Select        count(*) \
  from        ORDERS \
  group by    SALES_TAX

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where SALES_TAX = 'all_keywds' on 1 with KEYWD
   (111 keywords   <time>)
Fetchkeys SALES_TAX 1000 at a time on 1
Return COUNT('*')
-------------------------------------------------------------------------------
> ; <TEST=K5>
> ;
> ;40
> select category, count(*) from products group by category
----------------------------------- SUMMARY -----------------------------------
Select        CATEGORY, \
              count(*) \
  from        PRODUCTS \
  group by    CATEGORY

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where CATEGORY = 'all_keywds' on 1 with KEYWD
   (30 keywords   <time>)
Fetchkeys CATEGORY 1000 at a time on 1
Return PRODUCTS.CATEGORY, COUNT('*')
-------------------------------------------------------------------------------
> ; KWPCOUNT
> ; <TEST=K6>
> ;  int 4 si
> ;41
> select count(distinct acct) from orders group by source
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct ACCT) \
  from        ORDERS \
  group by    SOURCE

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns
----------------------------------- DETAILS -----------------------------------
Retrieve ORDERS sequentially
Pass to queue {1} [ORDERS.SOURCE]
Pass to queue {2} [ORDERS.SOURCE, ORDERS.ACCT]
Sort {1} for GROUP BY [ORDERS.SOURCE ASC]
Sort {2} for DISTINCT [ORDERS.SOURCE ASC, ORDERS.ACCT ASC]
Merge queues {1}, {2}
Return COUNT(DISTINCT ORDERS.ACCT)
-------------------------------------------------------------------------------
> ; <TEST=K7>
> ;  odx date si
> ;42
> select quantity, count(order_date), count(distinct order_date) from orders \
 (cont) >  group by quantity
----------------------------------- SUMMARY -----------------------------------
Select        QUANTITY, \
              count(ORDER_DATE), \
              count(distinct ORDER_DATE) \
  from        ORDERS \
  group by    QUANTITY

Version:      <version>
Optimization: AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(QUANTITY), COUNT(ORDER_DATE), \
   COUNT(DISTINCT ORDER_DATE) on 1 with ALT SORT
Return ORDERS.QUANTITY, COUNT(ORDERS.ORDER_DATE), COUNT(DISTINCT \
   ORDERS.ORDER_DATE)
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=K7r>
> ;43
> select quantity, count(order_date), count(distinct order_date) from orders \
 (cont) >  group by quantity
----------------------------------- SUMMARY -----------------------------------
Select        QUANTITY, \
              count(ORDER_DATE), \
              count(distinct ORDER_DATE) \
  from        ORDERS \
  group by    QUANTITY

Version:      <version>
Optimization: AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(QUANTITY), COUNT(ORDER_DATE), \
   COUNT(DISTINCT ORDER_DATE) on 1 with ALT SORT
Return ORDERS.QUANTITY, COUNT(ORDERS.ORDER_DATE), COUNT(DISTINCT \
   ORDERS.ORDER_DATE)
-------------------------------------------------------------------------------
> ;Make sure we don't try on non-NP colums
> ; <TEST=K8>
> ;44
> select distinct city from prospects
----------------------------------- SUMMARY -----------------------------------
Select        distinct CITY \
  from        PROSPECTS

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
----------------------------------- DETAILS -----------------------------------
Retrieve PROSPECTS sequentially
Pass to queue {1} [PROSPECTS.CITY]
Sort {1} for DISTINCT [PROSPECTS.CITY ASC]
Retrieve {1} sequentially
Return PROSPECTS.CITY
-------------------------------------------------------------------------------
> ; <TEST=K9>
> ;45
> select city, count(*) from prospects group by city
----------------------------------- SUMMARY -----------------------------------
Select        CITY, \
              count(*) \
  from        PROSPECTS \
  group by    CITY

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
Notes:        Unable to optimize COUNT because index CITY is Parsed, Exclude,
                Translate.
----------------------------------- DETAILS -----------------------------------
Retrieve PROSPECTS sequentially
Pass to queue {1} [PROSPECTS.CITY]
Sort {1} for GROUP BY [PROSPECTS.CITY ASC]
Retrieve {1} sequentially
Return PROSPECTS.CITY, COUNT('*')
-------------------------------------------------------------------------------
> ; <TEST=K10>
> ;46
> select tax_state, count(distinct acct) from orders group by tax_state
----------------------------------- SUMMARY -----------------------------------
Select        TAX_STATE, \
              count(distinct ACCT) \
  from        ORDERS \
  group by    TAX_STATE

Version:      <version>
Optimization: AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(TAX_STATE), COUNT(DISTINCT ACCT) \
   on 1 with ALT SORT
Return ORDERS.TAX_STATE, COUNT(DISTINCT ORDERS.ACCT)
-------------------------------------------------------------------------------
> ;
> ;
> ; <SECTION=DISTINCT(COL-LIST)>
> ;
> ;Tests optimized "distinct imsam-col(s) order by imsam-col(s)"
> ; uses agg index; only works if all the select items are order items
> ; and order by is same order as components
> ;
> ; <TEST=DO1>
> ;47
> select distinct profession, income from prospects order by 1, 2
----------------------------------- SUMMARY -----------------------------------
Select        distinct PROFESSION, \
              INCOME \
  from        PROSPECTS \
  order by    1, \
              2

Version:      <version>
Optimization: AGGREGATION
----------------------------------- DETAILS -----------------------------------
Aggregate PROSPECTS using PI for GROUP(PROFESSION), GROUP(INCOME) on 1
Return PROSPECTS.PROFESSION, PROSPECTS.INCOME
-------------------------------------------------------------------------------
> ; <TEST=DO2>
> ;48
> select top 10 distinct total, status from orders order by 2, 1
----------------------------------- SUMMARY -----------------------------------
Select        top 10 distinct TOTAL, \
              STATUS \
  from        ORDERS \
  order by    2, \
              1

Version:      <version>
Optimization: AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(STATUS), GROUP(TOTAL) on 1 with \
   ALT SORT
Return TOP 10 ORDERS.TOTAL, ORDERS.STATUS
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=DO2r>
> ;49
> select top 10 distinct total, status from orders order by 2, 1
----------------------------------- SUMMARY -----------------------------------
Select        top 10 distinct TOTAL, \
              STATUS \
  from        ORDERS \
  order by    2, \
              1

Version:      <version>
Optimization: AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(STATUS), GROUP(TOTAL) on 1 with \
   ALT SORT
Return TOP 10 ORDERS.TOTAL, ORDERS.STATUS
-------------------------------------------------------------------------------
> ; <TEST=DO3>
> ;50
> select distinct order_date, discount, quantity, total from orders \
 (cont) >  order by 1,2,3,4
----------------------------------- SUMMARY -----------------------------------
Select        distinct ORDER_DATE, \
              DISCOUNT, \
              QUANTITY, \
              TOTAL \
  from        ORDERS \
  order by    1, \
              2, \
              3, \
              4

Version:      <version>
Optimization: AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(ORDER_DATE), GROUP(DISCOUNT), \
   GROUP(QUANTITY), GROUP(TOTAL) on 1 with ALT SORT
Return ORDERS.ORDER_DATE, ORDERS.DISCOUNT, ORDERS.QUANTITY, ORDERS.TOTAL
-------------------------------------------------------------------------------
> ;
> ;Tests distinct col-list (un-optimized)
> ;
> ; <TEST=DC1>
> ;51
> select distinct * from prospects
----------------------------------- SUMMARY -----------------------------------
Select        distinct * \
  from        PROSPECTS

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
----------------------------------- DETAILS -----------------------------------
Retrieve PROSPECTS sequentially
Pass to queue {1} [PROSPECTS.ACCT, PROSPECTS.COMPANY_ID, PROSPECTS.COMPANY, \
   PROSPECTS.CONTACT, PROSPECTS.CITY, PROSPECTS.STATE, PROSPECTS.ZIP, \
   PROSPECTS.REGION, PROSPECTS.COUNTRY, PROSPECTS.PHONE, PROSPECTS.GENDER, \
   PROSPECTS.MAILFLAG, PROSPECTS.MAILING, PROSPECTS.PROFESSION, \
   PROSPECTS.INCOME, PROSPECTS.PROFILE, PROSPECTS.PREFERRED, \
   PROSPECTS.FRQ_BUY_MBR, PROSPECTS.CR_LIMIT, PROSPECTS.DISCOUNT_RT, \
   PROSPECTS.CUST_SINCE, PROSPECTS.LAST_ORDER, PROSPECTS.SEARCH_KEY, \
   PROSPECTS.COMPANY_SDX]
Sort {1} for DISTINCT [PROSPECTS.ACCT ASC, PROSPECTS.COMPANY_ID ASC, \
   PROSPECTS.COMPANY ASC, PROSPECTS.CONTACT ASC, PROSPECTS.CITY ASC, \
   PROSPECTS.STATE ASC, PROSPECTS.ZIP ASC, PROSPECTS.REGION ASC, \
   PROSPECTS.COUNTRY ASC, PROSPECTS.PHONE ASC, PROSPECTS.GENDER ASC, \
   PROSPECTS.MAILFLAG ASC, PROSPECTS.MAILING ASC, PROSPECTS.PROFESSION ASC, \
   PROSPECTS.INCOME ASC, PROSPECTS.PROFILE ASC, PROSPECTS.PREFERRED ASC, \
   PROSPECTS.FRQ_BUY_MBR ASC, PROSPECTS.CR_LIMIT ASC, PROSPECTS.DISCOUNT_RT \
   ASC, PROSPECTS.CUST_SINCE ASC, PROSPECTS.LAST_ORDER ASC, \
   PROSPECTS.SEARCH_KEY ASC, PROSPECTS.COMPANY_SDX ASC]
Retrieve {1} sequentially
Return PROSPECTS.ACCT, PROSPECTS.COMPANY_ID, PROSPECTS.COMPANY, \
   PROSPECTS.CONTACT, PROSPECTS.CITY, PROSPECTS.STATE, PROSPECTS.ZIP, \
   PROSPECTS.REGION, PROSPECTS.COUNTRY, PROSPECTS.PHONE, PROSPECTS.GENDER, \
   PROSPECTS.MAILFLAG, PROSPECTS.MAILING, PROSPECTS.PROFESSION, \
   PROSPECTS.INCOME, PROSPECTS.PROFILE, PROSPECTS.PREFERRED, \
   PROSPECTS.FRQ_BUY_MBR, PROSPECTS.CR_LIMIT, PROSPECTS.DISCOUNT_RT, \
   PROSPECTS.CUST_SINCE, PROSPECTS.LAST_ORDER, PROSPECTS.SEARCH_KEY, \
   PROSPECTS.COMPANY_SDX
-------------------------------------------------------------------------------
> ; <TEST=DC2>
> ;52
> select distinct discount_rt from prospects
----------------------------------- SUMMARY -----------------------------------
Select        distinct DISCOUNT_RT \
  from        PROSPECTS

Version:      <version>
Optimization: MDKQUAL
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where DISCOUNT_RT = 'all_keywds' on 1 with KEYWD
   (4 keywords   <time>)
Fetchkeys DISCOUNT_RT 1000 at a time on 1
Return PROSPECTS.DISCOUNT_RT
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=DC2r>
> ;53
> select distinct discount_rt from prospects
----------------------------------- SUMMARY -----------------------------------
Select        distinct DISCOUNT_RT \
  from        PROSPECTS

Version:      <version>
Optimization: MDKQUAL
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where DISCOUNT_RT = 'all_keywds' on 1 with KEYWD
   (4 keywords   <time>)
Fetchkeys DISCOUNT_RT 1000 at a time on 1
Return PROSPECTS.DISCOUNT_RT
-------------------------------------------------------------------------------
> ; <TEST=DC3>
> ;54
> select distinct tickler, 0, initials from activity \
 (cont) >  where initials = 'EFR' or tickler in ('MF', 'PC', 'RC')
----------------------------------- SUMMARY -----------------------------------
Select        distinct TICKLER, \
              0, \
              INITIALS \
  from        ACTIVITY \
  where       INITIALS = 'EFR' or \
              TICKLER in ('MF', 'PC', 'RC')

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where INITIALS = 'EFR' on 1 with NOAUTORESET
   (1 ACTIVITY, 1 Pre-intersect   <time>)
Qualify (ACTIVITY)ACTIVITY where or TICKLER in ('MF','PC','RC') on 1 with \
   NOAUTORESET
   (6 ACTIVITY, 0 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ACTIVITY using $ROWID = $ODXID
 Pass to queue {1} [ACTIVITY.TICKLER, ACTIVITY.INITIALS]
Sort {1} for DISTINCT [ACTIVITY.TICKLER ASC, ACTIVITY.INITIALS ASC]
Retrieve {1} sequentially
Return ACTIVITY.TICKLER, 0, ACTIVITY.INITIALS
-------------------------------------------------------------------------------
> ; <TEST=DC4>
> ;55
> select distinct division, dept from products \
 (cont) >  where margin > 30 \
 (cont) >  order by 2,1
----------------------------------- SUMMARY -----------------------------------
Select        distinct DIVISION, \
              DEPT \
  from        PRODUCTS \
  where       MARGIN > 30 \
  order by    2, \
              1

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
Notes:        The aggregation on DDMC required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where MARGIN > '30' on 1 with NOAUTORESET
   (52 PRODUCTS, 52 Pre-intersect   <time>)
Aggregate PRODUCTS using DDMC for GROUP(DEPT), GROUP(DIVISION) on 1 with ALT \
   SORT
Return PRODUCTS.DIVISION, PRODUCTS.DEPT
-------------------------------------------------------------------------------
> ; expressions
> ; <TEST=DE1>
> ;56
> select distinct cost * 100 from products
----------------------------------- SUMMARY -----------------------------------
Select        distinct COST * 100 \
  from        PRODUCTS

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
----------------------------------- DETAILS -----------------------------------
Retrieve PRODUCTS sequentially
Pass to queue {1} [PRODUCTS.COST * 100]
Sort {1} for DISTINCT [PRODUCTS.COST * 100 ASC]
Retrieve {1} sequentially
Return PRODUCTS.COST * 100
-------------------------------------------------------------------------------
> ; <TEST=DE2>
> ;57
> select distinct discount / 100.0 from orders \
 (cont) >  where (tax_state in ('CO', 'CA', 'AZ') and \
 (cont) >        discount >= 10) or (quantity < 100 and amount > 100)
----------------------------------- SUMMARY -----------------------------------
Select        distinct DISCOUNT / 100.0 \
  from        ORDERS \
  where       (TAX_STATE in ('CO', 'CA', 'AZ') and \
               DISCOUNT >= 10) or \
              (QUANTITY < 100 and \
               AMOUNT > 100)

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where TAX_STATE in ('CO','CA','AZ') on 1 with \
   NOAUTORESET
   (163 ORDERS, 163 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and DISCOUNT >= '10' on 1 with NOAUTORESET
   (163 ORDERS, 199 Pre-intersect   <time>)
Export to queue O1 on 1 with ODXID
   (163 rows exported   <time>)
Qualify (ORDERS)ORDERS where QUANTITY < '100' on 1 with NOAUTORESET
   (200 ORDERS, 200 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and AMOUNT > '100' on 1 with NOAUTORESET
   (144 ORDERS, 144 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or $ODXID = 'queue(O1)' on 1 with NOAUTORESET
   (189 ORDERS, 163 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.DISCOUNT / 100.0]
Sort {1} for DISTINCT [ORDERS.DISCOUNT / 100.0 ASC]
Retrieve {1} sequentially
Return ORDERS.DISCOUNT / 100.0
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=DE2r>
> ;58
> select distinct discount / 100.0 from orders \
 (cont) >  where (tax_state in ('CO', 'CA', 'AZ') and \
 (cont) >        discount >= 10) or (quantity < 100 and amount > 100)
----------------------------------- SUMMARY -----------------------------------
Select        distinct DISCOUNT / 100.0 \
  from        ORDERS \
  where       (TAX_STATE in ('CO', 'CA', 'AZ') and \
               DISCOUNT >= 10) or \
              (QUANTITY < 100 and \
               AMOUNT > 100)

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where TAX_STATE in ('CO','CA','AZ') on 1 with \
   NOAUTORESET
   (163 ORDERS, 163 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and DISCOUNT >= '10' on 1 with NOAUTORESET
   (163 ORDERS, 199 Pre-intersect   <time>)
Export to queue O1 on 1 with ODXID
   (163 rows exported   <time>)
Qualify (ORDERS)ORDERS where QUANTITY < '100' on 1 with NOAUTORESET
   (200 ORDERS, 200 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and AMOUNT > '100' on 1 with NOAUTORESET
   (144 ORDERS, 144 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or $ODXID = 'queue(O1)' on 1 with NOAUTORESET
   (189 ORDERS, 163 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.DISCOUNT / 100.0]
Sort {1} for DISTINCT [ORDERS.DISCOUNT / 100.0 ASC]
Retrieve {1} sequentially
Return ORDERS.DISCOUNT / 100.0
-------------------------------------------------------------------------------
> ; outside the aggregation
> ; <TEST=DE3>
> ;59
> select distinct region, avg(discount_rt) / 100.0 from prospects \
 (cont) >  group by region \
 (cont) > having REGION not in ('MW','SW') and avg(discount_rt) / 100.0 <> 0.0
----------------------------------- SUMMARY -----------------------------------
Select        distinct REGION, \
              avg(DISCOUNT_RT) / 100.0 \
  from        PROSPECTS \
  group by    REGION \
  having      REGION not in ('MW', 'SW') and \
              avg(DISCOUNT_RT) / 100.0 <> 0.0

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
Notes:        Use the HAVING clause to restrict which groups of rows defined by
                a group by clause are returned from the query.
              DISTINCT processing bypassed because Group By items match Select
                items.
----------------------------------- DETAILS -----------------------------------
Retrieve PROSPECTS sequentially
Pass to queue {1} [PROSPECTS.REGION, PROSPECTS.DISCOUNT_RT, PROSPECTS.REGION]
Sort {1} for GROUP BY [PROSPECTS.REGION ASC]
Retrieve {1} sequentially
Filter NOT PROSPECTS.REGION IN ('MW','SW')
Filter AVG(PROSPECTS.DISCOUNT_RT) / 100.0 <> 0.0
Filter FILTER 0 AND FILTER 1
Return PROSPECTS.REGION, AVG(PROSPECTS.DISCOUNT_RT) / 100.0
-------------------------------------------------------------------------------
> ; <TEST=DE4>
> ;60
> select distinct sum(total) as sumtotal from orders \
 (cont) >  group by acct \
 (cont) > having sumtotal < 100.00
----------------------------------- SUMMARY -----------------------------------
Select        distinct sum(TOTAL) SUMTOTAL \
  from        ORDERS \
  group by    ACCT \
  having      SUMTOTAL < 100.00

Version:      <version>
Optimization: AGGREGATION
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using AT for GROUP(ACCT), SUM(TOTAL) HAVING \
   SUM(ORDERS.TOTAL) < 100.00 on 1
Pass to queue {1} [SUM(ORDERS.TOTAL)]
Sort {1} for DISTINCT [SUM(ORDERS.TOTAL) ASC]
Retrieve {1} sequentially
Return SUMTOTAL
-------------------------------------------------------------------------------
> ; <TEST=DE5>
> ;61
> select distinct min(discount_rt) from prospects \
 (cont) >  where cust_since <= 1992 and last_order >= '07-31-1998' \
 (cont) >  order by 1
----------------------------------- SUMMARY -----------------------------------
Select        distinct min(DISCOUNT_RT) \
  from        PROSPECTS \
  where       CUST_SINCE <= 1992 and \
              LAST_ORDER >= '07-31-1998' \
  order by    1

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION
Notes:        DISTINCT processing bypassed because result set contains 1 row.
              Optimized aggregations are not possible because no ASK index
                contains all columns
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where CUST_SINCE <= '1992' on 1 with NOAUTORESET
   (1 PROSPECTS, 1 Pre-intersect   <time>)
Qualify (PROSPECTS)PROSPECTS where and LAST_ORDER >= '07-31-1998' on 1 with \
   NOAUTORESET
   (1 PROSPECTS, 4 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve PROSPECTS using $ROWID = $ODXID
Return MIN(PROSPECTS.DISCOUNT_RT)
-------------------------------------------------------------------------------
> ;
> ; multiple tables
> ; <TEST=DMT1>
> ;62
> select distinct contact, tickler, initials from activity a join prospects p \
 (cont) >   using (acct)
----------------------------------- SUMMARY -----------------------------------
Select        distinct CONTACT, \
              TICKLER, \
              INITIALS \
  from        ACTIVITY A \
  join        PROSPECTS P using (ACCT)

Version:      <version>
Optimization: ASKLINK
Warnings:     UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns and all links to dimension tables
----------------------------------- DETAILS -----------------------------------
Retrieve ACTIVITY A sequentially
 Qualify (PROSPECTS)PROSPECTS where ACCT = A.ACCT on 2 with ASK NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve PROSPECTS P using $ROWID = $ODXID
 Pass to queue {1} [P.CONTACT, A.TICKLER, A.INITIALS]
Sort {1} for DISTINCT [P.CONTACT ASC, A.TICKLER ASC, A.INITIALS ASC]
Retrieve {1} sequentially
Return P.CONTACT, A.TICKLER, A.INITIALS
-------------------------------------------------------------------------------
> ; <TEST=DMT2>
> ;63
> select distinct contact, source from prospects p, orders o \
 (cont) >  where o.acct = p.acct and \
 (cont) >        p.last_order <= '12-31-1996' and \
 (cont) >        ((p.region = 'MW' or o.tax_state in ('CO', 'KS', 'NE', 'IL')) \
 (cont) >         and (o.total >= 1000.00 or o.quantity > 100)) \
 (cont) >  order by contact
----------------------------------- SUMMARY -----------------------------------
Select        distinct CONTACT, \
              SOURCE \
  from        PROSPECTS P, \
              ORDERS O \
  where       O.ACCT = P.ACCT and \
              P.LAST_ORDER <= '12-31-1996' and \
              ((P.REGION = 'MW' or \
                O.TAX_STATE in ('CO', 'KS', 'NE', 'IL')) and \
               (O.TOTAL >= 1000.00 or \
                O.QUANTITY > 100)) \
  order by    CONTACT

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_SORT
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns and all links to dimension tables
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where REGION = 'MW' on 1 with NOAUTORESET
   (5 PROSPECTS, 5 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or TAX_STATE in ('CO','KS','NE','IL') on 1 with \
   NOAUTORESET
   (200 ORDERS, 164 Pre-intersect   <time>)
Export to queue O1 on 1 with ODXID
   (200 rows exported   <time>)
Qualify (ORDERS)ORDERS where TOTAL >= '1000.00' on 1 with NOAUTORESET
   (76 ORDERS, 76 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY > '100' on 1 with NOAUTORESET
   (76 ORDERS, 0 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PROSPECTS)PROSPECTS using ACCT on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PROSPECTS)PROSPECTS where and LAST_ORDER <= '12-31-1996' on 1 with \
   NOAUTORESET,PRESERVERS
   (11 ORDERS, 1 PROSPECTS, 2 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where and $ODXID = 'queue(O1)' on 1 with NOAUTORESET
   (11 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PROSPECTS P using $ROWID = $ODXID
  Pass to queue {1} [P.CONTACT, O.SOURCE]
Sort {1} for DISTINCT [P.CONTACT ASC, O.SOURCE ASC]
Retrieve {1} sequentially
Pass to queue {2} [P.CONTACT, O.SOURCE]
Sort {2} for ORDER BY [P.CONTACT ASC]
Retrieve {2} sequentially
Return P.CONTACT, O.SOURCE
-------------------------------------------------------------------------------
> ; <TEST=DMT3>
> ;64
> select top 3 distinct cost * quantity, total  from products p, orders o \
 (cont) >  where p.product_no = o.product_no and \
 (cont) >        (o.quantity >= 10 or p.wholesale > 1000.00) \
 (cont) >  order by total
----------------------------------- SUMMARY -----------------------------------
Select        top 3 distinct COST * QUANTITY, \
              TOTAL \
  from        PRODUCTS P, \
              ORDERS O \
  where       P.PRODUCT_NO = O.PRODUCT_NO and \
              (O.QUANTITY >= 10 or \
               P.WHOLESALE > 1000.00) \
  order by    TOTAL

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_SORT
Notes:        Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where WHOLESALE > '1000.00' on 1 with NOAUTORESET
   (11 PRODUCTS, 11 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY >= '10' on 1 with NOAUTORESET
   (80 ORDERS, 35 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (80 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PRODUCTS P using $ROWID = $ODXID
  Pass to queue {1} [P.COST * O.QUANTITY, O.TOTAL]
Sort {1} for DISTINCT [P.COST * O.QUANTITY ASC, O.TOTAL ASC]
Retrieve {1} sequentially
Pass to queue {2} [P.COST * O.QUANTITY, O.TOTAL]
Sort {2} for ORDER BY [O.TOTAL ASC]
Retrieve {2} sequentially
Return TOP 3 P.COST * O.QUANTITY, O.TOTAL
-------------------------------------------------------------------------------
> ; <TEST=DMT4>
> ;65
> select distinct category, avg(wholesale), avg(total) from products p, orders o \
 (cont) >  where p.product_no = o.product_no and \
 (cont) >        (o.quantity >= 10 or p.wholesale > 1000.00) \
 (cont) >  group by category
----------------------------------- SUMMARY -----------------------------------
Select        distinct CATEGORY, \
              avg(WHOLESALE), \
              avg(TOTAL) \
  from        PRODUCTS P, \
              ORDERS O \
  where       P.PRODUCT_NO = O.PRODUCT_NO and \
              (O.QUANTITY >= 10 or \
               P.WHOLESALE > 1000.00) \
  group by    CATEGORY

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        DISTINCT processing bypassed because Group By items match Select
                items.
              Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where WHOLESALE > '1000.00' on 1 with NOAUTORESET
   (11 PRODUCTS, 11 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY >= '10' on 1 with NOAUTORESET
   (80 ORDERS, 35 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (80 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PRODUCTS P using $ROWID = $ODXID
  Pass to queue {1} [P.CATEGORY, P.WHOLESALE, O.TOTAL]
Sort {1} for GROUP BY [P.CATEGORY ASC]
Retrieve {1} sequentially
Return P.CATEGORY, AVG(P.WHOLESALE), AVG(O.TOTAL)
-------------------------------------------------------------------------------
> ; <TEST=DMT5>
> ;66
> select distinct sum(p.discount_rt/100.0 * o.amount) from orders o join prospects p \
 (cont) >  on p.acct = o.acct \
 (cont) > having sum(p.discount_rt/100.0 * o.amount) between 1000.00 and 10000.00
----------------------------------- SUMMARY -----------------------------------
Select        distinct sum(P.DISCOUNT_RT / 100.0 * O.AMOUNT) \
  from        ORDERS O \
  join        PROSPECTS P on P.ACCT = O.ACCT \
  having      sum(P.DISCOUNT_RT / 100.0 * O.AMOUNT) between 1000.00 and \
              10000.00

Version:      <version>
Optimization: ASKLINK, ASKRETRIEVAL
Warnings:     UNOPTIMIZED_AGGREGATION
Notes:        DISTINCT processing bypassed because result set contains 1 row.
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where APOSTDQSAT = '*' on 1 with ASK, NOAUTORESET
Retrieve from index APOSTDQSAT on 1
 Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve PROSPECTS P using $ROWID = $ODXID
 Filter SUM(P.DISCOUNT_RT / 100.0 * O.AMOUNT) BETWEEN 1000.00 AND 10000.00
Return SUM(P.DISCOUNT_RT / 100.0 * O.AMOUNT)
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=DMT5r>
> ;67
> select distinct sum(p.discount_rt/100.0 * o.amount) from orders o, prospects p \
 (cont) >  where p.acct = o.acct \
 (cont) > having sum(p.discount_rt/100.0 * o.amount) between 1000.00 and 10000.00
----------------------------------- SUMMARY -----------------------------------
Select        distinct sum(P.DISCOUNT_RT / 100.0 * O.AMOUNT) \
  from        ORDERS O, \
              PROSPECTS P \
  where       P.ACCT = O.ACCT \
  having      sum(P.DISCOUNT_RT / 100.0 * O.AMOUNT) between 1000.00 and \
              10000.00

Version:      <version>
Optimization: ASKLINK, ASKRETRIEVAL
Warnings:     UNOPTIMIZED_AGGREGATION
Notes:        DISTINCT processing bypassed because result set contains 1 row.
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where APOSTDQSAT = '*' on 1 with ASK, NOAUTORESET
Retrieve from index APOSTDQSAT on 1
 Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve PROSPECTS P using $ROWID = $ODXID
 Filter SUM(P.DISCOUNT_RT / 100.0 * O.AMOUNT) BETWEEN 1000.00 AND 10000.00
Return SUM(P.DISCOUNT_RT / 100.0 * O.AMOUNT)
-------------------------------------------------------------------------------
> ;
> ;
> ; <SECTION=AGG(DISTINCT)>
> ;
> ;Tests sum/avg(distinct col)
> ;
> ; <TEST=AGD1>
> ;68
> select avg(distinct cr_limit), count(distinct cr_limit) from prospects
----------------------------------- SUMMARY -----------------------------------
Select        avg(distinct CR_LIMIT), \
              count(distinct CR_LIMIT) \
  from        PROSPECTS

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
----------------------------------- DETAILS -----------------------------------
Retrieve PROSPECTS sequentially
Pass to queue {1} [PROSPECTS.CR_LIMIT]
Pass to queue {2} [PROSPECTS.CR_LIMIT]
Sort {1} for DISTINCT [PROSPECTS.CR_LIMIT ASC]
Sort {2} for DISTINCT [PROSPECTS.CR_LIMIT ASC]
Retrieve {1} sequentially
Retrieve {2} sequentially
Return AVG(DISTINCT PROSPECTS.CR_LIMIT), COUNT(DISTINCT PROSPECTS.CR_LIMIT)
-------------------------------------------------------------------------------
> ; <TEST=AGD2>
> ;69
> select sum(distinct quantity) from orders \
 (cont) >  where amount < 10 \
 (cont) >  group by pmt_method
----------------------------------- SUMMARY -----------------------------------
Select        sum(distinct QUANTITY) \
  from        ORDERS \
  where       AMOUNT < 10 \
  group by    PMT_METHOD

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where AMOUNT < '10' on 1 with NOAUTORESET
   (22 ORDERS, 22 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.PMT_METHOD]
 Pass to queue {2} [ORDERS.PMT_METHOD, ORDERS.QUANTITY]
Sort {1} for GROUP BY [ORDERS.PMT_METHOD ASC]
Sort {2} for DISTINCT [ORDERS.PMT_METHOD ASC, ORDERS.QUANTITY ASC]
Merge queues {1}, {2}
Return SUM(DISTINCT ORDERS.QUANTITY)
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=AGD2r>
> ;70
> select sum(distinct quantity) from orders \
 (cont) >  where amount < 10 \
 (cont) >  group by pmt_method
----------------------------------- SUMMARY -----------------------------------
Select        sum(distinct QUANTITY) \
  from        ORDERS \
  where       AMOUNT < 10 \
  group by    PMT_METHOD

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where AMOUNT < '10' on 1 with NOAUTORESET
   (22 ORDERS, 22 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.PMT_METHOD]
 Pass to queue {2} [ORDERS.PMT_METHOD, ORDERS.QUANTITY]
Sort {1} for GROUP BY [ORDERS.PMT_METHOD ASC]
Sort {2} for DISTINCT [ORDERS.PMT_METHOD ASC, ORDERS.QUANTITY ASC]
Merge queues {1}, {2}
Return SUM(DISTINCT ORDERS.QUANTITY)
-------------------------------------------------------------------------------
> ; <TEST=AGD3>
> ;71
> select 100 * avg(distinct total) bigtotal, pmt_method, source \
 (cont) >   from orders \
 (cont) >  group by source, pmt_method \
 (cont) > having bigtotal between 10000 and 1000000.00
----------------------------------- SUMMARY -----------------------------------
Select        100 * avg(distinct TOTAL) BIGTOTAL, \
              PMT_METHOD, \
              SOURCE \
  from        ORDERS \
  group by    SOURCE, \
              PMT_METHOD \
  having      BIGTOTAL between 10000 and 1000000.00

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
----------------------------------- DETAILS -----------------------------------
Retrieve ORDERS sequentially
Pass to queue {1} [ORDERS.SOURCE, ORDERS.PMT_METHOD]
Pass to queue {2} [ORDERS.SOURCE, ORDERS.PMT_METHOD, ORDERS.TOTAL]
Sort {1} for GROUP BY [ORDERS.SOURCE ASC, ORDERS.PMT_METHOD ASC]
Sort {2} for DISTINCT [ORDERS.SOURCE ASC, ORDERS.PMT_METHOD ASC, ORDERS.TOTAL \
   ASC]
Merge queues {1}, {2}
Filter 100 * AVG(ORDERS.TOTAL) BETWEEN 10000 AND 1000000.00
Return BIGTOTAL, ORDERS.PMT_METHOD, ORDERS.SOURCE
-------------------------------------------------------------------------------
> ; <TEST=AGD4>
> ;72
> select avg(cost) - avg(distinct wholesale) neg from products \
 (cont) >  where (description like '%Computer%' or category < 30) and wholesale > 100 \
 (cont) >  group by category \
 (cont) > having neg > -10.00
----------------------------------- SUMMARY -----------------------------------
Select        avg(COST) - avg(distinct WHOLESALE) NEG \
  from        PRODUCTS \
  where       (DESCRIPTION like '%Computer%' or \
               CATEGORY < 30) and \
              WHOLESALE > 100 \
  group by    CATEGORY \
  having      NEG > -10.00

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where DESCRIPTION = '*Computer*' on 1 with \
   NOAUTORESET
   (11 PRODUCTS, 11 Pre-intersect   <time>)
Qualify (PRODUCTS)PRODUCTS where or CATEGORY < '30' on 1 with NOAUTORESET
   (30 PRODUCTS, 19 Pre-intersect   <time>)
Qualify (PRODUCTS)PRODUCTS where and WHOLESALE > '100' on 1 with NOAUTORESET
   (26 PRODUCTS, 40 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve PRODUCTS using $ROWID = $ODXID
 Pass to queue {1} [PRODUCTS.CATEGORY, PRODUCTS.COST]
 Pass to queue {2} [PRODUCTS.CATEGORY, PRODUCTS.WHOLESALE]
Sort {1} for GROUP BY [PRODUCTS.CATEGORY ASC]
Sort {2} for DISTINCT [PRODUCTS.CATEGORY ASC, PRODUCTS.WHOLESALE ASC]
Merge queues {1}, {2}
Filter EXPR[0] - AVG(PRODUCTS.WHOLESALE) > -10.00
Return NEG
-------------------------------------------------------------------------------
> ; <TEST=AGD5>
> ;73
> select sum(distinct cr_limit * 1000) * (1 - avg(distinct discount_rt / 100.0)) \
 (cont) >   from prospects where cust_since <= 1992 and last_order >= '07-31-1998'
----------------------------------- SUMMARY -----------------------------------
Select        sum(distinct CR_LIMIT * 1000) * (1 - avg(distinct DISCOUNT_RT / \
              100.0)) \
  from        PROSPECTS \
  where       CUST_SINCE <= 1992 and \
              LAST_ORDER >= '07-31-1998'

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where CUST_SINCE <= '1992' on 1 with NOAUTORESET
   (1 PROSPECTS, 1 Pre-intersect   <time>)
Qualify (PROSPECTS)PROSPECTS where and LAST_ORDER >= '07-31-1998' on 1 with \
   NOAUTORESET
   (1 PROSPECTS, 4 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve PROSPECTS using $ROWID = $ODXID
 Pass to queue {1} [PROSPECTS.CR_LIMIT * 1000]
 Pass to queue {2} [PROSPECTS.DISCOUNT_RT / 100.0]
Sort {1} for DISTINCT [PROSPECTS.CR_LIMIT * 1000 ASC]
Sort {2} for DISTINCT [PROSPECTS.DISCOUNT_RT / 100.0 ASC]
Retrieve {1} sequentially
Retrieve {2} sequentially
Return SUM(DISTINCT PROSPECTS.CR_LIMIT * 1000) * 1 - AVG(DISTINCT \
   PROSPECTS.DISCOUNT_RT / 100.0)
-------------------------------------------------------------------------------
> ; <TEST=AGD6>
> ;74
> select (discount/100.0) * sum(total), quantity * sum(distinct amount) \
 (cont) >   from orders \
 (cont) >  group by discount, quantity
----------------------------------- SUMMARY -----------------------------------
Select        DISCOUNT / 100.0 * sum(TOTAL), \
              QUANTITY * sum(distinct AMOUNT) \
  from        ORDERS \
  group by    DISCOUNT, \
              QUANTITY

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
----------------------------------- DETAILS -----------------------------------
Retrieve ORDERS sequentially
Pass to queue {1} [ORDERS.DISCOUNT, ORDERS.QUANTITY, ORDERS.DISCOUNT / 100.0, \
   ORDERS.TOTAL, ORDERS.QUANTITY]
Pass to queue {2} [ORDERS.DISCOUNT, ORDERS.QUANTITY, ORDERS.AMOUNT]
Sort {1} for GROUP BY [ORDERS.DISCOUNT ASC, ORDERS.QUANTITY ASC]
Sort {2} for DISTINCT [ORDERS.DISCOUNT ASC, ORDERS.QUANTITY ASC, \
   ORDERS.AMOUNT ASC]
Merge queues {1}, {2}
Return ORDERS.DISCOUNT / 100.0 * SUM(ORDERS.TOTAL), ORDERS.QUANTITY * \
   SUM(DISTINCT ORDERS.AMOUNT)
-------------------------------------------------------------------------------
> ; <TEST=AGD7>
> ;75
> select quantity * avg(amount) - quantity * avg(distinct amount), \
 (cont) >        count(amount), count(distinct amount) \
 (cont) >   from orders where amount < 10 \
 (cont) >  group by quantity, pmt_method
----------------------------------- SUMMARY -----------------------------------
Select        QUANTITY * avg(AMOUNT) - (QUANTITY * avg(distinct AMOUNT)), \
              count(AMOUNT), \
              count(distinct AMOUNT) \
  from        ORDERS \
  where       AMOUNT < 10 \
  group by    QUANTITY, \
              PMT_METHOD

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where AMOUNT < '10' on 1 with NOAUTORESET
   (22 ORDERS, 22 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.QUANTITY, ORDERS.PMT_METHOD, ORDERS.QUANTITY, \
    ORDERS.AMOUNT, ORDERS.QUANTITY, ORDERS.AMOUNT]
 Pass to queue {2} [ORDERS.QUANTITY, ORDERS.PMT_METHOD, ORDERS.AMOUNT]
 Pass to queue {3} [ORDERS.QUANTITY, ORDERS.PMT_METHOD, ORDERS.AMOUNT]
Sort {1} for GROUP BY [ORDERS.QUANTITY ASC, ORDERS.PMT_METHOD ASC]
Sort {2} for DISTINCT [ORDERS.QUANTITY ASC, ORDERS.PMT_METHOD ASC, \
   ORDERS.AMOUNT ASC]
Sort {3} for DISTINCT [ORDERS.QUANTITY ASC, ORDERS.PMT_METHOD ASC, \
   ORDERS.AMOUNT ASC]
Merge queues {1}, {2}, {3}
Return ORDERS.QUANTITY * AVG(ORDERS.AMOUNT) - ORDERS.QUANTITY * AVG(DISTINCT \
   ORDERS.AMOUNT), COUNT(ORDERS.AMOUNT), COUNT(DISTINCT ORDERS.AMOUNT)
-------------------------------------------------------------------------------
> ; <TEST=AGD8>
> ;76
> select sum(distinct amount - ((discount/100.0) * amount)) + avg(total) / quantity \
 (cont) >   from orders \
 (cont) >  where amount < 100.00 or quantity between 5 and 10 \
 (cont) >  group by status, quantity
----------------------------------- SUMMARY -----------------------------------
Select        sum(distinct AMOUNT - (DISCOUNT / 100.0 * AMOUNT)) + \
              (avg(TOTAL) / QUANTITY) \
  from        ORDERS \
  where       AMOUNT < 100.00 or \
              QUANTITY between 5 and 10 \
  group by    STATUS, \
              QUANTITY

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where AMOUNT < '100.00' on 1 with NOAUTORESET
   (56 ORDERS, 56 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY between '5' and '10' on 1 with \
   NOAUTORESET
   (63 ORDERS, 16 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.TOTAL, \
    ORDERS.QUANTITY]
 Pass to queue {2} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.AMOUNT - \
    ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT]
Sort {1} for GROUP BY [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC]
Sort {2} for DISTINCT [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.AMOUNT \
   - ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT ASC]
Merge queues {1}, {2}
Return SUM(DISTINCT ORDERS.AMOUNT - ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT) \
   + AVG(ORDERS.TOTAL) / ORDERS.QUANTITY
-------------------------------------------------------------------------------
> ; <TEST=AGD9>
> ;77
> select $round(quantity * sum(distinct amount - ((discount/100.0) * amount)) \
 (cont) >        - avg(distinct total) / quantity, 2), count(total), count(*), \
 (cont) >        status, quantity, acct \
 (cont) >   from orders \
 (cont) >  group by status, quantity, acct
----------------------------------- SUMMARY -----------------------------------
Select        $round(QUANTITY * sum(distinct AMOUNT - (DISCOUNT / 100.0 * \
              AMOUNT)) - (avg(distinct TOTAL) / QUANTITY), 2), \
              count(TOTAL), \
              count(*), \
              STATUS, \
              QUANTITY, \
              ACCT \
  from        ORDERS \
  group by    STATUS, \
              QUANTITY, \
              ACCT

Version:      <version>
Optimization: ASKRETRIEVAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where APOSTDQSAT = '*' on 1 with ASK, NOAUTORESET
Retrieve from index APOSTDQSAT on 1
Pass to queue {1} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, \
   ORDERS.QUANTITY, ORDERS.QUANTITY, ORDERS.TOTAL]
Pass to queue {2} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, ORDERS.AMOUNT \
   - ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT]
Pass to queue {3} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, ORDERS.TOTAL]
Sort {1} for GROUP BY [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT ASC]
Sort {2} for DISTINCT [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT \
   ASC, ORDERS.AMOUNT - ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT ASC]
Sort {3} for DISTINCT [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT \
   ASC, ORDERS.TOTAL ASC]
Merge queues {1}, {2}, {3}
Return $ROUND(ORDERS.QUANTITY * SUM(DISTINCT ORDERS.AMOUNT - ORDERS.DISCOUNT \
   / 100.0 * ORDERS.AMOUNT) - AVG(DISTINCT ORDERS.TOTAL) ..., \
   COUNT(ORDERS.TOTAL), COUNT('*'), ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT
-------------------------------------------------------------------------------
> ; <TEST=AGD10>
> ;78
> select quantity * sum(distinct amount - ((discount/100.0) * amount)) \
 (cont) >        - avg(distinct total) / quantity, count(total), count(*), \
 (cont) >        status, quantity, acct \
 (cont) >   from orders \
 (cont) >  where amount < 100.00 or quantity between 5 and 10 \
 (cont) >  group by status, quantity, acct \
 (cont) > having count(*) > 100 \
 (cont) >  order by 6,5,4,3,2,1
----------------------------------- SUMMARY -----------------------------------
Select        QUANTITY * sum(distinct AMOUNT - (DISCOUNT / 100.0 * AMOUNT)) - \
              (avg(distinct TOTAL) / QUANTITY), \
              count(TOTAL), \
              count(*), \
              STATUS, \
              QUANTITY, \
              ACCT \
  from        ORDERS \
  where       AMOUNT < 100.00 or \
              QUANTITY between 5 and 10 \
  group by    STATUS, \
              QUANTITY, \
              ACCT \
  having      count(*) > 100 \
  order by    6, \
              5, \
              4, \
              3, \
              2, \
              1

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where AMOUNT < '100.00' on 1 with NOAUTORESET
   (56 ORDERS, 56 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY between '5' and '10' on 1 with \
   NOAUTORESET
   (63 ORDERS, 16 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, \
    ORDERS.QUANTITY, ORDERS.QUANTITY, ORDERS.TOTAL]
 Pass to queue {2} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, \
    ORDERS.AMOUNT - ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT]
 Pass to queue {3} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, ORDERS.TOTAL]
Sort {1} for GROUP BY [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT ASC]
Sort {2} for DISTINCT [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT \
   ASC, ORDERS.AMOUNT - ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT ASC]
Sort {3} for DISTINCT [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT \
   ASC, ORDERS.TOTAL ASC]
Merge queues {1}, {2}, {3}
Filter EXPR[1] > 100
Pass to queue {4} [ORDERS.QUANTITY * SUM(ORDERS.AMOUNT - ORDERS.DISCOUNT / \
   100.0 * ORDERS.AMOUNT) - AVG(ORDERS.TOTAL) / ORDERS.QUANTITY, EXPR[0], \
   EXPR[1], ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT]
Sort {4} for ORDER BY [ORDERS.ACCT ASC, ORDERS.QUANTITY ASC, ORDERS.STATUS \
   ASC, EXPR[1] ASC, EXPR[0] ASC, ORDERS.QUANTITY * SUM(ORDERS.AMOUNT - \
   ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT) - AVG(ORDERS.TOTAL) / \
   ORDERS.QUANTITY ASC]
Retrieve {4} sequentially
Return ORDERS.QUANTITY * SUM(DISTINCT ORDERS.AMOUNT - ORDERS.DISCOUNT / 100.0 \
   * ORDERS.AMOUNT) - AVG(DISTINCT ORDERS.TOTAL) / QUANTITY, \
   COUNT(ORDERS.TOTAL), COUNT('*'), ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=AGD10r>
> ;79
> select quantity * sum(distinct amount - ((discount/100.0) * amount)) \
 (cont) >        - avg(distinct total) / quantity, count(total), count(*), \
 (cont) >        status, quantity, acct \
 (cont) >   from orders \
 (cont) >  where amount < 100.00 or quantity between 5 and 10 \
 (cont) >  group by status, quantity, acct \
 (cont) > having count(*) > 100 \
 (cont) >  order by 6,5,4,3,2,1
----------------------------------- SUMMARY -----------------------------------
Select        QUANTITY * sum(distinct AMOUNT - (DISCOUNT / 100.0 * AMOUNT)) - \
              (avg(distinct TOTAL) / QUANTITY), \
              count(TOTAL), \
              count(*), \
              STATUS, \
              QUANTITY, \
              ACCT \
  from        ORDERS \
  where       AMOUNT < 100.00 or \
              QUANTITY between 5 and 10 \
  group by    STATUS, \
              QUANTITY, \
              ACCT \
  having      count(*) > 100 \
  order by    6, \
              5, \
              4, \
              3, \
              2, \
              1

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where AMOUNT < '100.00' on 1 with NOAUTORESET
   (56 ORDERS, 56 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY between '5' and '10' on 1 with \
   NOAUTORESET
   (63 ORDERS, 16 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, \
    ORDERS.QUANTITY, ORDERS.QUANTITY, ORDERS.TOTAL]
 Pass to queue {2} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, \
    ORDERS.AMOUNT - ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT]
 Pass to queue {3} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, ORDERS.TOTAL]
Sort {1} for GROUP BY [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT ASC]
Sort {2} for DISTINCT [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT \
   ASC, ORDERS.AMOUNT - ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT ASC]
Sort {3} for DISTINCT [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT \
   ASC, ORDERS.TOTAL ASC]
Merge queues {1}, {2}, {3}
Filter EXPR[1] > 100
Pass to queue {4} [ORDERS.QUANTITY * SUM(ORDERS.AMOUNT - ORDERS.DISCOUNT / \
   100.0 * ORDERS.AMOUNT) - AVG(ORDERS.TOTAL) / ORDERS.QUANTITY, EXPR[0], \
   EXPR[1], ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT]
Sort {4} for ORDER BY [ORDERS.ACCT ASC, ORDERS.QUANTITY ASC, ORDERS.STATUS \
   ASC, EXPR[1] ASC, EXPR[0] ASC, ORDERS.QUANTITY * SUM(ORDERS.AMOUNT - \
   ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT) - AVG(ORDERS.TOTAL) / \
   ORDERS.QUANTITY ASC]
Retrieve {4} sequentially
Return ORDERS.QUANTITY * SUM(DISTINCT ORDERS.AMOUNT - ORDERS.DISCOUNT / 100.0 \
   * ORDERS.AMOUNT) - AVG(DISTINCT ORDERS.TOTAL) / QUANTITY, \
   COUNT(ORDERS.TOTAL), COUNT('*'), ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT
-------------------------------------------------------------------------------
> ; <TEST=AGD11>
> ;80
> select quantity * sum(distinct amount - ((discount/100.0) * amount)) \
 (cont) >        - avg(distinct total) / quantity, count(total), count(*), \
 (cont) >        status, quantity, acct \
 (cont) >   from orders \
 (cont) >  where amount < 100.00 or quantity between 5 and 10 \
 (cont) >  group by status, quantity, acct \
 (cont) >  order by 6,5,4,3,2,1
----------------------------------- SUMMARY -----------------------------------
Select        QUANTITY * sum(distinct AMOUNT - (DISCOUNT / 100.0 * AMOUNT)) - \
              (avg(distinct TOTAL) / QUANTITY), \
              count(TOTAL), \
              count(*), \
              STATUS, \
              QUANTITY, \
              ACCT \
  from        ORDERS \
  where       AMOUNT < 100.00 or \
              QUANTITY between 5 and 10 \
  group by    STATUS, \
              QUANTITY, \
              ACCT \
  order by    6, \
              5, \
              4, \
              3, \
              2, \
              1

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where AMOUNT < '100.00' on 1 with NOAUTORESET
   (56 ORDERS, 56 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY between '5' and '10' on 1 with \
   NOAUTORESET
   (63 ORDERS, 16 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, \
    ORDERS.QUANTITY, ORDERS.QUANTITY, ORDERS.TOTAL]
 Pass to queue {2} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, \
    ORDERS.AMOUNT - ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT]
 Pass to queue {3} [ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT, ORDERS.TOTAL]
Sort {1} for GROUP BY [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT ASC]
Sort {2} for DISTINCT [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT \
   ASC, ORDERS.AMOUNT - ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT ASC]
Sort {3} for DISTINCT [ORDERS.STATUS ASC, ORDERS.QUANTITY ASC, ORDERS.ACCT \
   ASC, ORDERS.TOTAL ASC]
Merge queues {1}, {2}, {3}
Pass to queue {4} [ORDERS.QUANTITY * SUM(ORDERS.AMOUNT - ORDERS.DISCOUNT / \
   100.0 * ORDERS.AMOUNT) - AVG(ORDERS.TOTAL) / ORDERS.QUANTITY, EXPR[0], \
   EXPR[1], ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT]
Sort {4} for ORDER BY [ORDERS.ACCT ASC, ORDERS.QUANTITY ASC, ORDERS.STATUS \
   ASC, EXPR[1] ASC, EXPR[0] ASC, ORDERS.QUANTITY * SUM(ORDERS.AMOUNT - \
   ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT) - AVG(ORDERS.TOTAL) / \
   ORDERS.QUANTITY ASC]
Retrieve {4} sequentially
Return ORDERS.QUANTITY * SUM(DISTINCT ORDERS.AMOUNT - ORDERS.DISCOUNT / 100.0 \
   * ORDERS.AMOUNT) - AVG(DISTINCT ORDERS.TOTAL) / QUANTITY, \
   COUNT(ORDERS.TOTAL), COUNT('*'), ORDERS.STATUS, ORDERS.QUANTITY, ORDERS.ACCT
-------------------------------------------------------------------------------
> ;
> ; multiple tables
> ; <TEST=AGDMT1>
> ;81
> select sum(distinct quantity + 1000), avg(distinct quantity *100), \
 (cont) >        0.5 * sum(distinct cr_limit), avg(distinct cr_limit) \
 (cont) >   from orders o, prospects p \
 (cont) >  where o.acct = p.acct and \
 (cont) >        (order_date > '01-01-1996' or quantity between 1 and 5 \
 (cont) >        or sales_tax < 4.00) and company like '%Systems%' \
 (cont) >  group by cr_limit \
 (cont) > having sum(cr_limit) < 10
----------------------------------- SUMMARY -----------------------------------
Select        sum(distinct QUANTITY + 1000), \
              avg(distinct QUANTITY * 100), \
              0.5 * sum(distinct CR_LIMIT), \
              avg(distinct CR_LIMIT) \
  from        ORDERS O, \
              PROSPECTS P \
  where       O.ACCT = P.ACCT and \
              (ORDER_DATE > '01-01-1996' or \
               QUANTITY between 1 and 5 or \
               SALES_TAX < 4.00) and \
              COMPANY like '%Systems%' \
  group by    CR_LIMIT \
  having      sum(CR_LIMIT) < 10

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where ORDER_DATE > '01-01-1996' on 1 with NOAUTORESET
   (8 ORDERS, 8 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY between '1' and '5' on 1 with \
   NOAUTORESET
   (155 ORDERS, 154 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or SALES_TAX < '4.00' on 1 with NOAUTORESET
   (158 ORDERS, 50 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PROSPECTS)PROSPECTS using ACCT on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PROSPECTS)PROSPECTS where and COMPANY = '*Systems*' on 1 with \
   NOAUTORESET,PRESERVERS
   (129 ORDERS, 1 PROSPECTS, 4 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (129 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PROSPECTS P using $ROWID = $ODXID
  Pass to queue {1} [P.CR_LIMIT, P.CR_LIMIT]
  Pass to queue {2} [P.CR_LIMIT, O.QUANTITY + 1000]
  Pass to queue {3} [P.CR_LIMIT, O.QUANTITY * 100]
  Pass to queue {4} [P.CR_LIMIT, P.CR_LIMIT]
  Pass to queue {5} [P.CR_LIMIT, P.CR_LIMIT]
Sort {1} for GROUP BY [P.CR_LIMIT ASC]
Sort {2} for DISTINCT [P.CR_LIMIT ASC, O.QUANTITY + 1000 ASC]
Sort {3} for DISTINCT [P.CR_LIMIT ASC, O.QUANTITY * 100 ASC]
Sort {4} for DISTINCT [P.CR_LIMIT ASC, P.CR_LIMIT ASC]
Sort {5} for DISTINCT [P.CR_LIMIT ASC, P.CR_LIMIT ASC]
Merge queues {1}, {2}, {3}, {4}, {5}
Filter EXPR[0] < 10
Return SUM(DISTINCT O.QUANTITY + 1000), AVG(DISTINCT O.QUANTITY * 100), 0.5 * \
   SUM(DISTINCT P.CR_LIMIT), AVG(DISTINCT P.CR_LIMIT)
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=AGDMT1r>
> ;82
> select sum(distinct quantity + 1000), avg(distinct quantity *100), \
 (cont) >        0.5 * sum(distinct cr_limit), avg(distinct cr_limit) \
 (cont) >   from orders o, prospects p \
 (cont) >  where o.acct = p.acct and \
 (cont) >        (order_date > '01-01-1996' or quantity between 1 and 5 \
 (cont) >        or sales_tax < 4.00) and company like '%Systems%' \
 (cont) >  group by cr_limit \
 (cont) > having sum(cr_limit) < 10
----------------------------------- SUMMARY -----------------------------------
Select        sum(distinct QUANTITY + 1000), \
              avg(distinct QUANTITY * 100), \
              0.5 * sum(distinct CR_LIMIT), \
              avg(distinct CR_LIMIT) \
  from        ORDERS O, \
              PROSPECTS P \
  where       O.ACCT = P.ACCT and \
              (ORDER_DATE > '01-01-1996' or \
               QUANTITY between 1 and 5 or \
               SALES_TAX < 4.00) and \
              COMPANY like '%Systems%' \
  group by    CR_LIMIT \
  having      sum(CR_LIMIT) < 10

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where ORDER_DATE > '01-01-1996' on 1 with NOAUTORESET
   (8 ORDERS, 8 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY between '1' and '5' on 1 with \
   NOAUTORESET
   (155 ORDERS, 154 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or SALES_TAX < '4.00' on 1 with NOAUTORESET
   (158 ORDERS, 50 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PROSPECTS)PROSPECTS using ACCT on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PROSPECTS)PROSPECTS where and COMPANY = '*Systems*' on 1 with \
   NOAUTORESET,PRESERVERS
   (129 ORDERS, 1 PROSPECTS, 4 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (129 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PROSPECTS P using $ROWID = $ODXID
  Pass to queue {1} [P.CR_LIMIT, P.CR_LIMIT]
  Pass to queue {2} [P.CR_LIMIT, O.QUANTITY + 1000]
  Pass to queue {3} [P.CR_LIMIT, O.QUANTITY * 100]
  Pass to queue {4} [P.CR_LIMIT, P.CR_LIMIT]
  Pass to queue {5} [P.CR_LIMIT, P.CR_LIMIT]
Sort {1} for GROUP BY [P.CR_LIMIT ASC]
Sort {2} for DISTINCT [P.CR_LIMIT ASC, O.QUANTITY + 1000 ASC]
Sort {3} for DISTINCT [P.CR_LIMIT ASC, O.QUANTITY * 100 ASC]
Sort {4} for DISTINCT [P.CR_LIMIT ASC, P.CR_LIMIT ASC]
Sort {5} for DISTINCT [P.CR_LIMIT ASC, P.CR_LIMIT ASC]
Merge queues {1}, {2}, {3}, {4}, {5}
Filter EXPR[0] < 10
Return SUM(DISTINCT O.QUANTITY + 1000), AVG(DISTINCT O.QUANTITY * 100), 0.5 * \
   SUM(DISTINCT P.CR_LIMIT), AVG(DISTINCT P.CR_LIMIT)
-------------------------------------------------------------------------------
> ; <TEST=AGDMT2>
> ;83
> select sum(distinct cr_limit) * (discount / 100.0), \
 (cont) >        $trunc(quantity * sum(distinct wholesale - ((discount/100.0) * amount)), 2), \
 (cont) >        - avg(distinct total) / quantity, count(total), count(*) \
 (cont) >   from orders, prospects, products \
 (cont) >  where orders.acct = prospects.acct and \
 (cont) >        products.product_no = orders.product_no \
 (cont) >  group by quantity, discount \
 (cont) >  order by 2
----------------------------------- SUMMARY -----------------------------------
Select        sum(distinct CR_LIMIT) * (DISCOUNT / 100.0), \
              $trunc(QUANTITY * sum(distinct WHOLESALE - (DISCOUNT / 100.0 * \
              AMOUNT)), 2), \
              avg(distinct TOTAL) * -1 / QUANTITY, \
              count(TOTAL), \
              count(*) \
  from        ORDERS, \
              PROSPECTS, \
              PRODUCTS \
  where       ORDERS.ACCT = PROSPECTS.ACCT and \
              PRODUCTS.PRODUCT_NO = ORDERS.PRODUCT_NO \
  group by    QUANTITY, \
              DISCOUNT \
  order by    2

Version:      <version>
Optimization: ASKLINK, ASKRETRIEVAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where APOSTDQSAT = '*' on 1 with ASK, NOAUTORESET
Retrieve from index APOSTDQSAT on 1
 Qualify (PROSPECTS)PROSPECTS where ACCT = ORDERS.ACCT on 2 with ASK \
    NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve PROSPECTS using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = ORDERS.PRODUCT_NO on 3 with \
     ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 3
  Retrieve PRODUCTS using $ROWID = $ODXID
  Pass to queue {1} [ORDERS.QUANTITY, ORDERS.DISCOUNT, ORDERS.DISCOUNT / \
     100.0, ORDERS.QUANTITY, ORDERS.QUANTITY, ORDERS.TOTAL]
  Pass to queue {2} [ORDERS.QUANTITY, ORDERS.DISCOUNT, PROSPECTS.CR_LIMIT]
  Pass to queue {3} [ORDERS.QUANTITY, ORDERS.DISCOUNT, PRODUCTS.WHOLESALE - \
     ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT]
  Pass to queue {4} [ORDERS.QUANTITY, ORDERS.DISCOUNT, ORDERS.TOTAL]
Sort {1} for GROUP BY [ORDERS.QUANTITY ASC, ORDERS.DISCOUNT ASC]
Sort {2} for DISTINCT [ORDERS.QUANTITY ASC, ORDERS.DISCOUNT ASC, \
   PROSPECTS.CR_LIMIT ASC]
Sort {3} for DISTINCT [ORDERS.QUANTITY ASC, ORDERS.DISCOUNT ASC, \
   PRODUCTS.WHOLESALE - ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT ASC]
Sort {4} for DISTINCT [ORDERS.QUANTITY ASC, ORDERS.DISCOUNT ASC, ORDERS.TOTAL \
   ASC]
Merge queues {1}, {2}, {3}, {4}
Pass to queue {5} [SUM(PROSPECTS.CR_LIMIT) * ORDERS.DISCOUNT / 100.0, \
   $TRUNC(ORDERS.QUANTITY * SUM(PRODUCTS.WHOLESALE - ORDERS.DISCOUNT / 100.0 \
   * ORDERS.AMOUNT),2), AVG(ORDERS.TOTAL) * -1 / ORDERS.QUANTITY, EXPR[0], \
   EXPR[1]]
Sort {5} for ORDER BY [$TRUNC(ORDERS.QUANTITY * SUM(PRODUCTS.WHOLESALE - \
   ORDERS.DISCOUNT / 100.0 * ORDERS.AMOUNT),2) ASC]
Retrieve {5} sequentially
Return SUM(DISTINCT PROSPECTS.CR_LIMIT) * ORDERS.DISCOUNT / 100.0, \
   $TRUNC(ORDERS.QUANTITY * SUM(DISTINCT PRODUCTS.WHOLESALE - ORDERS.DISCOUNT \
   / 100.0 * ORDERS.AMOUNT),2), AVG(DISTINCT ORDERS.TOTAL) * -1 / \
   ORDERS.QUANTITY, COUNT(ORDERS.TOTAL), COUNT('*')
-------------------------------------------------------------------------------
> ;
> ;
> ; <SECTION=WHERE-CLAUSE-OPT(no_aggs)>
> ;
> ;Tests where-clause optimization (without aggregations)
> ;
> ; <TEST=WO1>
> ;84
> select p.product_no \
 (cont) >   from orders o, products p \
 (cont) >   where o.product_no = p.product_no and \
 (cont) >         (o.quantity >= 10 or p.wholesale > 1000.00)
----------------------------------- SUMMARY -----------------------------------
Select        P.PRODUCT_NO \
  from        ORDERS O, \
              PRODUCTS P \
  where       O.PRODUCT_NO = P.PRODUCT_NO and \
              (O.QUANTITY >= 10 or \
               P.WHOLESALE > 1000.00)

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Notes:        Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where WHOLESALE > '1000.00' on 1 with NOAUTORESET
   (11 PRODUCTS, 11 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY >= '10' on 1 with NOAUTORESET
   (80 ORDERS, 35 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (80 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PRODUCTS P using $ROWID = $ODXID
  Return P.PRODUCT_NO
-------------------------------------------------------------------------------
> ; <TEST=WO2>
> ;85
> select top 5% acct, product_no, order_date from orders \
 (cont) >   where discount = 0 or quantity <= 5 or total < 22.5 \
 (cont) >   order by 1, 2, 3
----------------------------------- SUMMARY -----------------------------------
Select        top 5 % ACCT, \
              PRODUCT_NO, \
              ORDER_DATE \
  from        ORDERS \
  where       DISCOUNT = 0 or \
              QUANTITY <= 5 or \
              TOTAL < 22.5 \
  order by    1, \
              2, \
              3

Version:      <version>
Optimization: MDKQUAL, ASKORDERBY
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where DISCOUNT = '0' on 1 with NOAUTORESET
   (1 ORDERS, 1 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY <= '5' on 1 with NOAUTORESET
   (154 ORDERS, 154 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or TOTAL < '22.5' on 1 with NOAUTORESET
   (156 ORDERS, 21 Pre-intersect   <time>)
Fetchkeys ACCT, PRODUCT_NO, ORDER_DATE, STATUS, TAX_STATE, DISCOUNT, \
   QUANTITY, SALES_TAX, AMOUNT, TOTAL, $ROWID ordered by APOSTDQSAT 1000 at a \
   time on 1
Return TOP 5% ORDERS.ACCT, ORDERS.PRODUCT_NO, ORDERS.ORDER_DATE
-------------------------------------------------------------------------------
> ; <TEST=WO3>
> ;86
> select acct, initials, dt from activity \
 (cont) >   where (initials not like 'SH%' and initials not like '%J%') or tickler in ('MF', 'PC', 'RC')
----------------------------------- SUMMARY -----------------------------------
Select        ACCT, \
              INITIALS, \
              DT \
  from        ACTIVITY \
  where       (INITIALS not like 'SH%' and \
               INITIALS not like '%J%') or \
              TICKLER in ('MF', 'PC', 'RC')

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_CRITERIA, SEQUENTIAL_SCAN
Notes:        Filter on column INITIALS will not be optimized because a bitmap
                index does not support non-trailing wildcards.
              Cross-references are necessary because an Omnidexed condition is
                OR-connected with a non-Omnidexed condition.
              Omnidex optimization will not be used because xrefs are not
                supported with a non-optimized LIKE.
----------------------------------- DETAILS -----------------------------------
Retrieve ACTIVITY sequentially
Filter NOT ACTIVITY.INITIALS LIKE 'SH%'
Filter NOT ACTIVITY.INITIALS LIKE '%J%'
Filter FILTER 0 AND FILTER 1
Filter ACTIVITY.TICKLER IN ('MF','PC','RC')
Filter FILTER 2 OR FILTER 3
Return ACTIVITY.ACCT, ACTIVITY.INITIALS, ACTIVITY.DT
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=WO3r>
> ;87
> select acct, initials, dt from activity \
 (cont) >   where (initials not like 'SH%' and initials not like '%J%') or tickler in ('MF', 'PC', 'RC')
----------------------------------- SUMMARY -----------------------------------
Select        ACCT, \
              INITIALS, \
              DT \
  from        ACTIVITY \
  where       (INITIALS not like 'SH%' and \
               INITIALS not like '%J%') or \
              TICKLER in ('MF', 'PC', 'RC')

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_CRITERIA, SEQUENTIAL_SCAN
Notes:        Filter on column INITIALS will not be optimized because a bitmap
                index does not support non-trailing wildcards.
              Cross-references are necessary because an Omnidexed condition is
                OR-connected with a non-Omnidexed condition.
              Omnidex optimization will not be used because xrefs are not
                supported with a non-optimized LIKE.
----------------------------------- DETAILS -----------------------------------
Retrieve ACTIVITY sequentially
Filter NOT ACTIVITY.INITIALS LIKE 'SH%'
Filter NOT ACTIVITY.INITIALS LIKE '%J%'
Filter FILTER 0 AND FILTER 1
Filter ACTIVITY.TICKLER IN ('MF','PC','RC')
Filter FILTER 2 OR FILTER 3
Return ACTIVITY.ACCT, ACTIVITY.INITIALS, ACTIVITY.DT
-------------------------------------------------------------------------------
> ; <TEST=WO4>
> ;88
> select product_no from products \
 (cont) >   where description like '%Computer' or (category < 30 and wholesale > 100)
----------------------------------- SUMMARY -----------------------------------
Select        PRODUCT_NO \
  from        PRODUCTS \
  where       DESCRIPTION like '%Computer' or \
              (CATEGORY < 30 and \
               WHOLESALE > 100)

Version:      <version>
Optimization: MDKQUAL, ASKRETRIEVAL
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where CATEGORY < '30' on 1 with NOAUTORESET
   (19 PRODUCTS, 19 Pre-intersect   <time>)
Qualify (PRODUCTS)PRODUCTS where and WHOLESALE > '100' on 1 with NOAUTORESET
   (15 PRODUCTS, 40 Pre-intersect   <time>)
Qualify (PRODUCTS)PRODUCTS where or DESCRIPTION = '*Computer' on 1 with \
   NOAUTORESET
   (26 PRODUCTS, 11 Pre-intersect   <time>)
Retrieve from index PCC on 1
Return PRODUCTS.PRODUCT_NO
-------------------------------------------------------------------------------
> ; <TEST=WO5>
> ;89
> select order_date, ((amount * quantity) - total) from orders \
 (cont) >   where ((order_date between '01-01-1996' and '12-31-1996' and quantity > 10) or \
 (cont) >         (order_date between '01-01-1995' and '12-31-1995' and (quantity > 10 or total > 10000))) \
 (cont) >         and tax_state = 'CO'
----------------------------------- SUMMARY -----------------------------------
Select        ORDER_DATE, \
              AMOUNT * QUANTITY - TOTAL \
  from        ORDERS \
  where       ((ORDER_DATE between '01-01-1996' and '12-31-1996' and \
                QUANTITY > 10) or \
               (ORDER_DATE between '01-01-1995' and '12-31-1995' and \
                (QUANTITY > 10 or \
                 TOTAL > 10000))) and \
              TAX_STATE = 'CO'

Version:      <version>
Optimization: MDKQUAL
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where ORDER_DATE between '01-01-1996' and '12-31-1996' \
   on 1 with NOAUTORESET
   (7 ORDERS, 7 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and QUANTITY > '10' on 1 with NOAUTORESET
   (1 ORDERS, 32 Pre-intersect   <time>)
Export to queue O1 on 1 with ODXID
   (1 row exported   <time>)
Qualify (ORDERS)ORDERS where QUANTITY > '10' on 1 with NOAUTORESET
   (32 ORDERS, 32 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or TOTAL > '10000' on 1 with NOAUTORESET
   (35 ORDERS, 17 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and ORDER_DATE between '01-01-1995' and \
   '12-31-1995' on 1 with NOAUTORESET
   (7 ORDERS, 44 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or $ODXID = 'queue(O1)' on 1 with NOAUTORESET
   (8 ORDERS, 1 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and TAX_STATE = 'CO' on 1 with NOAUTORESET
   (6 ORDERS, 163 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Return ORDERS.ORDER_DATE, ORDERS.AMOUNT * ORDERS.QUANTITY - ORDERS.TOTAL
-------------------------------------------------------------------------------
> ; <TEST=WO6>
> ;90
> select d.description, p.description, s.description \
 (cont) >   from orders o, products p, dates d, statuses s \
 (cont) >  where (o.product_no = p.product_no and o.order_date = d.dt \
 (cont) >         and o.status = s.status) and \
 (cont) >         (s.description = 'Cancelled' or d.yr < 1991 \
 (cont) >         or o.discount = 0 or p.margin <= 30) order by d.dt, p.description
----------------------------------- SUMMARY -----------------------------------
Select        D.DESCRIPTION, \
              P.DESCRIPTION, \
              S.DESCRIPTION \
  from        ORDERS O, \
              PRODUCTS P, \
              DATES D, \
              STATUSES S \
  where       O.PRODUCT_NO = P.PRODUCT_NO and \
              O.ORDER_DATE = D.DT and \
              O.STATUS = S.STATUS and \
              (S.DESCRIPTION = 'Cancelled' or \
               D.YR < 1991 or \
               O.DISCOUNT = 0 or \
               P.MARGIN <= 30) \
  order by    D.DT, \
              P.DESCRIPTION

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_SORT
Notes:        Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (DATES)DATES where YR < '1991' on 1 with NOAUTORESET
   (365 DATES, 365 Pre-intersect   <time>)
Export to queue M1 on 1 with ODXSI,SORT
   (365 rows exported   <time>)
Qualify (STATUSES)STATUSES where DESCRIPTION = 'Cancelled' on 1 with \
   NOAUTORESET
   (1 STATUSES, 1 Pre-intersect   <time>)
Join STATUSES using STATUS to (ORDERS)ORDERS using STATUS on 1 with NOAUTORESET
   (8 ORDERS, 8 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PRODUCTS)PRODUCTS where or MARGIN <= '30' on 1 with NOAUTORESET, \
   PRESERVERS
   (37 ORDERS, 28 PRODUCTS, 48 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or DISCOUNT = '0' on 1 with NOAUTORESET
   (37 ORDERS, 1 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or $ODXID = 'queue(M1, 3)' on 1 with NOAUTORESET
   (69 ORDERS, 39 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (69 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PRODUCTS P using $ROWID = $ODXID
   Qualify (DATES)DATES where DT = O.ORDER_DATE on 3 with ASK NOAUTORESET
   Fetchkeys $ROWID 1000 at a time on 3
   Retrieve DATES D using $ROWID = $ODXID
    Qualify (STATUSES)STATUSES where STATUS = O.STATUS on 4 with ASK \
       NOAUTORESET
    Fetchkeys $ROWID 1000 at a time on 4
    Retrieve STATUSES S using $ROWID = $ODXID
    Pass to queue {1} [D.DESCRIPTION, P.DESCRIPTION, S.DESCRIPTION, D.DT]
Sort {1} for ORDER BY [D.DT ASC, P.DESCRIPTION ASC]
Retrieve {1} sequentially
Return D.DESCRIPTION, P.DESCRIPTION, S.DESCRIPTION
-------------------------------------------------------------------------------
> ; <TEST=WO7>
> ;91
> select a.initials, t.description from activity a join ticklers t \
 (cont) >   on (a.tickler = t.tickler) \
 (cont) >   where a.dt >= '01-01-1998' and t.description like '%Catalog'
----------------------------------- SUMMARY -----------------------------------
Select        A.INITIALS, \
              T.DESCRIPTION \
  from        ACTIVITY A \
  join        TICKLERS T on A.TICKLER = T.TICKLER \
  where       A.DT >= '01-01-1998' and \
              T.DESCRIPTION like '%Catalog'

Version:      <version>
Optimization: MDKQUAL, ASKLINK
----------------------------------- DETAILS -----------------------------------
Qualify (TICKLERS)TICKLERS where DESCRIPTION = '*Catalog' on 1 with NOAUTORESET
   (6 TICKLERS, 6 Pre-intersect   <time>)
Join TICKLERS using TICKLER to (ACTIVITY)ACTIVITY using TICKLER on 1 with \
   NOAUTORESET
   (94 ACTIVITY, 94 Pre-intersect   <time>)
Qualify (ACTIVITY)ACTIVITY where and DT >= '01-01-1998' on 1 with NOAUTORESET
   (18 ACTIVITY, 18 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ACTIVITY A using $ROWID = $ODXID
  Qualify (TICKLERS)TICKLERS where TICKLER = A.TICKLER on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve TICKLERS T using $ROWID = $ODXID
  Return A.INITIALS, T.DESCRIPTION
-------------------------------------------------------------------------------
> ; <TEST=WO8>
> ;92
> select contact, f.description, m.description \
 (cont) >   from prospects p, mailings m, mailflags f \
 (cont) >  where (p.mailing = m.mailing and p.mailflag = f.mailflag) and \
 (cont) >         m.description = 'All' and f.description like '%catalogs%' \
 (cont) >         and f.description not like '%flyers%' \
 (cont) >  order by p.acct, m.mailing desc
----------------------------------- SUMMARY -----------------------------------
Select        CONTACT, \
              F.DESCRIPTION, \
              M.DESCRIPTION \
  from        PROSPECTS P, \
              MAILINGS M, \
              MAILFLAGS F \
  where       P.MAILING = M.MAILING and \
              P.MAILFLAG = F.MAILFLAG and \
              M.DESCRIPTION = 'All' and \
              F.DESCRIPTION like '%catalogs%' and \
              F.DESCRIPTION not like '%flyers%' \
  order by    P.ACCT, \
              M.MAILING desc

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (MAILINGS)MAILINGS where DESCRIPTION = 'All' on 1 with NOAUTORESET
   (1 MAILINGS, 1 Pre-intersect   <time>)
Export to queue M1 on 1 with ODXSI
   (1 row exported   <time>)
Qualify (MAILFLAGS)MAILFLAGS where DESCRIPTION = '*catalogs* and not \
   *flyers*' on 1 with NOAUTORESET
   (1 MAILFLAGS, 1 Pre-intersect   <time>)
Join MAILFLAGS using MAILFLAG to (PROSPECTS)PROSPECTS using MAILFLAG on 1 \
   with NOAUTORESET
   (2 PROSPECTS, 2 Pre-intersect   <time>)
Qualify (PROSPECTS)PROSPECTS where and $ODXID = 'queue(M1, 13)' on 1 with \
   NOAUTORESET
   (2 PROSPECTS, 10 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve PROSPECTS P using $ROWID = $ODXID
  Qualify (MAILINGS)MAILINGS where MAILING = P.MAILING on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve MAILINGS M using $ROWID = $ODXID
   Qualify (MAILFLAGS)MAILFLAGS where MAILFLAG = P.MAILFLAG on 3 with ASK \
      NOAUTORESET
   Fetchkeys $ROWID 1000 at a time on 3
   Retrieve MAILFLAGS F using $ROWID = $ODXID
   Pass to queue {1} [P.CONTACT, F.DESCRIPTION, M.DESCRIPTION, P.ACCT, \
      M.MAILING]
Sort {1} for ORDER BY [P.ACCT ASC, M.MAILING DESC]
Retrieve {1} sequentially
Return P.CONTACT, F.DESCRIPTION, M.DESCRIPTION
-------------------------------------------------------------------------------
> ; <TEST=WO9>
> ;93
> select tax_state, region, last_order \
 (cont) >   from orders o, prospects p \
 (cont) >   where p.acct = o.acct and \
 (cont) >         p.last_order <= '12-31-1996' and \
 (cont) >         ((p.region = 'MW' or o.tax_state in ('CO', 'KS', 'NE', 'IL')) \
 (cont) >          and (o.total >= 1000.00 or o.quantity > 100)) \
 (cont) >   order by region desc, tax_state
----------------------------------- SUMMARY -----------------------------------
Select        TAX_STATE, \
              REGION, \
              LAST_ORDER \
  from        ORDERS O, \
              PROSPECTS P \
  where       P.ACCT = O.ACCT and \
              P.LAST_ORDER <= '12-31-1996' and \
              ((P.REGION = 'MW' or \
                O.TAX_STATE in ('CO', 'KS', 'NE', 'IL')) and \
               (O.TOTAL >= 1000.00 or \
                O.QUANTITY > 100)) \
  order by    REGION desc, \
              TAX_STATE

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where REGION = 'MW' on 1 with NOAUTORESET
   (5 PROSPECTS, 5 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or TAX_STATE in ('CO','KS','NE','IL') on 1 with \
   NOAUTORESET
   (200 ORDERS, 164 Pre-intersect   <time>)
Export to queue O1 on 1 with ODXID
   (200 rows exported   <time>)
Qualify (ORDERS)ORDERS where TOTAL >= '1000.00' on 1 with NOAUTORESET
   (76 ORDERS, 76 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY > '100' on 1 with NOAUTORESET
   (76 ORDERS, 0 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PROSPECTS)PROSPECTS using ACCT on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PROSPECTS)PROSPECTS where and LAST_ORDER <= '12-31-1996' on 1 with \
   NOAUTORESET,PRESERVERS
   (11 ORDERS, 1 PROSPECTS, 2 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where and $ODXID = 'queue(O1)' on 1 with NOAUTORESET
   (11 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PROSPECTS P using $ROWID = $ODXID
  Pass to queue {1} [O.TAX_STATE, P.REGION, P.LAST_ORDER]
Sort {1} for ORDER BY [P.REGION DESC, O.TAX_STATE ASC]
Retrieve {1} sequentially
Return O.TAX_STATE, P.REGION, P.LAST_ORDER
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=WO9r>
> ;94
> select tax_state, region, last_order \
 (cont) >   from orders o, prospects p \
 (cont) >   where p.acct = o.acct and \
 (cont) >         p.last_order <= '12-31-1996' and \
 (cont) >         ((p.region = 'MW' or o.tax_state in ('CO', 'KS', 'NE', 'IL')) \
 (cont) >          and (o.total >= 1000.00 or o.quantity > 100)) \
 (cont) >   order by region desc, tax_state
----------------------------------- SUMMARY -----------------------------------
Select        TAX_STATE, \
              REGION, \
              LAST_ORDER \
  from        ORDERS O, \
              PROSPECTS P \
  where       P.ACCT = O.ACCT and \
              P.LAST_ORDER <= '12-31-1996' and \
              ((P.REGION = 'MW' or \
                O.TAX_STATE in ('CO', 'KS', 'NE', 'IL')) and \
               (O.TOTAL >= 1000.00 or \
                O.QUANTITY > 100)) \
  order by    REGION desc, \
              TAX_STATE

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where REGION = 'MW' on 1 with NOAUTORESET
   (5 PROSPECTS, 5 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or TAX_STATE in ('CO','KS','NE','IL') on 1 with \
   NOAUTORESET
   (200 ORDERS, 164 Pre-intersect   <time>)
Export to queue O1 on 1 with ODXID
   (200 rows exported   <time>)
Qualify (ORDERS)ORDERS where TOTAL >= '1000.00' on 1 with NOAUTORESET
   (76 ORDERS, 76 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY > '100' on 1 with NOAUTORESET
   (76 ORDERS, 0 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PROSPECTS)PROSPECTS using ACCT on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PROSPECTS)PROSPECTS where and LAST_ORDER <= '12-31-1996' on 1 with \
   NOAUTORESET,PRESERVERS
   (11 ORDERS, 1 PROSPECTS, 2 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where and $ODXID = 'queue(O1)' on 1 with NOAUTORESET
   (11 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PROSPECTS P using $ROWID = $ODXID
  Pass to queue {1} [O.TAX_STATE, P.REGION, P.LAST_ORDER]
Sort {1} for ORDER BY [P.REGION DESC, O.TAX_STATE ASC]
Retrieve {1} sequentially
Return O.TAX_STATE, P.REGION, P.LAST_ORDER
-------------------------------------------------------------------------------
> ;
> ;
> ; <SECTION=WHERE-CLAUSE-OPT-$ODXID>
> ;
> ; Tests where-clause optimization following an explicit qualify
> ;
> ; <TEST=QWO1>
> ;95
> qualify prospects where company = 'systems'
----------------------------------- SUMMARY -----------------------------------
Qualify       PROSPECTS \
  where       COMPANY = 'systems'

Version:      <version>
Index:        (PROSPECTS)PROSPECTS.COMPANY
----------------------------------- DETAILS -----------------------------------
ox_find systems on 1 with NOAUTORESET
   (4 PROSPECTS, 4 Pre-intersect   <time>)
-------------------------------------------------------------------------------
> select company from prospects where cust_since = '1998' with odxid
----------------------------------- SUMMARY -----------------------------------
Select        COMPANY \
  from        PROSPECTS \
  where       CUST_SINCE = '1998' \
  with        ODXID

Version:      <version>
Optimization: MDKQUAL
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where and CUST_SINCE = '1998' on 1 with \
   NOAUTORESET
   (3 PROSPECTS, 4 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve PROSPECTS using $ROWID = $ODXID
 Return PROSPECTS.COMPANY
-------------------------------------------------------------------------------
> ; try a distinct
> ; <TEST=QWO2>
> ;96
> qualify prospects where company = 'systems'
----------------------------------- SUMMARY -----------------------------------
Qualify       PROSPECTS \
  where       COMPANY = 'systems'

Version:      <version>
Index:        (PROSPECTS)PROSPECTS.COMPANY
----------------------------------- DETAILS -----------------------------------
ox_find systems on 1 with NOAUTORESET
   (4 PROSPECTS, 4 Pre-intersect   <time>)
-------------------------------------------------------------------------------
> select distinct region from prospects where cust_since = '1998' with odxid
----------------------------------- SUMMARY -----------------------------------
Select        distinct REGION \
  from        PROSPECTS \
  where       CUST_SINCE = '1998' \
  with        ODXID

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where and CUST_SINCE = '1998' on 1 with \
   NOAUTORESET
   (3 PROSPECTS, 4 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve PROSPECTS using $ROWID = $ODXID
 Pass to queue {1} [PROSPECTS.REGION]
Sort {1} for DISTINCT [PROSPECTS.REGION ASC]
Retrieve {1} sequentially
Return PROSPECTS.REGION
-------------------------------------------------------------------------------
> ;<TEST=QWO3>
> ;97
> qualify activity where initials <> 'SHIP'
----------------------------------- SUMMARY -----------------------------------
Qualify       ACTIVITY \
  where       INITIALS <> 'SHIP'

Version:      <version>
Index:        (ACTIVITY)ACTIVITY.INITIALS
----------------------------------- DETAILS -----------------------------------
ox_find @,-SHIP on 1 with NOAUTORESET
   (3 ACTIVITY, 3 Pre-intersect   <time>)
-------------------------------------------------------------------------------
> select min(dt) from activity where tickler = 'RC' with odxid
----------------------------------- SUMMARY -----------------------------------
Select        min(DT) \
  from        ACTIVITY \
  where       TICKLER = 'RC' \
  with        ODXID

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where and TICKLER = 'RC' on 1 with NOAUTORESET
   (2 ACTIVITY, 2 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ACTIVITY using $ROWID = $ODXID
Return MIN(ACTIVITY.DT)
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=QWO3r>
> ;98
> qualify activity where initials <> 'SHIP'
----------------------------------- SUMMARY -----------------------------------
Qualify       ACTIVITY \
  where       INITIALS <> 'SHIP'

Version:      <version>
Index:        (ACTIVITY)ACTIVITY.INITIALS
----------------------------------- DETAILS -----------------------------------
ox_find @,-SHIP on 1 with NOAUTORESET
   (3 ACTIVITY, 3 Pre-intersect   <time>)
-------------------------------------------------------------------------------
> select min(dt) from activity where tickler = 'RC' with odxid
----------------------------------- SUMMARY -----------------------------------
Select        min(DT) \
  from        ACTIVITY \
  where       TICKLER = 'RC' \
  with        ODXID

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where and TICKLER = 'RC' on 1 with NOAUTORESET
   (2 ACTIVITY, 2 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ACTIVITY using $ROWID = $ODXID
Return MIN(ACTIVITY.DT)
-------------------------------------------------------------------------------
> ; try an ims agg
> ; <TEST=QWO4>
> ;99
> qualify orders where discount > 10
----------------------------------- SUMMARY -----------------------------------
Qualify       ORDERS \
  where       DISCOUNT > '10'

Version:      <version>
Index:        (ORDERS)ORDERS.DISCOUNT
----------------------------------- DETAILS -----------------------------------
ox_find >10: on 1 with NOAUTORESET
   (163 ORDERS, 163 Pre-intersect   <time>)
-------------------------------------------------------------------------------
> select top 10% product_no, sum(amount), count(*), avg(quantity) from orders \
 (cont) >  where discount > 0 \
 (cont) >  group by product_no \
 (cont) >   with odxid
----------------------------------- SUMMARY -----------------------------------
Select        top 10 % PRODUCT_NO, \
              sum(AMOUNT), \
              count(*), \
              avg(QUANTITY) \
  from        ORDERS \
  where       DISCOUNT > 0 \
  group by    PRODUCT_NO \
  with        ODXID

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where and DISCOUNT > '0' on 1 with NOAUTORESET
   (163 ORDERS, 199 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for GROUP(PRODUCT_NO), COUNT(*), \
   AVG(QUANTITY), SUM(AMOUNT) on 1 with ALT SORT
Pass to queue {1} [ORDERS.PRODUCT_NO, SUM(ORDERS.AMOUNT), COUNT('*'), \
   AVG(ORDERS.QUANTITY)]
Retrieve {1} sequentially
Return TOP 10% ORDERS.PRODUCT_NO, SUM(ORDERS.AMOUNT), COUNT('*'), \
   AVG(ORDERS.QUANTITY)
-------------------------------------------------------------------------------
> ; try an ims qualify
> ; <TEST=QWO5>
> ;100
> qualify orders where pt = 'H*' with ask
----------------------------------- SUMMARY -----------------------------------
Qualify       ORDERS \
  where       PT = 'H*' \
  with        ASK

Version:      <version>
Index:        (ORDERS)ORDERS.PT
----------------------------------- DETAILS -----------------------------------
dbigetkeys H* on 1
   (45 ORDERS   <time>)
-------------------------------------------------------------------------------
> select distinct acct, total from orders where tax_state = 'TX' with odxid
----------------------------------- SUMMARY -----------------------------------
Select        distinct ACCT, \
              TOTAL \
  from        ORDERS \
  where       TAX_STATE = 'TX' \
  with        ODXID

Version:      <version>
Optimization: ASKQUAL
Warnings:     UNOPTIMIZED_CRITERIA, UNOPTIMIZED_SORT
Notes:        Omnidex indexes will not be used because existing list is on an
                ASK key.
----------------------------------- DETAILS -----------------------------------
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Filter ORDERS.TAX_STATE = 'TX'
 Pass to queue {1} [ORDERS.ACCT, ORDERS.TOTAL]
Sort {1} for DISTINCT [ORDERS.ACCT ASC, ORDERS.TOTAL ASC]
Retrieve {1} sequentially
Return ORDERS.ACCT, ORDERS.TOTAL
-------------------------------------------------------------------------------
> ; try an 'or'
> ; <TEST=QWO6>
> ;101
> qualify orders where discount > 10
----------------------------------- SUMMARY -----------------------------------
Qualify       ORDERS \
  where       DISCOUNT > '10'

Version:      <version>
Index:        (ORDERS)ORDERS.DISCOUNT
----------------------------------- DETAILS -----------------------------------
ox_find >10: on 1 with NOAUTORESET
   (163 ORDERS, 163 Pre-intersect   <time>)
-------------------------------------------------------------------------------
> select product_no from orders \
 (cont) >  where $rowid in $odxid or \
 (cont) >        (order_date between '02-14-1996' and '12-07-1996' and \
 (cont) >         not (amount < 100))
----------------------------------- SUMMARY -----------------------------------
Select        PRODUCT_NO \
  from        ORDERS \
  where       $ROWID in $odxid or \
              (ORDER_DATE between '02-14-1996' and '12-07-1996' and \
               not AMOUNT < 100)

Version:      <version>
Optimization: MDKQUAL, ASKRETRIEVAL
----------------------------------- DETAILS -----------------------------------
Export to queue O1 on 1 with ODXID
   (163 rows exported   <time>)
Qualify (ORDERS)ORDERS where ORDER_DATE between '02-14-1996' and '12-07-1996' \
   on 1 with NOAUTORESET
   (7 ORDERS, 7 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and not AMOUNT < '100' on 1 with NOAUTORESET
   (6 ORDERS, 56 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or $ODXID = 'queue(O1)' on 1 with NOAUTORESET
   (164 ORDERS, 163 Pre-intersect   <time>)
Retrieve from index PT on 1
Return ORDERS.PRODUCT_NO
-------------------------------------------------------------------------------
> ;
> ;
> ; <SECTION=HAVING>
> ; (in addition to those tested above)
> ;
> ; <TEST=H1>
> ;102
> select count(*) from orders group by sales_tax having count(*) > 1
----------------------------------- SUMMARY -----------------------------------
Select        count(*) \
  from        ORDERS \
  group by    SALES_TAX \
  having      count(*) > 1

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where SALES_TAX = 'all_keywds' on 1 with KEYWD
   (111 keywords   <time>)
Fetchkeys SALES_TAX 1000 at a time on 1
Filter COUNT('*') > 1
Return COUNT('*')
-------------------------------------------------------------------------------
> ;
> ; non-optimized
> ; <TEST=H2>
> ;103
> select min(cust_since), last_order, contact from prospects \
 (cont) >  where (contact not like 'Clint%') \
 (cont) >  group by last_order, contact having min(cust_since) >= 1997
----------------------------------- SUMMARY -----------------------------------
Select        min(CUST_SINCE), \
              LAST_ORDER, \
              CONTACT \
  from        PROSPECTS \
  where       CONTACT not like 'Clint%' \
  group by    LAST_ORDER, \
              CONTACT \
  having      min(CUST_SINCE) >= 1997

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where CONTACT <> 'Clint*' on 1 with NOAUTORESET
   (9 PROSPECTS, 9 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve PROSPECTS using $ROWID = $ODXID
 Pass to queue {1} [PROSPECTS.CUST_SINCE, PROSPECTS.LAST_ORDER, \
    PROSPECTS.CONTACT]
Sort {1} for GROUP BY [PROSPECTS.LAST_ORDER ASC, PROSPECTS.CONTACT ASC]
Retrieve {1} sequentially
Filter MIN(PROSPECTS.CUST_SINCE) >= 1997
Return MIN(PROSPECTS.CUST_SINCE), PROSPECTS.LAST_ORDER, PROSPECTS.CONTACT
-------------------------------------------------------------------------------
> ;
> ; not in select list
> ; <TEST=H3>
> ;104
> select max(cust_since), contact from prospects \
 (cont) > where (contact not like 'Clint%') \
 (cont) > group by contact having min(cust_since) >= 1997
----------------------------------- SUMMARY -----------------------------------
Select        max(CUST_SINCE), \
              CONTACT \
  from        PROSPECTS \
  where       CONTACT not like 'Clint%' \
  group by    CONTACT \
  having      min(CUST_SINCE) >= 1997

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where CONTACT <> 'Clint*' on 1 with NOAUTORESET
   (9 PROSPECTS, 9 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve PROSPECTS using $ROWID = $ODXID
 Pass to queue {1} [PROSPECTS.CUST_SINCE, PROSPECTS.CONTACT, \
    PROSPECTS.CUST_SINCE]
Sort {1} for GROUP BY [PROSPECTS.CONTACT ASC]
Retrieve {1} sequentially
Filter MIN(PROSPECTS.CUST_SINCE) >= 1997
Return MAX(PROSPECTS.CUST_SINCE), PROSPECTS.CONTACT
-------------------------------------------------------------------------------
> ;
> ; multiple-tbl
> ; <TEST=H4>
> ;105
> select dt, prospects.acct, sum(prospects.cr_limit) \
 (cont) >   from prospects, activity \
 (cont) >  where prospects.acct = activity.acct \
 (cont) >  group by dt, prospects.acct \
 (cont) > having activity.dt > '01-01-1991' and prospects.acct < 10 \
 (cont) >        and min(cr_limit) > 0
----------------------------------- SUMMARY -----------------------------------
Select        DT, \
              PROSPECTS.ACCT, \
              sum(PROSPECTS.CR_LIMIT) \
  from        PROSPECTS, \
              ACTIVITY \
  where       PROSPECTS.ACCT = ACTIVITY.ACCT \
  group by    DT, \
              PROSPECTS.ACCT \
  having      ACTIVITY.DT > '01-01-1991' and \
              PROSPECTS.ACCT < 10 and \
              min(CR_LIMIT) > 0

Version:      <version>
Optimization: MDKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
Notes:        Use the HAVING clause to restrict which groups of rows defined by
                a group by clause are returned from the query.
----------------------------------- DETAILS -----------------------------------
Retrieve PROSPECTS sequentially
 Qualify (ACTIVITY)ACTIVITY where ACCT = PROSPECTS.ACCT on 2 with NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve ACTIVITY using $ROWID = $ODXID
 Pass to queue {1} [ACTIVITY.DT, PROSPECTS.ACCT, PROSPECTS.CR_LIMIT, \
    ACTIVITY.DT, PROSPECTS.ACCT, PROSPECTS.CR_LIMIT]
Sort {1} for GROUP BY [ACTIVITY.DT ASC, PROSPECTS.ACCT ASC]
Retrieve {1} sequentially
Filter ACTIVITY.DT > '01-01-1991'
Filter PROSPECTS.ACCT < 10
Filter FILTER 0 AND FILTER 1
Filter MIN(PROSPECTS.CR_LIMIT) > 0
Filter FILTER 2 AND FILTER 3
Return ACTIVITY.DT, PROSPECTS.ACCT, SUM(PROSPECTS.CR_LIMIT)
-------------------------------------------------------------------------------
> ;
> ; grp col optimized
> ; <TEST=H5>
> ;106
> select every 10 dt, prospects.acct, sum(prospects.cr_limit) \
 (cont) >   from prospects, activity \
 (cont) >  where prospects.acct = activity.acct \
 (cont) >  group by dt, prospects.acct \
 (cont) > having activity.dt > '01-01-1991' and prospects.acct < 10 \
 (cont) > order by 1, 2, 3
----------------------------------- SUMMARY -----------------------------------
Select        every 10 DT, \
              PROSPECTS.ACCT, \
              sum(PROSPECTS.CR_LIMIT) \
  from        PROSPECTS, \
              ACTIVITY \
  where       PROSPECTS.ACCT = ACTIVITY.ACCT \
  group by    DT, \
              PROSPECTS.ACCT \
  having      ACTIVITY.DT > '01-01-1991' and \
              PROSPECTS.ACCT < 10 \
  order by    1, \
              2, \
              3

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Use the HAVING clause to restrict which groups of rows defined by
                a group by clause are returned from the query.
              Moving HAVING clause to WHERE clause for better optimization.
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where ACCT < '10' on 1 with NOAUTORESET
   (9 PROSPECTS, 9 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ACTIVITY)ACTIVITY using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ACTIVITY)ACTIVITY where and DT > '01-01-1991' on 1 with NOAUTORESET
   (95 ACTIVITY, 96 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ACTIVITY using $ROWID = $ODXID
  Qualify (PROSPECTS)PROSPECTS where ACCT = ACTIVITY.ACCT on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PROSPECTS using $ROWID = $ODXID
  Pass to queue {1} [ACTIVITY.DT, PROSPECTS.ACCT, PROSPECTS.CR_LIMIT]
Sort {1} for GROUP BY [ACTIVITY.DT ASC, PROSPECTS.ACCT ASC]
Retrieve {1} sequentially
Pass to queue {2} [ACTIVITY.DT, PROSPECTS.ACCT, SUM(PROSPECTS.CR_LIMIT)]
Sort {2} for ORDER BY [ACTIVITY.DT ASC, PROSPECTS.ACCT ASC, \
   SUM(PROSPECTS.CR_LIMIT) ASC]
Retrieve {2} sequentially
Return EVERY 10 ACTIVITY.DT, PROSPECTS.ACCT, SUM(PROSPECTS.CR_LIMIT)
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=H5r>
> ;107
> select every 10 dt, prospects.acct, sum(prospects.cr_limit) \
 (cont) >   from prospects, activity \
 (cont) >  where prospects.acct = activity.acct \
 (cont) >  group by dt, prospects.acct \
 (cont) > having activity.dt > '01-01-1991' and prospects.acct < 10 \
 (cont) > order by 1, 2, 3
----------------------------------- SUMMARY -----------------------------------
Select        every 10 DT, \
              PROSPECTS.ACCT, \
              sum(PROSPECTS.CR_LIMIT) \
  from        PROSPECTS, \
              ACTIVITY \
  where       PROSPECTS.ACCT = ACTIVITY.ACCT \
  group by    DT, \
              PROSPECTS.ACCT \
  having      ACTIVITY.DT > '01-01-1991' and \
              PROSPECTS.ACCT < 10 \
  order by    1, \
              2, \
              3

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Use the HAVING clause to restrict which groups of rows defined by
                a group by clause are returned from the query.
              Moving HAVING clause to WHERE clause for better optimization.
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where ACCT < '10' on 1 with NOAUTORESET
   (9 PROSPECTS, 9 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ACTIVITY)ACTIVITY using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ACTIVITY)ACTIVITY where and DT > '01-01-1991' on 1 with NOAUTORESET
   (95 ACTIVITY, 96 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ACTIVITY using $ROWID = $ODXID
  Qualify (PROSPECTS)PROSPECTS where ACCT = ACTIVITY.ACCT on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PROSPECTS using $ROWID = $ODXID
  Pass to queue {1} [ACTIVITY.DT, PROSPECTS.ACCT, PROSPECTS.CR_LIMIT]
Sort {1} for GROUP BY [ACTIVITY.DT ASC, PROSPECTS.ACCT ASC]
Retrieve {1} sequentially
Pass to queue {2} [ACTIVITY.DT, PROSPECTS.ACCT, SUM(PROSPECTS.CR_LIMIT)]
Sort {2} for ORDER BY [ACTIVITY.DT ASC, PROSPECTS.ACCT ASC, \
   SUM(PROSPECTS.CR_LIMIT) ASC]
Retrieve {2} sequentially
Return EVERY 10 ACTIVITY.DT, PROSPECTS.ACCT, SUM(PROSPECTS.CR_LIMIT)
-------------------------------------------------------------------------------
> ;
> ; mst-optimized
> ; <TEST=H6>
> ;108
> select min(quantity) from orders \
 (cont) >        having min(quantity) = 1
----------------------------------- SUMMARY -----------------------------------
Select        min(QUANTITY) \
  from        ORDERS \
  having      min(QUANTITY) = 1

Version:      <version>
Optimization: AGGREGATION
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for MIN(QUANTITY) HAVING \
   MIN(ORDERS.QUANTITY) = 1 on 1
Return MIN(ORDERS.QUANTITY)
-------------------------------------------------------------------------------
> ; <TEST=H7>
> ;109
> select acct, avg(amount) from orders \
 (cont) >        group by acct \
 (cont) >        having avg(amount) <= 1000 and avg(amount) >= 10
----------------------------------- SUMMARY -----------------------------------
Select        ACCT, \
              avg(AMOUNT) \
  from        ORDERS \
  group by    ACCT \
  having      avg(AMOUNT) <= 1000 and \
              avg(AMOUNT) >= 10

Version:      <version>
Optimization: AGGREGATION
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(ACCT), AVG(AMOUNT) HAVING \
   AVG(ORDERS.AMOUNT) <= 1000 AND AVG(ORDERS.AMOUNT) >= 10 on 1
Return ORDERS.ACCT, AVG(ORDERS.AMOUNT)
-------------------------------------------------------------------------------
> ;
> ; "having" not in sel list
> ; <TEST=H8>
> ;110
> select discount, sum(total) \
 (cont) >   from orders \
 (cont) >  where pmt_method <= 5 \
 (cont) >  group by discount \
 (cont) > having avg(quantity) > 10
----------------------------------- SUMMARY -----------------------------------
Select        DISCOUNT, \
              sum(TOTAL) \
  from        ORDERS \
  where       PMT_METHOD <= 5 \
  group by    DISCOUNT \
  having      avg(QUANTITY) > 10

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where PMT_METHOD <= '5' on 1 with NOAUTORESET
   (82 ORDERS, 82 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for GROUP(DISCOUNT), AVG(QUANTITY), \
   SUM(TOTAL) HAVING AVG(ORDERS.QUANTITY) > 10 on 1 with ALT SORT
Return ORDERS.DISCOUNT, SUM(ORDERS.TOTAL)
-------------------------------------------------------------------------------
> ;
> ; mix, complex
> ; <TEST=H9>
> ;111
> select discount, avg(total) * count(*), min(quantity) mq, max(sales_tax) ms \
 (cont) >   from orders \
 (cont) >  group by discount \
 (cont) > having (sum(amount * quantity) > 100.00 or count(*) < 10) and \
 (cont) >        ms / mq < 100.0
----------------------------------- SUMMARY -----------------------------------
Select        DISCOUNT, \
              avg(TOTAL) * count(*), \
              min(QUANTITY) MQ, \
              max(SALES_TAX) MS \
  from        ORDERS \
  group by    DISCOUNT \
  having      (sum(AMOUNT * QUANTITY) > 100.00 or \
               count(*) < 10) and \
              MS / MQ < 100.0

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
----------------------------------- DETAILS -----------------------------------
Retrieve ORDERS sequentially
Pass to queue {1} [ORDERS.DISCOUNT, ORDERS.TOTAL, ORDERS.QUANTITY, \
   ORDERS.SALES_TAX, ORDERS.AMOUNT * ORDERS.QUANTITY, ORDERS.SALES_TAX, \
   ORDERS.QUANTITY]
Sort {1} for GROUP BY [ORDERS.DISCOUNT ASC]
Retrieve {1} sequentially
Filter SUM(ORDERS.AMOUNT * ORDERS.QUANTITY) > 100.00
Filter COUNT('*') < 10
Filter FILTER 0 OR FILTER 1
Filter MAX(ORDERS.SALES_TAX) / MIN(ORDERS.QUANTITY) < 100.0
Filter FILTER 2 AND FILTER 3
Return ORDERS.DISCOUNT, AVG(ORDERS.TOTAL) * COUNT('*'), MQ, MS
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=H9r>
> ;112
> select discount, avg(total) * count(*), min(quantity) mq, max(sales_tax) ms \
 (cont) >   from orders \
 (cont) >  group by discount \
 (cont) > having (sum(amount * quantity) > 100.00 or count(*) < 10) and \
 (cont) >        ms / mq < 100.0
----------------------------------- SUMMARY -----------------------------------
Select        DISCOUNT, \
              avg(TOTAL) * count(*), \
              min(QUANTITY) MQ, \
              max(SALES_TAX) MS \
  from        ORDERS \
  group by    DISCOUNT \
  having      (sum(AMOUNT * QUANTITY) > 100.00 or \
               count(*) < 10) and \
              MS / MQ < 100.0

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
----------------------------------- DETAILS -----------------------------------
Retrieve ORDERS sequentially
Pass to queue {1} [ORDERS.DISCOUNT, ORDERS.TOTAL, ORDERS.QUANTITY, \
   ORDERS.SALES_TAX, ORDERS.AMOUNT * ORDERS.QUANTITY, ORDERS.SALES_TAX, \
   ORDERS.QUANTITY]
Sort {1} for GROUP BY [ORDERS.DISCOUNT ASC]
Retrieve {1} sequentially
Filter SUM(ORDERS.AMOUNT * ORDERS.QUANTITY) > 100.00
Filter COUNT('*') < 10
Filter FILTER 0 OR FILTER 1
Filter MAX(ORDERS.SALES_TAX) / MIN(ORDERS.QUANTITY) < 100.0
Filter FILTER 2 AND FILTER 3
Return ORDERS.DISCOUNT, AVG(ORDERS.TOTAL) * COUNT('*'), MQ, MS
-------------------------------------------------------------------------------
> ; <TEST=H10>
> ;113
> select count(quantity), 100 * $round(avg(total * 0.90), 1), max(wholesale) \
 (cont) >   from orders o, products p \
 (cont) >  where o.product_no = p.product_no and \
 (cont) >         (o.amount < 100 or o.quantity between 5 and 10 \
 (cont) >         or p.description like '%Computer') \
 (cont) >  group by category \
 (cont) > having count(quantity) < 100 or \
 (cont) >        sum(wholesale * quantity) >= sum(amount * quantity) or \
 (cont) >        category not in (1,2,3,8,9,10,21,22,23)
----------------------------------- SUMMARY -----------------------------------
Select        count(QUANTITY), \
              100 * $round(avg(TOTAL * 0.90), 1), \
              max(WHOLESALE) \
  from        ORDERS O, \
              PRODUCTS P \
  where       O.PRODUCT_NO = P.PRODUCT_NO and \
              (O.AMOUNT < 100 or \
               O.QUANTITY between 5 and 10 or \
               P.DESCRIPTION like '%Computer') \
  group by    CATEGORY \
  having      count(QUANTITY) < 100 or \
              sum(WHOLESALE * QUANTITY) >= sum(AMOUNT * QUANTITY) or \
              CATEGORY not in (1, 2, 3, 8, 9, 10, 21, 22, 23)

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where DESCRIPTION = '*Computer' on 1 with \
   NOAUTORESET
   (11 PRODUCTS, 11 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or AMOUNT < '100' on 1 with NOAUTORESET
   (114 ORDERS, 56 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY between '5' and '10' on 1 with \
   NOAUTORESET
   (118 ORDERS, 16 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (118 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PRODUCTS P using $ROWID = $ODXID
  Pass to queue {1} [O.QUANTITY, O.TOTAL * 0.90, P.WHOLESALE, P.CATEGORY, \
     P.WHOLESALE * O.QUANTITY, O.AMOUNT * O.QUANTITY, P.CATEGORY]
Sort {1} for GROUP BY [P.CATEGORY ASC]
Retrieve {1} sequentially
Filter COUNT(O.QUANTITY) < 100
Filter SUM(P.WHOLESALE * O.QUANTITY) >= SUM(O.AMOUNT * O.QUANTITY)
Filter FILTER 0 OR FILTER 1
Filter NOT P.CATEGORY IN (1,2,3,8,9,10,21,22,23)
Filter FILTER 2 OR FILTER 3
Return COUNT(O.QUANTITY), 100 * $ROUND(AVG(O.TOTAL * 0.90),1), MAX(P.WHOLESALE)
-------------------------------------------------------------------------------
> ;
> ; on date
> ; <TEST=H11>
> ;114
> select acct, min(order_date) from orders where pmt_method >= 5 \
 (cont) >  group by acct \
 (cont) > having max(order_date) = '10-20-1996'
----------------------------------- SUMMARY -----------------------------------
Select        ACCT, \
              min(ORDER_DATE) \
  from        ORDERS \
  where       PMT_METHOD >= 5 \
  group by    ACCT \
  having      max(ORDER_DATE) = '10-20-1996'

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where PMT_METHOD >= '5' on 1 with NOAUTORESET
   (138 ORDERS, 138 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for GROUP(ACCT), MIN(ORDER_DATE), \
   MAX(ORDER_DATE) HAVING MAX(ORDERS.ORDER_DATE) = '10-20-1996' on 1
Return ORDERS.ACCT, MIN(ORDERS.ORDER_DATE)
-------------------------------------------------------------------------------
> ;
> ;
> ;
> ; <SECTION=ORDER_BY>
> ; (in addition to those tested above)
> ;
> ; <TEST=O1>
> ;115
> select acct from prospects order by acct desc
----------------------------------- SUMMARY -----------------------------------
Select        ACCT \
  from        PROSPECTS \
  order by    ACCT desc

Version:      <version>
Optimization: ASKRETRIEVAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where ACCT_NO = '*' on 1 with ASK, NOAUTORESET
Retrieve from index ACCT_NO on 1
Pass to queue {1} [PROSPECTS.ACCT]
Sort {1} for ORDER BY [PROSPECTS.ACCT DESC]
Retrieve {1} sequentially
Return PROSPECTS.ACCT
-------------------------------------------------------------------------------
> ; <TEST=O2>
> ;116
> select quantity from orders \
 (cont) >   where discount >= 20 and total > 1000 and not quantity < 15 \
 (cont) >   order by quantity desc
----------------------------------- SUMMARY -----------------------------------
Select        QUANTITY \
  from        ORDERS \
  where       DISCOUNT >= 20 and \
              TOTAL > 1000 and \
              not QUANTITY < 15 \
  order by    QUANTITY desc

Version:      <version>
Optimization: MDKQUAL, ASKRETRIEVAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where DISCOUNT >= '20' on 1 with NOAUTORESET
   (163 ORDERS, 163 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and TOTAL > '1000' on 1 with NOAUTORESET
   (65 ORDERS, 76 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and not QUANTITY < '15' on 1 with NOAUTORESET
   (12 ORDERS, 183 Pre-intersect   <time>)
Retrieve from index APOSTDQSAT on 1
Pass to queue {1} [ORDERS.QUANTITY]
Sort {1} for ORDER BY [ORDERS.QUANTITY DESC]
Retrieve {1} sequentially
Return ORDERS.QUANTITY
-------------------------------------------------------------------------------
> ; <TEST=O3>
> ;117
> select quantity from orders \
 (cont) >   where discount >= 20 and total > 1000 and not quantity < 15 \
 (cont) >   order by order_date desc
----------------------------------- SUMMARY -----------------------------------
Select        QUANTITY \
  from        ORDERS \
  where       DISCOUNT >= 20 and \
              TOTAL > 1000 and \
              not QUANTITY < 15 \
  order by    ORDER_DATE desc

Version:      <version>
Optimization: MDKQUAL, ASKRETRIEVAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where DISCOUNT >= '20' on 1 with NOAUTORESET
   (163 ORDERS, 163 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and TOTAL > '1000' on 1 with NOAUTORESET
   (65 ORDERS, 76 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and not QUANTITY < '15' on 1 with NOAUTORESET
   (12 ORDERS, 183 Pre-intersect   <time>)
Retrieve from index APOSTDQSAT on 1
Pass to queue {1} [ORDERS.QUANTITY, ORDERS.ORDER_DATE]
Sort {1} for ORDER BY [ORDERS.ORDER_DATE DESC]
Retrieve {1} sequentially
Return ORDERS.QUANTITY
-------------------------------------------------------------------------------
> ; <TEST=O4>
> ;118
> select pmt_method, discount, quantity, amount from orders \
 (cont) >   where total > 1000 \
 (cont) >  order by 2 desc, 1, 4 desc
----------------------------------- SUMMARY -----------------------------------
Select        PMT_METHOD, \
              DISCOUNT, \
              QUANTITY, \
              AMOUNT \
  from        ORDERS \
  where       TOTAL > 1000 \
  order by    2 desc, \
              1, \
              4 desc

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where TOTAL > '1000' on 1 with NOAUTORESET
   (76 ORDERS, 76 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.PMT_METHOD, ORDERS.DISCOUNT, ORDERS.QUANTITY, \
    ORDERS.AMOUNT]
Sort {1} for ORDER BY [ORDERS.DISCOUNT DESC, ORDERS.PMT_METHOD ASC, \
   ORDERS.AMOUNT DESC]
Retrieve {1} sequentially
Return ORDERS.PMT_METHOD, ORDERS.DISCOUNT, ORDERS.QUANTITY, ORDERS.AMOUNT
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=O4r>
> ;119
> select pmt_method, discount, quantity, amount from orders \
 (cont) >   where total > 1000 \
 (cont) >  order by 2 desc, 1, 4 desc
----------------------------------- SUMMARY -----------------------------------
Select        PMT_METHOD, \
              DISCOUNT, \
              QUANTITY, \
              AMOUNT \
  from        ORDERS \
  where       TOTAL > 1000 \
  order by    2 desc, \
              1, \
              4 desc

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where TOTAL > '1000' on 1 with NOAUTORESET
   (76 ORDERS, 76 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.PMT_METHOD, ORDERS.DISCOUNT, ORDERS.QUANTITY, \
    ORDERS.AMOUNT]
Sort {1} for ORDER BY [ORDERS.DISCOUNT DESC, ORDERS.PMT_METHOD ASC, \
   ORDERS.AMOUNT DESC]
Retrieve {1} sequentially
Return ORDERS.PMT_METHOD, ORDERS.DISCOUNT, ORDERS.QUANTITY, ORDERS.AMOUNT
-------------------------------------------------------------------------------
> ; <TEST=O5>
> ;120
> select top 10 * from activity \
 (cont) >   where dt >= '01-01-1996' and initials != 'EFR' \
 (cont) >   order by initials desc, tickler desc, dt, acct
----------------------------------- SUMMARY -----------------------------------
Select        top 10 * \
  from        ACTIVITY \
  where       DT >= '01-01-1996' and \
              INITIALS <> 'EFR' \
  order by    INITIALS desc, \
              TICKLER desc, \
              DT, \
              ACCT

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where DT >= '01-01-1996' on 1 with NOAUTORESET
   (62 ACTIVITY, 62 Pre-intersect   <time>)
Qualify (ACTIVITY)ACTIVITY where and INITIALS <> 'EFR' on 1 with NOAUTORESET
   (61 ACTIVITY, 1 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ACTIVITY using $ROWID = $ODXID
 Pass to queue {1} [ACTIVITY.ACCT, ACTIVITY.DT, ACTIVITY.TICKLER, \
    ACTIVITY.INITIALS]
Sort {1} for ORDER BY [ACTIVITY.INITIALS DESC, ACTIVITY.TICKLER DESC, \
   ACTIVITY.DT ASC, ACTIVITY.ACCT ASC]
Retrieve {1} sequentially
Return TOP 10 ACTIVITY.ACCT, ACTIVITY.DT, ACTIVITY.TICKLER, ACTIVITY.INITIALS
-------------------------------------------------------------------------------
> ; <TEST=O6>
> ;121
> select product_no, acct, min(total) from orders \
 (cont) >   group by acct, product_no \
 (cont) >   order by product_no, acct
----------------------------------- SUMMARY -----------------------------------
Select        PRODUCT_NO, \
              ACCT, \
              min(TOTAL) \
  from        ORDERS \
  group by    ACCT, \
              PRODUCT_NO \
  order by    PRODUCT_NO, \
              ACCT

Version:      <version>
Optimization: AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(PRODUCT_NO), GROUP(ACCT), \
   MIN(TOTAL) on 1 with ALT SORT
Return ORDERS.PRODUCT_NO, ORDERS.ACCT, MIN(ORDERS.TOTAL)
-------------------------------------------------------------------------------
> ; see 'where clause' tests for order-by testing on multiple tables
> ; Test reuse
> ; <TEST=O6r>
> ;122
> select product_no, acct, min(total) from orders \
 (cont) >   group by acct, product_no \
 (cont) >   order by product_no, acct
----------------------------------- SUMMARY -----------------------------------
Select        PRODUCT_NO, \
              ACCT, \
              min(TOTAL) \
  from        ORDERS \
  group by    ACCT, \
              PRODUCT_NO \
  order by    PRODUCT_NO, \
              ACCT

Version:      <version>
Optimization: AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(PRODUCT_NO), GROUP(ACCT), \
   MIN(TOTAL) on 1 with ALT SORT
Return ORDERS.PRODUCT_NO, ORDERS.ACCT, MIN(ORDERS.TOTAL)
-------------------------------------------------------------------------------
> ;
> ;
> ; Test 'order by' optimized by imsam
> ;
> ; <TEST=OI1>
> ;123
> select last_order from prospects \
 (cont) >        where last_order > '01-01-1990' \
 (cont) >        order by last_order
----------------------------------- SUMMARY -----------------------------------
Select        LAST_ORDER \
  from        PROSPECTS \
  where       LAST_ORDER > '01-01-1990' \
  order by    LAST_ORDER

Version:      <version>
Optimization: ASKQUAL, ASKORDERBY
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where LAST_ORDER > '01-01-1990' on 1 with ASK, \
   NOAUTORESET
Fetchkeys LAST_ORDER, $ROWID 1000 at a time on 1
Return PROSPECTS.LAST_ORDER
-------------------------------------------------------------------------------
> ; <TEST=OI2>
> ;124
> select profession from prospects \
 (cont) >        where profession > 1 \
 (cont) >        order by profession
----------------------------------- SUMMARY -----------------------------------
Select        PROFESSION \
  from        PROSPECTS \
  where       PROFESSION > 1 \
  order by    PROFESSION

Version:      <version>
Optimization: MDKQUAL, ASKORDERBY
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where PROFESSION > '1' on 1 with NOAUTORESET
   (9 PROSPECTS, 9 Pre-intersect   <time>)
Fetchkeys PROFESSION, INCOME, $ROWID ordered by PI 1000 at a time on 1
Return PROSPECTS.PROFESSION
-------------------------------------------------------------------------------
> ;
> ;
> ;
> ; <SECTION=STARSCHEMA_SCENARIOS>
> ; (may or may not use starschema opt)
> ;
> ; <TEST=SS1>
> ;125
> select p.contact, sum(o.total) from prospects p, orders o \
 (cont) >        where o.acct = p.acct \
 (cont) >        group by p.contact
----------------------------------- SUMMARY -----------------------------------
Select        P.CONTACT, \
              sum(O.TOTAL) \
  from        PROSPECTS P, \
              ORDERS O \
  where       O.ACCT = P.ACCT \
  group by    P.CONTACT

Version:      <version>
Optimization: AGGREGATION, ASKLINK, STARSCHEMA
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using AT for GROUP(ACCT), SUM(TOTAL) on 1
 Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve PROSPECTS P using $ROWID = $ODXID
  Pass to queue {1} [P.CONTACT, SUM(O.TOTAL)]
Sort {1} for GROUP BY [P.CONTACT ASC]
Retrieve {1} sequentially
Return P.CONTACT, SUM(O.TOTAL)
-------------------------------------------------------------------------------
> ; <TEST=SS2>
> ;126
> select r.description, avg(o.amount), min(o.total) from products r, orders o \
 (cont) >        where r.product_no = o.product_no and \
 (cont) >         (o.quantity >= 10 and r.wholesale > 1000.00) \
 (cont) >        group by r.description
----------------------------------- SUMMARY -----------------------------------
Select        R.DESCRIPTION, \
              avg(O.AMOUNT), \
              min(O.TOTAL) \
  from        PRODUCTS R, \
              ORDERS O \
  where       R.PRODUCT_NO = O.PRODUCT_NO and \
              (O.QUANTITY >= 10 and \
               R.WHOLESALE > 1000.00) \
  group by    R.DESCRIPTION

Version:      <version>
Optimization: MDKQUAL, AGGREGATION, ASKLINK, STARSCHEMA
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where WHOLESALE > '1000.00' on 1 with NOAUTORESET
   (11 PRODUCTS, 11 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where and QUANTITY >= '10' on 1 with NOAUTORESET
   (13 ORDERS, 35 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for GROUP(PRODUCT_NO), COUNT(*), \
   AVG(AMOUNT), MIN(TOTAL) on 1 with ALT SORT
 Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
    NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve PRODUCTS R using $ROWID = $ODXID
  Pass to queue {1} [R.DESCRIPTION, AVG(O.AMOUNT), MIN(O.TOTAL), COUNT('*')]
Sort {1} for GROUP BY [R.DESCRIPTION ASC]
Retrieve {1} sequentially
Return R.DESCRIPTION, AVG(O.AMOUNT), MIN(O.TOTAL)
-------------------------------------------------------------------------------
> ; Test reuse
> ; <TEST=SS2r>
> ;127
> select r.description, avg(o.amount), min(o.total) from products r, orders o \
 (cont) >        where r.product_no = o.product_no and \
 (cont) >         (o.quantity >= 10 and r.wholesale > 1000.00) \
 (cont) >        group by r.description
----------------------------------- SUMMARY -----------------------------------
Select        R.DESCRIPTION, \
              avg(O.AMOUNT), \
              min(O.TOTAL) \
  from        PRODUCTS R, \
              ORDERS O \
  where       R.PRODUCT_NO = O.PRODUCT_NO and \
              (O.QUANTITY >= 10 and \
               R.WHOLESALE > 1000.00) \
  group by    R.DESCRIPTION

Version:      <version>
Optimization: MDKQUAL, AGGREGATION, ASKLINK, STARSCHEMA
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where WHOLESALE > '1000.00' on 1 with NOAUTORESET
   (11 PRODUCTS, 11 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where and QUANTITY >= '10' on 1 with NOAUTORESET
   (13 ORDERS, 35 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for GROUP(PRODUCT_NO), COUNT(*), \
   AVG(AMOUNT), MIN(TOTAL) on 1 with ALT SORT
 Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
    NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve PRODUCTS R using $ROWID = $ODXID
  Pass to queue {1} [R.DESCRIPTION, AVG(O.AMOUNT), MIN(O.TOTAL), COUNT('*')]
Sort {1} for GROUP BY [R.DESCRIPTION ASC]
Retrieve {1} sequentially
Return R.DESCRIPTION, AVG(O.AMOUNT), MIN(O.TOTAL)
-------------------------------------------------------------------------------
> ; <TEST=SS3>
> ;128
> select p.company, r.division, count(o.amount), sum(o.amount) \
 (cont) >        from orders o, prospects p, products r \
 (cont) >        where p.acct = o.acct and o.product_no = r.product_no \
 (cont) >        group by r.division, p.company \
 (cont) >        having count(o.amount) > 10 and sum(o.amount) > 500.00
----------------------------------- SUMMARY -----------------------------------
Select        P.COMPANY, \
              R.DIVISION, \
              count(O.AMOUNT), \
              sum(O.AMOUNT) \
  from        ORDERS O, \
              PROSPECTS P, \
              PRODUCTS R \
  where       P.ACCT = O.ACCT and \
              O.PRODUCT_NO = R.PRODUCT_NO \
  group by    R.DIVISION, \
              P.COMPANY \
  having      count(O.AMOUNT) > 10 and \
              sum(O.AMOUNT) > 500.00

Version:      <version>
Optimization: AGGREGATION, ASKLINK, STARSCHEMA
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Aggregate ORDERS using APOSTDQSAT for GROUP(PRODUCT_NO), GROUP(ACCT), \
   COUNT(AMOUNT), SUM(AMOUNT) on 1 with ALT SORT
 Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve PROSPECTS P using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 3 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 3
  Retrieve PRODUCTS R using $ROWID = $ODXID
   Pass to queue {1} [P.COMPANY, R.DIVISION, COUNT(O.AMOUNT), SUM(O.AMOUNT)]
Sort {1} for GROUP BY [R.DIVISION ASC, P.COMPANY ASC]
Retrieve {1} sequentially
Filter SUM(COUNT(O.AMOUNT)) > 10
Filter SUM(SUM(O.AMOUNT)) > 500.00
Filter FILTER 0 AND FILTER 1
Return P.COMPANY, R.DIVISION, COUNT(O.AMOUNT), SUM(O.AMOUNT)
-------------------------------------------------------------------------------
> ; <TEST=SS4>
> ;129
> select avg(amount), avg(total), count(*) \
 (cont) >        from orders o, dates d, products r, prospects p \
 (cont) >        where o.order_date = d.dt and o.product_no = r.product_no and \
 (cont) >              p.acct = o.acct and \
 (cont) >        p.discount_rt != 0 and (r.description like '%Computer%' or quantity > 50) \
 (cont) >        group by d.yr, r.category \
 (cont) >        having count(*) > 2.0  \
 (cont) >        order by 3 desc, 1 asc
----------------------------------- SUMMARY -----------------------------------
Select        avg(AMOUNT), \
              avg(TOTAL), \
              count(*) \
  from        ORDERS O, \
              DATES D, \
              PRODUCTS R, \
              PROSPECTS P \
  where       O.ORDER_DATE = D.DT and \
              O.PRODUCT_NO = R.PRODUCT_NO and \
              P.ACCT = O.ACCT and \
              P.DISCOUNT_RT <> 0 and \
              (R.DESCRIPTION like '%Computer%' or \
               QUANTITY > 50) \
  group by    D.YR, \
              R.CATEGORY \
  having      count(*) > 2.0 \
  order by    3 desc, \
              1

Version:      <version>
Optimization: MDKQUAL, AGGREGATION, ASKLINK, STARSCHEMA
Warnings:     UNOPTIMIZED_SORT
Notes:        Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where DESCRIPTION = '*Computer*' on 1 with \
   NOAUTORESET
   (11 PRODUCTS, 11 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or QUANTITY > '50' on 1 with NOAUTORESET
   (58 ORDERS, 0 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PROSPECTS)PROSPECTS using ACCT on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PROSPECTS)PROSPECTS where and DISCOUNT_RT <> '0' on 1 with \
   NOAUTORESET,PRESERVERS
   (58 ORDERS, 2 PROSPECTS, 6 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (58 ORDERS, 200 Pre-intersect   <time>)
Aggregate ORDERS using OPASTDQSAT for GROUP(ORDER_DATE), GROUP(PRODUCT_NO), \
   COUNT(*), AVG(AMOUNT), AVG(TOTAL) on 1
 Qualify (DATES)DATES where DT = O.ORDER_DATE on 2 with ASK NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve DATES D using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 3 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 3
  Retrieve PRODUCTS R using $ROWID = $ODXID
   Pass to queue {1} [AVG(O.AMOUNT), AVG(O.TOTAL), COUNT('*'), D.YR, \
      R.CATEGORY, COUNT('*')]
Sort {1} for GROUP BY [D.YR ASC, R.CATEGORY ASC]
Retrieve {1} sequentially
Filter SUM(COUNT('*')) > 2.0
Pass to queue {2} [SUM(AVG(O.AMOUNT)) / SUM(COUNT('*')), SUM(AVG(O.TOTAL)) / \
   SUM(COUNT('*')), SUM(COUNT('*'))]
Sort {2} for ORDER BY [SUM(COUNT('*')) DESC, SUM(AVG(O.AMOUNT)) / \
   SUM(COUNT('*')) ASC]
Retrieve {2} sequentially
Return AVG(O.AMOUNT), AVG(O.TOTAL), COUNT('*')
-------------------------------------------------------------------------------
> ; <TEST=SS5>
> ;130
> select o.status, r.dept, avg(o.amount), avg(o.quantity * 1.0) \
 (cont) >        from prospects p, orders o, products r \
 (cont) >        where o.acct = p.acct and o.product_no = r.product_no and  \
 (cont) >        p.state = 'CO' and o.total > 1000.00 and o.source between 1 and 4 \
 (cont) >        and r.cost between 1000.00 and 50000.00 \
 (cont) >        group by o.status, r.dept
----------------------------------- SUMMARY -----------------------------------
Select        O.STATUS, \
              R.DEPT, \
              avg(O.AMOUNT), \
              avg(O.QUANTITY * 1.0) \
  from        PROSPECTS P, \
              ORDERS O, \
              PRODUCTS R \
  where       O.ACCT = P.ACCT and \
              O.PRODUCT_NO = R.PRODUCT_NO and \
              P.STATE = 'CO' and \
              O.TOTAL > 1000.00 and \
              O.SOURCE between 1 and 4 and \
              R.COST between 1000.00 and 50000.00 \
  group by    O.STATUS, \
              R.DEPT

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_CRITERIA, UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Filter on column COST will not be optimized because there is not
                an MDK index installed on the column.
              Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where STATE = 'CO' on 1 with NOAUTORESET
   (1 PROSPECTS, 1 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where and TOTAL > '1000.00' on 1 with NOAUTORESET
   (65 ORDERS, 76 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and SOURCE between '1' and '4' on 1 with \
   NOAUTORESET
   (21 ORDERS, 60 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (21 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PRODUCTS R using $ROWID = $ODXID
  Filter R.COST BETWEEN 1000.00 AND 50000.00
  Pass to queue {1} [O.STATUS, R.DEPT, O.AMOUNT, O.QUANTITY * 1.0]
Sort {1} for GROUP BY [O.STATUS ASC, R.DEPT ASC]
Retrieve {1} sequentially
Return O.STATUS, R.DEPT, AVG(O.AMOUNT), AVG(O.QUANTITY * 1.0)
-------------------------------------------------------------------------------
> ;
> ;
> ; <SECTION=SNOWFLAKE_SCENARIOS>
> ;
> ;no special optimization performed (besides where/imslink)
> ; <TEST=SF1>
> ;131
> select d.yr, ca.description, avg(amount), avg(total) \
 (cont) >        from orders o, dates d, products r, categories ca \
 (cont) >        where o.order_date = d.dt and o.product_no = r.product_no and  \
 (cont) >        ca.category = r.category and \
 (cont) >        discount != 0 and (r.description like '%Computer%' or quantity > 50) \
 (cont) >        group by d.yr, ca.description \
 (cont) >        having count(*) > 2.0  \
 (cont) >        order by 3 desc, 1 asc
----------------------------------- SUMMARY -----------------------------------
Select        D.YR, \
              CA.DESCRIPTION, \
              avg(AMOUNT), \
              avg(TOTAL) \
  from        ORDERS O, \
              DATES D, \
              PRODUCTS R, \
              CATEGORIES CA \
  where       O.ORDER_DATE = D.DT and \
              O.PRODUCT_NO = R.PRODUCT_NO and \
              CA.CATEGORY = R.CATEGORY and \
              DISCOUNT <> 0 and \
              (R.DESCRIPTION like '%Computer%' or \
               QUANTITY > 50) \
  group by    D.YR, \
              CA.DESCRIPTION \
  having      count(*) > 2.0 \
  order by    3 desc, \
              1

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     XREF_FILES, UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Cross-references are necessary because all predicates cannot be
                reduced to a single Omnidex ID list.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where DESCRIPTION = '*Computer*' on 1 with \
   NOAUTORESET
   (11 PRODUCTS, 11 Pre-intersect   <time>)
Build xref {1} from CURRENT ODXID LIST on 1
   (11 rows loaded   <time>)
Qualify (ORDERS)ORDERS where QUANTITY > '50' on 1 with NOAUTORESET
   (0 ORDERS, 0 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where DISCOUNT <> '0' on 1 with NOAUTORESET
   (199 ORDERS, 199 Pre-intersect   <time>)
Build xref {2} from CURRENT ODXID LIST on 1
   (199 rows loaded   <time>)
Read R.$ROWID from {1} sequentially
 Retrieve PRODUCTS R using $ROWID = R.$ROWID
  Qualify (ORDERS)ORDERS where PT = R.PRODUCT_NO on 2 with ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve ORDERS O using $ROWID = $ODXID
  Filter O.$ROWID IN {2}
   Qualify (CATEGORIES)CATEGORIES where CAT = R.CATEGORY on 3 with ASK \
      NOAUTORESET
   Fetchkeys $ROWID 1000 at a time on 3
   Retrieve CATEGORIES CA using $ROWID = $ODXID
    Qualify (DATES)DATES where DT = O.ORDER_DATE on 4 with ASK NOAUTORESET
    Fetchkeys $ROWID 1000 at a time on 4
    Retrieve DATES D using $ROWID = $ODXID
    Pass to queue {3} [D.YR, CA.DESCRIPTION, O.AMOUNT, O.TOTAL]
Sort {3} for GROUP BY [D.YR ASC, CA.DESCRIPTION ASC]
Retrieve {3} sequentially
Filter COUNT('*') > 2.0
Pass to queue {4} [D.YR, CA.DESCRIPTION, AVG(O.AMOUNT), AVG(O.TOTAL)]
Sort {4} for ORDER BY [AVG(O.AMOUNT) DESC, D.YR ASC]
Retrieve {4} sequentially
Return D.YR, CA.DESCRIPTION, AVG(O.AMOUNT), AVG(O.TOTAL)
-------------------------------------------------------------------------------
> ; <TEST=SF2>
> ;132
> select sum(o.total), min(o.order_date) \
 (cont) >   from orders o, products p, divisions d, depts e \
 (cont) >   where (p.division = d.division and p.dept = e.dept and o.product_no = p.product_no) and \
 (cont) >         (d.description = 'Furniture' or e.description in ('Desks', 'Chairs'))
----------------------------------- SUMMARY -----------------------------------
Select        sum(O.TOTAL), \
              min(O.ORDER_DATE) \
  from        ORDERS O, \
              PRODUCTS P, \
              DIVISIONS D, \
              DEPTS E \
  where       P.DIVISION = D.DIVISION and \
              P.DEPT = E.DEPT and \
              O.PRODUCT_NO = P.PRODUCT_NO and \
              (D.DESCRIPTION = 'Furniture' or \
               E.DESCRIPTION in ('Desks', 'Chairs'))

Version:      <version>
Optimization: MDKQUAL, ASKLINK, MDKLINK
Warnings:     XREF_FILES, UNOPTIMIZED_AGGREGATION
Notes:        Cross-references are necessary because all predicates cannot be
                reduced to a single Omnidex ID list.
----------------------------------- DETAILS -----------------------------------
Qualify (DIVISIONS)DIVISIONS where DESCRIPTION = 'Furniture' on 1 with \
   NOAUTORESET
   (1 DIVISIONS, 1 Pre-intersect   <time>)
Build xref {1} from CURRENT ODXID LIST on 1
   (1 row loaded   <time>)
Qualify (DEPTS)DEPTS where DESCRIPTION in ('Desks','Chairs') on 1 with \
   NOAUTORESET
   (2 DEPTS, 2 Pre-intersect   <time>)
Build xref {2} from CURRENT ODXID LIST on 1
   (2 rows loaded   <time>)
Read D.$ROWID from {1} sequentially
 Retrieve DIVISIONS D using $ROWID = D.$ROWID
  Qualify (PRODUCTS)PRODUCTS where DDMC = D.DIVISION on 2 with ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PRODUCTS P using $ROWID = $ODXID
   Qualify (ORDERS)ORDERS where PT = P.PRODUCT_NO on 3 with ASK NOAUTORESET
   Fetchkeys $ROWID 1000 at a time on 3
   Retrieve ORDERS O using $ROWID = $ODXID
    Qualify (DEPTS)DEPTS where DPT = P.DEPT on 4 with ASK NOAUTORESET
    Fetchkeys $ROWID 1000 at a time on 4
    Retrieve DEPTS E using $ROWID = $ODXID
Read E.$ROWID from {2} sequentially
 Retrieve DEPTS E using $ROWID = E.$ROWID
  Qualify (PRODUCTS)PRODUCTS where DEPT = E.DEPT on 5 with NOAUTORESET
  Fetchkeys PRODUCT_NO 1000 at a time on 5
  Retrieve PRODUCTS P using $ROWID = $ODXID
   Qualify (ORDERS)ORDERS where PT = P.PRODUCT_NO on 6 with ASK NOAUTORESET
   Fetchkeys $ROWID 1000 at a time on 6
   Retrieve ORDERS O using $ROWID = $ODXID
    Qualify (DIVISIONS)DIVISIONS where DIVISION = P.DIVISION on 7 with ASK \
       NOAUTORESET
    Fetchkeys $ROWID 1000 at a time on 7
    Retrieve DIVISIONS D using $ROWID = $ODXID
    Filter NOT D.$ROWID IN {1}
Return SUM(O.TOTAL), MIN(O.ORDER_DATE)
-------------------------------------------------------------------------------
> ; <TEST=SF3>
> ;133
> select s.description, di.description, max(o.discount), \
 (cont) >         count(distinct o.discount) numdiscounts \
 (cont) >   from orders o, products r, dates d, statuses s, divisions di \
 (cont) >   where (o.product_no = r.product_no and o.order_date = d.dt \
 (cont) >         and o.status = s.status and r.division = di.division) and \
 (cont) >         (s.description = 'Cancelled' or d.yr < 1991 \
 (cont) >         or o.discount = 0 or r.margin <= 30) \
 (cont) >         group by s.description, di.description \
 (cont) >         having numdiscounts > 1 order by 2, 1 desc
----------------------------------- SUMMARY -----------------------------------
Select        S.DESCRIPTION, \
              DI.DESCRIPTION, \
              max(O.DISCOUNT), \
              count(distinct O.DISCOUNT) NUMDISCOUNTS \
  from        ORDERS O, \
              PRODUCTS R, \
              DATES D, \
              STATUSES S, \
              DIVISIONS DI \
  where       O.PRODUCT_NO = R.PRODUCT_NO and \
              O.ORDER_DATE = D.DT and \
              O.STATUS = S.STATUS and \
              R.DIVISION = DI.DIVISION and \
              (S.DESCRIPTION = 'Cancelled' or \
               D.YR < 1991 or \
               O.DISCOUNT = 0 or \
               R.MARGIN <= 30) \
  group by    S.DESCRIPTION, \
              DI.DESCRIPTION \
  having      NUMDISCOUNTS > 1 \
  order by    2, \
              1 desc

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (DATES)DATES where $ODXID = 'all_rows' on 1 with NOAUTORESET
   (4,383 DATES, 4,383 Pre-intersect   <time>)
Export to queue M1 on 1 with ODXSI,SORT
   (4,383 rows exported   <time>)
Qualify (DATES)DATES where YR < '1991' on 1 with NOAUTORESET
   (365 DATES, 365 Pre-intersect   <time>)
Export to queue M2 on 1 with ODXSI,SORT
   (365 rows exported   <time>)
Qualify (STATUSES)STATUSES where DESCRIPTION = 'Cancelled' on 1 with \
   NOAUTORESET
   (1 STATUSES, 1 Pre-intersect   <time>)
Join STATUSES using STATUS to (ORDERS)ORDERS using STATUS on 1 with NOAUTORESET
   (8 ORDERS, 8 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PRODUCTS)PRODUCTS where or MARGIN <= '30' on 1 with NOAUTORESET, \
   PRESERVERS
   (37 ORDERS, 28 PRODUCTS, 48 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or DISCOUNT = '0' on 1 with NOAUTORESET
   (37 ORDERS, 1 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or $ODXID = 'queue(M2, 3)' on 1 with NOAUTORESET
   (69 ORDERS, 39 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and $ODXID = 'queue(M1, 3)' on 1 with NOAUTORESET
   (69 ORDERS, 199 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PRODUCTS R using $ROWID = $ODXID
   Qualify (STATUSES)STATUSES where STATUS = O.STATUS on 3 with ASK NOAUTORESET
   Fetchkeys $ROWID 1000 at a time on 3
   Retrieve STATUSES S using $ROWID = $ODXID
    Qualify (DIVISIONS)DIVISIONS where DIVISION = R.DIVISION on 4 with ASK \
       NOAUTORESET
    Fetchkeys $ROWID 1000 at a time on 4
    Retrieve DIVISIONS DI using $ROWID = $ODXID
    Pass to queue {1} [S.DESCRIPTION, DI.DESCRIPTION, O.DISCOUNT]
    Pass to queue {2} [S.DESCRIPTION, DI.DESCRIPTION, O.DISCOUNT]
Sort {1} for GROUP BY [S.DESCRIPTION ASC, DI.DESCRIPTION ASC]
Sort {2} for DISTINCT [S.DESCRIPTION ASC, DI.DESCRIPTION ASC, O.DISCOUNT ASC]
Merge queues {1}, {2}
Filter COUNT(O.DISCOUNT) > 1
Pass to queue {3} [S.DESCRIPTION, DI.DESCRIPTION, EXPR[0], COUNT(O.DISCOUNT)]
Sort {3} for ORDER BY [DI.DESCRIPTION ASC, S.DESCRIPTION DESC]
Retrieve {3} sequentially
Return S.DESCRIPTION, DI.DESCRIPTION, MAX(O.DISCOUNT), NUMDISCOUNTS
-------------------------------------------------------------------------------
> ; <TEST=SF4>
> ;134
> select d.description, $round(sum(o.amount * r.wholesale) * 100) \
 (cont) >   from orders o, products r, divisions d \
 (cont) >   where r.division = d.division and o.product_no = r.product_no \
 (cont) >   group by d.description
----------------------------------- SUMMARY -----------------------------------
Select        D.DESCRIPTION, \
              $round(sum(O.AMOUNT * R.WHOLESALE) * 100) \
  from        ORDERS O, \
              PRODUCTS R, \
              DIVISIONS D \
  where       R.DIVISION = D.DIVISION and \
              O.PRODUCT_NO = R.PRODUCT_NO \
  group by    D.DESCRIPTION

Version:      <version>
Optimization: ASKLINK, ASKRETRIEVAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where APOSTDQSAT = '*' on 1 with ASK, NOAUTORESET
Retrieve from index APOSTDQSAT on 1
 Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
    NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve PRODUCTS R using $ROWID = $ODXID
  Qualify (DIVISIONS)DIVISIONS where DIVISION = R.DIVISION on 3 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 3
  Retrieve DIVISIONS D using $ROWID = $ODXID
  Pass to queue {1} [D.DESCRIPTION, O.AMOUNT * R.WHOLESALE]
Sort {1} for GROUP BY [D.DESCRIPTION ASC]
Retrieve {1} sequentially
Return D.DESCRIPTION, $ROUND(SUM(O.AMOUNT * R.WHOLESALE) * 100)
-------------------------------------------------------------------------------
> ; <TEST=SF5>
> ;135
> select g.description, d.description, avg(o.total) \
 (cont) >   from orders o, products r, depts d, prospects p, genders g \
 (cont) >   where r.dept = d.dept and o.product_no = r.product_no and \
 (cont) >        p.acct = o.acct and p.gender = g.gender and \
 (cont) >        d.description in ('Computers', 'Printers', 'Fax Machines', 'Telephones') \
 (cont) >   group by g.description, d.description
----------------------------------- SUMMARY -----------------------------------
Select        G.DESCRIPTION, \
              D.DESCRIPTION, \
              avg(O.TOTAL) \
  from        ORDERS O, \
              PRODUCTS R, \
              DEPTS D, \
              PROSPECTS P, \
              GENDERS G \
  where       R.DEPT = D.DEPT and \
              O.PRODUCT_NO = R.PRODUCT_NO and \
              P.ACCT = O.ACCT and \
              P.GENDER = G.GENDER and \
              D.DESCRIPTION in ('Computers', 'Printers', 'Fax Machines', \
               'Telephones') \
  group by    G.DESCRIPTION, \
              D.DESCRIPTION

Version:      <version>
Optimization: MDKQUAL, ASKLINK, MDKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN,
              SEQUENTIAL_TABLE_JOIN
Notes:        Sequential Table Join on GENDERS with P.GENDER = G.GENDER
              If order and proximity of words are important, DEPTS.DESCRIPTION
                should not be installed as a parsed index.
----------------------------------- DETAILS -----------------------------------
Qualify (DEPTS)DEPTS where DESCRIPTION = 'in (Computers,Printers,(Fax \
   Machines),Telephones)' on 1 with NOAUTORESET
   (4 DEPTS, 4 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve DEPTS D using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where DEPT = D.DEPT on 2 with NOAUTORESET
  Fetchkeys PRODUCT_NO 1000 at a time on 2
  Retrieve PRODUCTS R using $ROWID = $ODXID
   Qualify (ORDERS)ORDERS where PT = R.PRODUCT_NO on 3 with ASK NOAUTORESET
   Fetchkeys $ROWID 1000 at a time on 3
   Retrieve ORDERS O using $ROWID = $ODXID
    Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 4 with ASK NOAUTORESET
    Fetchkeys $ROWID 1000 at a time on 4
    Retrieve PROSPECTS P using $ROWID = $ODXID
     Retrieve GENDERS G sequentially
     Filter P.GENDER = G.GENDER
     Pass to queue {1} [G.DESCRIPTION, D.DESCRIPTION, O.TOTAL]
Sort {1} for GROUP BY [G.DESCRIPTION ASC, D.DESCRIPTION ASC]
Retrieve {1} sequentially
Return G.DESCRIPTION, D.DESCRIPTION, AVG(O.TOTAL)
-------------------------------------------------------------------------------
> ;
> ;
> ; <SECTION=SELECT_INTO>
> ;
> ;TABLE TYPE1 - checking for select into, select from the table created.
> ;The drop is performed after the pseudocolumns test.
> ;
> ;select into a temp table
> ; <TEST=SI1>
> ;136
> select top 15 p.acct, o.acct as o_acct, sum(o.acct) as sum_acct, o.product_no, o.total, o.tax_state \
 (cont) >    into op_temp \
 (cont) >    from orders o join prospects p using (acct) \
 (cont) >    group by p.acct, o_acct, o.product_no, o.total, o.tax_state \
 (cont) >    order by o.product_no desc
----------------------------------- SUMMARY -----------------------------------
Select        top 15 P.ACCT, \
              O.ACCT O_ACCT, \
              sum(O.ACCT) SUM_ACCT, \
              O.PRODUCT_NO, \
              O.TOTAL, \
              O.TAX_STATE \
  into        OP_TEMP \
  from        ORDERS O \
  join        PROSPECTS P using (ACCT) \
  group by    P.ACCT, \
              O_ACCT, \
              O.PRODUCT_NO, \
              O.TOTAL, \
              O.TAX_STATE \
  order by    O.PRODUCT_NO desc

Version:      <version>
Optimization: AGGREGATION, ASKLINK, STARSCHEMA
Warnings:     UNOPTIMIZED_SORT
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Create table STAR.OP_TEMP physical <filename>
  (ACCT                             datatype INTEGER
   O_ACCT                           datatype INTEGER
   SUM_ACCT                         datatype DOUBLE
   PRODUCT_NO                       datatype CHARACTER(4)
   TOTAL                            datatype FLOAT
   TAX_STATE                        datatype CHARACTER(2))
Aggregate ORDERS using APOSTDQSAT for GROUP(ACCT), GROUP(PRODUCT_NO), \
   GROUP(TOTAL), GROUP(TAX_STATE), SUM(ACCT) on 1 with ALT SORT
 Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
 Fetchkeys $ROWID 1000 at a time on 2
 Retrieve PROSPECTS P using $ROWID = $ODXID
  Pass to queue {1} [P.ACCT, O.ACCT, SUM(O.ACCT), O.PRODUCT_NO, O.TOTAL, \
     O.TAX_STATE]
Sort {1} for GROUP BY [P.ACCT ASC, O.ACCT ASC, O.PRODUCT_NO ASC, O.TOTAL ASC, \
   O.TAX_STATE ASC]
Retrieve {1} sequentially
Pass to queue {2} [P.ACCT, O.ACCT, SUM(SUM(O.ACCT)), O.PRODUCT_NO, O.TOTAL, \
   O.TAX_STATE]
Sort {2} for ORDER BY [O.PRODUCT_NO DESC]
Retrieve {2} sequentially
Insert into OP_TEMP values (P.ACCT, O.ACCT, SUM(O.ACCT), O.PRODUCT_NO, \
   O.TOTAL, O.TAX_STATE)
-------------------------------------------------------------------------------
> ;
> ;select from it
> ; <TEST=SI2>
> ;137
> select o_acct, sum_acct \
 (cont) >    from op_temp \
 (cont) >    where tax_state not in ('CA') \
 (cont) >    order by 2
*E* An invalid table was specified
(11019 0 0 OP_TEMP)
> ;
> ;TABLE TYPE2 - checking for select into, select from.
> ;The drop is performed after the pseudocolumns test, so that the table will be released.
> ;
> ;select into a $tempdb table
> ; <TEST=SI3>
> ;138
> select distinct p.*, o.* \
 (cont) >    into $tempdb.op_temp2 physical "op_temp2.dat" \
 (cont) >    from orders o join prospects p on o.acct = p.acct \
 (cont) >    where o.total > 10.00 or o.amount < 500.00
----------------------------------- SUMMARY -----------------------------------
Select        distinct P.*, \
              O.* \
  into        $TEMPDB.OP_TEMP2 \
  physical    "op_temp2.dat" \
  from        ORDERS O \
  join        PROSPECTS P on O.ACCT = P.ACCT \
  where       O.TOTAL > 10.00 or \
              O.AMOUNT < 500.00

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_SORT
Notes:        Optimized aggregations are not possible because no ASK index
                contains all columns and all links to dimension tables
              Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where TOTAL > '10.00' on 1 with NOAUTORESET
   (180 ORDERS, 180 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or AMOUNT < '500.00' on 1 with NOAUTORESET
   (200 ORDERS, 132 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PROSPECTS)PROSPECTS using ACCT on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (200 ORDERS, 200 Pre-intersect   <time>)
Create table $TEMPDB.OP_TEMP2 physical <filename>
  (ACCT1                            datatype INTEGER
   COMPANY_ID                       datatype INTEGER
   COMPANY                          datatype C STRING(59)
   CONTACT                          datatype C STRING(23)
   CITY                             datatype C STRING(25)
   STATE                            datatype CHARACTER(2)
   ZIP                              datatype C STRING(9)
   REGION                           datatype CHARACTER(2)
   COUNTRY                          datatype CHARACTER(2)
   PHONE                            datatype C STRING(15)
   GENDER                           datatype CHARACTER(1)
   MAILFLAG                         datatype CHARACTER(1)
   MAILING                          datatype CHARACTER(1)
   PROFESSION                       datatype TINYINT
   INCOME                           datatype TINYINT
   PROFILE                          datatype CHARACTER(1)
   PREFERRED                        datatype CHARACTER(1)
   FRQ_BUY_MBR                      datatype CHARACTER(1)
   CR_LIMIT                         datatype TINYINT
   DISCOUNT_RT                      datatype TINYINT
   CUST_SINCE                       datatype OMNIDEX DATE(4)
   LAST_ORDER                       datatype OMNIDEX DATE
   SEARCH_KEY                       datatype CHARACTER(12)
   COMPANY_SDX                      datatype C STRING(24)
   ACCT2                            datatype INTEGER
   PRODUCT_NO                       datatype CHARACTER(4)
   ORDER_DATE                       datatype OMNIDEX DATE
   STATUS                           datatype CHARACTER(2)
   TAX_STATE                        datatype CHARACTER(2)
   SOURCE                           datatype TINYINT
   PMT_METHOD                       datatype TINYINT
   DISCOUNT                         datatype TINYINT
   QUANTITY                         datatype TINYINT
   SALES_TAX                        datatype FLOAT
   AMOUNT                           datatype FLOAT
   TOTAL                            datatype FLOAT)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PROSPECTS P using $ROWID = $ODXID
  Pass to queue {1} [P.ACCT, P.COMPANY_ID, P.COMPANY, P.CONTACT, P.CITY, \
     P.STATE, P.ZIP, P.REGION, P.COUNTRY, P.PHONE, P.GENDER, P.MAILFLAG, \
     P.MAILING, P.PROFESSION, P.INCOME, P.PROFILE, P.PREFERRED, \
     P.FRQ_BUY_MBR, P.CR_LIMIT, P.DISCOUNT_RT, P.CUST_SINCE, P.LAST_ORDER, \
     P.SEARCH_KEY, P.COMPANY_SDX, O.ACCT, O.PRODUCT_NO, O.ORDER_DATE, \
     O.STATUS, O.TAX_STATE, O.SOURCE, O.PMT_METHOD, O.DISCOUNT, O.QUANTITY, \
     O.SALES_TAX, O.AMOUNT, O.TOTAL]
Sort {1} for DISTINCT [P.ACCT ASC, P.COMPANY_ID ASC, P.COMPANY ASC, P.CONTACT \
   ASC, P.CITY ASC, P.STATE ASC, P.ZIP ASC, P.REGION ASC, P.COUNTRY ASC, \
   P.PHONE ASC, P.GENDER ASC, P.MAILFLAG ASC, P.MAILING ASC, P.PROFESSION \
   ASC, P.INCOME ASC, P.PROFILE ASC, P.PREFERRED ASC, P.FRQ_BUY_MBR ASC, \
   P.CR_LIMIT ASC, P.DISCOUNT_RT ASC, P.CUST_SINCE ASC, P.LAST_ORDER ASC, \
   P.SEARCH_KEY ASC, P.COMPANY_SDX ASC, O.ACCT ASC, O.PRODUCT_NO ASC, \
   O.ORDER_DATE ASC, O.STATUS ASC, O.TAX_STATE ASC, O.SOURCE ASC, \
   O.PMT_METHOD ASC, O.DISCOUNT ASC, O.QUANTITY ASC, O.SALES_TAX ASC, \
   O.AMOUNT ASC, O.TOTAL ASC]
Retrieve {1} sequentially
Insert into OP_TEMP2 values (P.ACCT, P.COMPANY_ID, P.COMPANY, P.CONTACT, \
   P.CITY, P.STATE, P.ZIP, P.REGION, P.COUNTRY, P.PHONE, P.GENDER, \
   P.MAILFLAG, P.MAILING, P.PROFESSION, P.INCOME, P.PROFILE, P.PREFERRED, \
   P.FRQ_BUY_MBR, P.CR_LIMIT, P.DISCOUNT_RT, P.CUST_SINCE, P.LAST_ORDER, \
   P.SEARCH_KEY, P.COMPANY_SDX, O.ACCT, O.PRODUCT_NO, O.ORDER_DATE, O.STATUS, \
   O.TAX_STATE, O.SOURCE, O.PMT_METHOD, O.DISCOUNT, O.QUANTITY, O.SALES_TAX, \
   O.AMOUNT, O.TOTAL)
-------------------------------------------------------------------------------
> ;
> ;select from it
> ; <TEST=SI4>
> ;139
> select distinct op.acct1 from $tempdb.op_temp2 op \
 (cont) >    join products p on op.product_no = p.product_no \
 (cont) >    where p.product_no > 'D'
*E* An invalid table was specified
(11019 0 0 $TEMPDB.OP_TEMP2)
> ;
> ; <SECTION=DROP_TABLES>
> ;
> ;Drop tables from the select into's above
> ; <TEST=DT1>
> ;140
> drop table $tempdb.op_temp2
*E* An invalid table was specified
(11019 0 0 $TEMPDB.OP_TEMP2)
> ; <TEST=DT2>
> ;141
> drop table op_temp
*E* An invalid table was specified
(11019 0 0 OP_TEMP)
> ;
> ; <SECTION=PSEUDOCOLUMNS>
> ; <TEST=PC1>
> ;142
> select count(*), avg(distinct p.discount_rt) \
 (cont) >   from products p join orders o using (product_no) \
 (cont) >   where p.discount_rt > 70 or o.acct > 2 \
 (cont) >   group by p.discount_rt \
 (cont) >   order by 2
----------------------------------- SUMMARY -----------------------------------
Select        count(*), \
              avg(distinct P.DISCOUNT_RT) \
  from        PRODUCTS P \
  join        ORDERS O using (PRODUCT_NO) \
  where       P.DISCOUNT_RT > 70 or \
              O.ACCT > 2 \
  group by    P.DISCOUNT_RT \
  order by    2

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Additional qualifies/joins were inserted to verify sql join
                criteria.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where DISCOUNT_RT > '70' on 1 with NOAUTORESET
   (79 PRODUCTS, 79 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where or ACCT > '2' on 1 with NOAUTORESET
   (186 ORDERS, 1 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (186 ORDERS, 200 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS O using $ROWID = $ODXID
  Qualify (PRODUCTS)PRODUCTS where PRODUCT_NO = O.PRODUCT_NO on 2 with ASK \
     NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PRODUCTS P using $ROWID = $ODXID
  Pass to queue {1} [P.DISCOUNT_RT]
  Pass to queue {2} [P.DISCOUNT_RT, P.DISCOUNT_RT]
Sort {1} for GROUP BY [P.DISCOUNT_RT ASC]
Sort {2} for DISTINCT [P.DISCOUNT_RT ASC, P.DISCOUNT_RT ASC]
Merge queues {1}, {2}
Pass to queue {3} [EXPR[0], AVG(P.DISCOUNT_RT)]
Sort {3} for ORDER BY [AVG(P.DISCOUNT_RT) ASC]
Retrieve {3} sequentially
Return COUNT('*'), AVG(DISTINCT P.DISCOUNT_RT)
-------------------------------------------------------------------------------
> ;
> ; <SECTION=FUNCTIONS>
> ; <TEST=F1>
> ;144
> select company, $soundex(company) sndx, $mod(income, acct) \
 (cont) >    from prospects \
 (cont) >    where $soundex(contact) not in ($soundex('John Moore'), $soundex('Mary Kate Rosak')) \
 (cont) >    order by sndx
----------------------------------- SUMMARY -----------------------------------
Select        COMPANY, \
              $soundex(COMPANY) SNDX, \
              $mod(INCOME, ACCT) \
  from        PROSPECTS \
  where       $soundex(CONTACT) not in ($soundex('John Moore'), \
               $soundex('Mary Kate Rosak')) \
  order by    SNDX

Version:      <version>
Optimization: NONE
Warnings:     UNOPTIMIZED_CRITERIA, UNOPTIMIZED_SORT, SEQUENTIAL_SCAN
Notes:        Filter on column CONTACT will not be optimized because there is
                not a soundex index installed on the column.
----------------------------------- DETAILS -----------------------------------
Retrieve PROSPECTS sequentially
Filter NOT $SOUNDEX(PROSPECTS.CONTACT) IN ($SOUNDEX('John Moore'), \
   $SOUNDEX('Mary Kate Rosak'))
Pass to queue {1} [PROSPECTS.COMPANY, $SOUNDEX(PROSPECTS.COMPANY), \
   $MOD(PROSPECTS.INCOME,PROSPECTS.ACCT)]
Sort {1} for ORDER BY [$SOUNDEX(PROSPECTS.COMPANY) ASC]
Retrieve {1} sequentially
Return PROSPECTS.COMPANY, SNDX, $MOD(PROSPECTS.INCOME,PROSPECTS.ACCT)
-------------------------------------------------------------------------------
> ;
> ; <TEST=F2>
> ;145
> select *, $current_row from mfrs \
 (cont) >   where $soundex(description) = $soundex('Smeed') or \
 (cont) >         $soundex(description) = $soundex('Xerox') \
 (cont) >   order by mfr
----------------------------------- SUMMARY -----------------------------------
Select        *, \
              $current_row \
  from        MFRS \
  where       $soundex(DESCRIPTION) = $soundex('Smeed') or \
              $soundex(DESCRIPTION) = $soundex('Xerox') \
  order by    MFR

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (MFRS)MFRS where DESCRIPTION = 'phonetic(Smeed) or phonetic(Xerox)' \
   on 1 with NOAUTORESET
   (2 MFRS, 2 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve MFRS using $ROWID = $ODXID
 Pass to queue {1} [MFRS.MFR, MFRS.DESCRIPTION]
Sort {1} for ORDER BY [MFRS.MFR ASC]
Retrieve {1} sequentially
Return MFRS.MFR, MFRS.DESCRIPTION, $CURRENT_ROW
-------------------------------------------------------------------------------
> ;
> ;
> ; <SECTION=PROBLEM_QUERIES>
> ;   The next 3 are problems that pop up from time to time:
> ; <TEST=PRBQ1>
> ;146
> select acct, order_date, quantity, total from orders \
 (cont) >   where ((order_date between '01-01-1996' and '12-31-1996' and quantity > 10) or \
 (cont) >   (order_date between '01-01-1995'and '12-31-1995' \
 (cont) >   and (quantity > 200 or total > 1000000))) and tax_state = 'CO'
----------------------------------- SUMMARY -----------------------------------
Select        ACCT, \
              ORDER_DATE, \
              QUANTITY, \
              TOTAL \
  from        ORDERS \
  where       ((ORDER_DATE between '01-01-1996' and '12-31-1996' and \
                QUANTITY > 10) or \
               (ORDER_DATE between '01-01-1995' and '12-31-1995' and \
                (QUANTITY > 200 or \
                 TOTAL > 1000000))) and \
              TAX_STATE = 'CO'

Version:      <version>
Optimization: MDKQUAL, ASKRETRIEVAL
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where ORDER_DATE between '01-01-1996' and '12-31-1996' \
   on 1 with NOAUTORESET
   (7 ORDERS, 7 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and QUANTITY > '10' on 1 with NOAUTORESET
   (1 ORDERS, 32 Pre-intersect   <time>)
Export to queue O1 on 1 with ODXID
   (1 row exported   <time>)
Qualify (ORDERS)ORDERS where QUANTITY > '200' on 1 with NOAUTORESET
   (0 ORDERS, 0 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where TOTAL > '1000000' on 1 with NOAUTORESET
   (0 ORDERS, 0 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where $ODXID = 'queue(O1)' on 1 with NOAUTORESET
   (1 ORDERS, 1 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and TAX_STATE = 'CO' on 1 with NOAUTORESET
   (1 ORDERS, 163 Pre-intersect   <time>)
Retrieve from index APOSTDQSAT on 1
Return ORDERS.ACCT, ORDERS.ORDER_DATE, ORDERS.QUANTITY, ORDERS.TOTAL
-------------------------------------------------------------------------------
> ; <TEST=PRBQ2>
> ;147
> select count(*) from activity a, prospects p \
 (cont) >   where a.acct = p.acct and (p.company like '%Systems%')
----------------------------------- SUMMARY -----------------------------------
Select        count(*) \
  from        ACTIVITY A, \
              PROSPECTS P \
  where       A.ACCT = P.ACCT and \
              P.COMPANY like '%Systems%'

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PROSPECTS)PROSPECTS where COMPANY = '*Systems*' on 1 with NOAUTORESET
   (4 PROSPECTS, 4 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ACTIVITY)ACTIVITY using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (41 ACTIVITY, 100 Pre-intersect   <time>)
Return COUNT('*')
-------------------------------------------------------------------------------
> ; <TEST=PRBQ3>
> ;148
> select count(a.dt) from orders o, activity a \
 (cont) >   where o.acct = a.acct and \
 (cont) >   (a.dt between '07-31-1997' and '12-31-1997' \
 (cont) >    or o.order_date between '07-31-1997' and '12-31-1997')
----------------------------------- SUMMARY -----------------------------------
Select        count(A.DT) \
  from        ORDERS O, \
              ACTIVITY A \
  where       O.ACCT = A.ACCT and \
              (A.DT between '07-31-1997' and '12-31-1997' or \
               O.ORDER_DATE between '07-31-1997' and '12-31-1997')

Version:      <version>
Optimization: MDKQUAL, ASKLINK
Warnings:     XREF_FILES, UNOPTIMIZED_AGGREGATION
Notes:        Cross-references are necessary because multiple children from a
                domain are used with a need to keep each table's qualified
                rows.
----------------------------------- DETAILS -----------------------------------
Qualify (ACTIVITY)ACTIVITY where DT between '07-31-1997' and '12-31-1997' on \
   1 with NOAUTORESET
   (7 ACTIVITY, 7 Pre-intersect   <time>)
Build xref {1} from CURRENT ODXID LIST on 1
   (7 rows loaded   <time>)
Qualify (ORDERS)ORDERS where ORDER_DATE between '07-31-1997' and '12-31-1997' \
   on 1 with NOAUTORESET
   (0 ORDERS, 0 Pre-intersect   <time>)
Read A.$ROWID from {1} sequentially
 Retrieve ACTIVITY A using $ROWID = A.$ROWID
  Qualify (ORDERS)ORDERS where AT = A.ACCT on 2 with ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve ORDERS O using $ROWID = $ODXID
Return COUNT(A.DT)
-------------------------------------------------------------------------------
> ;
> ;   Double-check tidmap works (for oracle)
> ;
> ; <TEST=PRBQ4>
> ;149
> select yr, jan_total from orders_rollup where num_orders between 20 and 40
----------------------------------- SUMMARY -----------------------------------
Select        YR, \
              JAN_TOTAL \
  from        ORDERS_ROLLUP \
  where       NUM_ORDERS between 20 and 40

Version:      <version>
Optimization: MDKQUAL
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS_ROLLUP)ORDERS_ROLLUP where NUM_ORDERS between '20' and '40' \
   on 1 with NOAUTORESET
   (3 ORDERS_ROLLUP, 3 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS_ROLLUP using $ROWID = $ODXID
 Return ORDERS_ROLLUP.YR, ORDERS_ROLLUP.JAN_TOTAL
-------------------------------------------------------------------------------
> ; <TEST=PRBQ5>
> ;150
> select jan_total, retail, yr from orders_rollup where jan_total > 0
----------------------------------- SUMMARY -----------------------------------
Select        JAN_TOTAL, \
              RETAIL, \
              YR \
  from        ORDERS_ROLLUP \
  where       JAN_TOTAL > 0

Version:      <version>
Optimization: MDKQUAL
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS_ROLLUP)ORDERS_ROLLUP where JAN_TOTAL > '0' on 1 with \
   NOAUTORESET
   (6 ORDERS_ROLLUP, 6 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS_ROLLUP using $ROWID = $ODXID
 Return ORDERS_ROLLUP.JAN_TOTAL, ORDERS_ROLLUP.RETAIL, ORDERS_ROLLUP.YR
-------------------------------------------------------------------------------
> ;
> ;   Check date aggs for y2k
> ;
> ; <TEST=PRBQ6>
> ;151
> select count(distinct dt) from dates group by mo
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct DT) \
  from        DATES \
  group by    MO

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (DATES)DATES where MO = 'all_keywds' on 1 with KEYWD
   (12 keywords   <time>)
Fetchkeys MO 1000 at a time on 1
Return COUNT(DISTINCT DATES.DT)
-------------------------------------------------------------------------------
> ; <TEST=PRBQ7>
> ;152
> select min(dt), max(dt) from dates \
 (cont) >   where yr between 1993 and 2003
----------------------------------- SUMMARY -----------------------------------
Select        min(DT), \
              max(DT) \
  from        DATES \
  where       YR between 1993 and 2003

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION
Notes:        Index DTC on Table DATES has ASK installed as ;RK.
----------------------------------- DETAILS -----------------------------------
Qualify (DATES)DATES where YR between '1993' and '2003' on 1 with NOAUTORESET
   (3,287 DATES, 3,287 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve DATES using $ROWID = $ODXID
Return MIN(DATES.DT), MAX(DATES.DT)
-------------------------------------------------------------------------------
> ;
> ;   Check required_optimization, ask_retrieval_threshold
> ; <SECTION=REQ_OPT>
> ; <TEST=RO1>
> ;153
> select top 5 acct, quantity, total from orders order by 1,2,3 \
 (cont) >   with required = 'no_unoptimized_criteria \
 (cont) >    no_sequential_table_join no_xref_files \
 (cont) >    no_unoptimized_aggregation no_cartesian_products'
----------------------------------- SUMMARY -----------------------------------
Select        top 5 ACCT, \
              QUANTITY, \
              TOTAL \
  from        ORDERS \
  order by    1, \
              2, \
              3 \
  with        REQUIRED_OPTIMIZATION='no_unoptimized_criteria    no_sequential_\
table_join no_xref_files    no_unoptimized_aggregation no_cartesian_products'

Version:      <version>
Required Opt: NO_XREF_FILES, NO_UNOPTIMIZED_CRITERIA, NO_CARTESIAN_PRODUCTS,
              NO_UNOPTIMIZED_AGGREGATIONS, NO_SEQUENTIAL_TABLE_JOINS
Optimization: ASKRETRIEVAL
Warnings:     UNOPTIMIZED_SORT
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where APOSTDQSAT = '*' on 1 with ASK, NOAUTORESET
Retrieve from index APOSTDQSAT on 1
Pass to queue {1} [ORDERS.ACCT, ORDERS.QUANTITY, ORDERS.TOTAL]
Sort {1} for ORDER BY [ORDERS.ACCT ASC, ORDERS.QUANTITY ASC, ORDERS.TOTAL ASC]
Retrieve {1} sequentially
Return TOP 5 ORDERS.ACCT, ORDERS.QUANTITY, ORDERS.TOTAL
-------------------------------------------------------------------------------
> ;
> ; <TEST=RO2>
> ;154  /* should fail except on nonopt */
> select O.ACCT, A.ACCT \
 (cont) >   from  ORDERS O, ACTIVITY A, PROSPECTS P, INITIALS I \
 (cont) >   where O.ACCT = P.ACCT and A.ACCT = P.ACCT and A.INITIALS = I.INITIALS and \
 (cont) >         O.ACCT = 3 and A.ACCT = 3 \
 (cont) >   with required='no_xref_files'
----------------------------------- SUMMARY -----------------------------------
Select        O.ACCT, \
              A.ACCT \
  from        ORDERS O, \
              ACTIVITY A, \
              PROSPECTS P, \
              INITIALS I \
  where       O.ACCT = P.ACCT and \
              A.ACCT = P.ACCT and \
              A.INITIALS = I.INITIALS and \
              O.ACCT = 3 and \
              A.ACCT = 3 \
  with        REQUIRED_OPTIMIZATION=no_xref_files

Version:      <version>
Required Opt: NO_XREF_FILES
Optimization: MDKQUAL, ASKLINK, MDKLINK
Warnings:     XREF_FILES
Notes:        Cross-references are necessary because multiple children from a
                domain are used with a need to keep each table's qualified
                rows.
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where ACCT = '3' on 1 with NOAUTORESET
Build xref {1} from CURRENT ODXID LIST on 1
Qualify (ACTIVITY)ACTIVITY where ACCT = '3' on 1 with NOAUTORESET
Build xref {2} from CURRENT ODXID LIST on 1
Read O.$ROWID from {1} sequentially
 Retrieve ORDERS O using $ROWID = O.$ROWID
  Qualify (PROSPECTS)PROSPECTS where ACCT = O.ACCT on 2 with ASK NOAUTORESET
  Fetchkeys $ROWID 1000 at a time on 2
  Retrieve PROSPECTS P using $ROWID = $ODXID
   Qualify (ACTIVITY)ACTIVITY where ACCT = P.ACCT on 3 with NOAUTORESET
   Fetchkeys $ROWID 1000 at a time on 3
   Retrieve ACTIVITY A using $ROWID = $ODXID
   Filter A.$ROWID IN {2}
    Qualify (INITIALS)INITIALS where INITIALS = A.INITIALS on 4 with ASK \
       NOAUTORESET
    Fetchkeys $ROWID 1000 at a time on 4
    Retrieve INITIALS I using $ROWID = $ODXID
    Return O.ACCT, A.ACCT
-------------------------------------------------------------------------------
> ;
> ; <TEST=RO3>
> ;155
> select count(distinct total), count(distinct product_no), count(distinct quantity), \
 (cont) >   count(distinct order_date) from orders \
 (cont) >   where tax_state in ('CO', 'CA', 'AZ') and \
 (cont) >         (discount < 10 or (quantity > 15 and amount > 100)) \
 (cont) >   group by acct with ask_retrieval_threshold = 20
----------------------------------- SUMMARY -----------------------------------
Select        count(distinct TOTAL), \
              count(distinct PRODUCT_NO), \
              count(distinct QUANTITY), \
              count(distinct ORDER_DATE) \
  from        ORDERS \
  where       TAX_STATE in ('CO', 'CA', 'AZ') and \
              (DISCOUNT < 10 or \
               (QUANTITY > 15 and \
                AMOUNT > 100)) \
  group by    ACCT \
  with        ASK_RETRIEVAL_THRESHOLD=20

Version:      <version>
Optimization: MDKQUAL
Warnings:     UNOPTIMIZED_AGGREGATION, UNOPTIMIZED_SORT
Notes:        Omnidex qualified 5.00% of ORDERS which is less than the
                ASK_RETRIEVAL_THRESHOLD of 20.00%; Omnidex index APOSTDQSAT
                will not be used.
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where QUANTITY > '15' on 1 with NOAUTORESET
   (15 ORDERS, 15 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and AMOUNT > '100' on 1 with NOAUTORESET
   (13 ORDERS, 144 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where or DISCOUNT < '10' on 1 with NOAUTORESET
   (14 ORDERS, 1 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and TAX_STATE in ('CO','CA','AZ') on 1 with \
   NOAUTORESET
   (10 ORDERS, 163 Pre-intersect   <time>)
Fetchkeys $ROWID 1000 at a time on 1
 Retrieve ORDERS using $ROWID = $ODXID
 Pass to queue {1} [ORDERS.ACCT]
 Pass to queue {2} [ORDERS.ACCT, ORDERS.TOTAL]
 Pass to queue {3} [ORDERS.ACCT, ORDERS.PRODUCT_NO]
 Pass to queue {4} [ORDERS.ACCT, ORDERS.QUANTITY]
 Pass to queue {5} [ORDERS.ACCT, ORDERS.ORDER_DATE]
Sort {1} for GROUP BY [ORDERS.ACCT ASC]
Sort {2} for DISTINCT [ORDERS.ACCT ASC, ORDERS.TOTAL ASC]
Sort {3} for DISTINCT [ORDERS.ACCT ASC, ORDERS.PRODUCT_NO ASC]
Sort {4} for DISTINCT [ORDERS.ACCT ASC, ORDERS.QUANTITY ASC]
Sort {5} for DISTINCT [ORDERS.ACCT ASC, ORDERS.ORDER_DATE ASC]
Merge queues {1}, {2}, {3}, {4}, {5}
Return COUNT(DISTINCT ORDERS.TOTAL), COUNT(DISTINCT ORDERS.PRODUCT_NO), \
   COUNT(DISTINCT ORDERS.QUANTITY), COUNT(DISTINCT ORDERS.ORDER_DATE)
-------------------------------------------------------------------------------
> ;
> ;  'Kellogg' optimization:  all select items come from child; not all parents linked
> ; <SECTION=MULTIFIND>
> ;
> ;2 parents, neither linked
> ; <TEST=MF1>
> ;156
> select         sum(amount), sum(total), min(quantity) \
 (cont) >   from         pmt_methods pmt, \
 (cont) >                states sts, \
 (cont) >                orders ord \
 (cont) >   where        pmt.pmt_method = ord.pmt_method and \
 (cont) >                sts.state = ord.tax_state and \
 (cont) >                pmt.description in ('Cash', 'Check') and \
 (cont) >                sts.description = 'Texas'
----------------------------------- SUMMARY -----------------------------------
Select        sum(AMOUNT), \
              sum(TOTAL), \
              min(QUANTITY) \
  from        PMT_METHODS PMT, \
              STATES STS, \
              ORDERS ORD \
  where       PMT.PMT_METHOD = ORD.PMT_METHOD and \
              STS.STATE = ORD.TAX_STATE and \
              PMT.DESCRIPTION in ('Cash', 'Check') and \
              STS.DESCRIPTION = 'Texas'

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PMT_METHODS)PMT_METHODS where DESCRIPTION in ('Cash','Check') on 1 \
   with NOAUTORESET
   (2 PMT_METHODS, 2 Pre-intersect   <time>)
Export to queue M1 on 1 with ODXSI,SORT
   (2 rows exported   <time>)
Qualify (STATES)STATES where DESCRIPTION = 'Texas' on 1 with NOAUTORESET
   (1 STATES, 1 Pre-intersect   <time>)
Join STATES using STATE to (ORDERS)ORDERS using TAX_STATE on 1 with NOAUTORESET
   (36 ORDERS, 36 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and $ODXID = 'queue(M1, 7)' on 1 with NOAUTORESET
   (6 ORDERS, 35 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for MIN(QUANTITY), SUM(AMOUNT), SUM(TOTAL) \
   on 1
 Return SUM(ORD.AMOUNT), SUM(ORD.TOTAL), MIN(ORD.QUANTITY)
-------------------------------------------------------------------------------
> ;2 parents, one linked
> ; <TEST=MF2>
> ;157
> select         count(amount) \
 (cont) >   from         pmt_methods pmt, \
 (cont) >                products prd, \
 (cont) >                orders ord \
 (cont) >   where        pmt.pmt_method = ord.pmt_method and \
 (cont) >                ord.product_no = prd.product_no and \
 (cont) >                pmt.description in ('Cash', 'Check') and \
 (cont) >                prd.margin < 50.0 \
 (cont) >   group by     acct
----------------------------------- SUMMARY -----------------------------------
Select        count(AMOUNT) \
  from        PMT_METHODS PMT, \
              PRODUCTS PRD, \
              ORDERS ORD \
  where       PMT.PMT_METHOD = ORD.PMT_METHOD and \
              ORD.PRODUCT_NO = PRD.PRODUCT_NO and \
              PMT.DESCRIPTION in ('Cash', 'Check') and \
              PRD.MARGIN < 50.0 \
  group by    ACCT

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PMT_METHODS)PMT_METHODS where DESCRIPTION in ('Cash','Check') on 1 \
   with NOAUTORESET
   (2 PMT_METHODS, 2 Pre-intersect   <time>)
Join PMT_METHODS using PMT_METHOD to (ORDERS)ORDERS using PMT_METHOD on 1 \
   with NOAUTORESET
   (35 ORDERS, 35 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PRODUCTS)PRODUCTS where and MARGIN < '50.0' on 1 with NOAUTORESET, \
   PRESERVERS
   (33 ORDERS, 23 PRODUCTS, 79 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET,COUNT
   (33 ORDERS, 200 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for GROUP(ACCT), COUNT(AMOUNT) on 1
 Return COUNT(ORD.AMOUNT)
-------------------------------------------------------------------------------
> ;3 parents, 1 linked
> ; <TEST=MF3>
> ;158
> select         order_date, sum(amount), sum(total), min(quantity), count(*) \
 (cont) >   from         pmt_methods pmt, \
 (cont) >                states sts, \
 (cont) >                products prd, \
 (cont) >                orders ord \
 (cont) >   where        pmt.pmt_method = ord.pmt_method and \
 (cont) >                sts.state = ord.tax_state and \
 (cont) >                prd.product_no = ord.product_no and \
 (cont) >                pmt.description in ('Cash', 'Check') and \
 (cont) >                prd.category > 30 and \
 (cont) >                sts.description = 'Texas' \
 (cont) >   group by     ord.order_date
----------------------------------- SUMMARY -----------------------------------
Select        ORDER_DATE, \
              sum(AMOUNT), \
              sum(TOTAL), \
              min(QUANTITY), \
              count(*) \
  from        PMT_METHODS PMT, \
              STATES STS, \
              PRODUCTS PRD, \
              ORDERS ORD \
  where       PMT.PMT_METHOD = ORD.PMT_METHOD and \
              STS.STATE = ORD.TAX_STATE and \
              PRD.PRODUCT_NO = ORD.PRODUCT_NO and \
              PMT.DESCRIPTION in ('Cash', 'Check') and \
              PRD.CATEGORY > 30 and \
              STS.DESCRIPTION = 'Texas' \
  group by    ORD.ORDER_DATE

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PMT_METHODS)PMT_METHODS where DESCRIPTION in ('Cash','Check') on 1 \
   with NOAUTORESET
   (2 PMT_METHODS, 2 Pre-intersect   <time>)
Export to queue M1 on 1 with ODXSI,SORT
   (2 rows exported   <time>)
Qualify (STATES)STATES where DESCRIPTION = 'Texas' on 1 with NOAUTORESET
   (1 STATES, 1 Pre-intersect   <time>)
Join STATES using STATE to (ORDERS)ORDERS using TAX_STATE on 1 with NOAUTORESET
   (36 ORDERS, 36 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PRODUCTS)PRODUCTS where and CATEGORY > '30' on 1 with NOAUTORESET, \
   PRESERVERS
   (32 ORDERS, 20 PRODUCTS, 81 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where and $ODXID = 'queue(M1, 7)' on 1 with NOAUTORESET
   (5 ORDERS, 35 Pre-intersect   <time>)
Aggregate ORDERS using OPASTDQSAT for GROUP(ORDER_DATE), COUNT(*), \
   MIN(QUANTITY), SUM(AMOUNT), SUM(TOTAL) on 1
 Return ORD.ORDER_DATE, SUM(ORD.AMOUNT), SUM(ORD.TOTAL), MIN(ORD.QUANTITY), \
    COUNT('*')
-------------------------------------------------------------------------------
> ;4 parents, 2 linked, and qualify in child
> ; <TEST=MF4>
> ;159
> select         sum(amount), sum(total), min(quantity), count(*) \
 (cont) >   from         prospects prs, \
 (cont) >                pmt_methods pmt, \
 (cont) >                states sts, \
 (cont) >                products prd, \
 (cont) >                orders ord \
 (cont) >   where        prs.acct = ord.acct and \
 (cont) >                pmt.pmt_method = ord.pmt_method and \
 (cont) >                sts.state = ord.tax_state and \
 (cont) >                prd.product_no = ord.product_no and \
 (cont) >                prs.company like '%Systems%' and \
 (cont) >                pmt.description in ('Cash', 'Check') and \
 (cont) >                prd.category > 50 and \
 (cont) >                sts.description = 'Colorado' and \
 (cont) >                ord.quantity > 5
----------------------------------- SUMMARY -----------------------------------
Select        sum(AMOUNT), \
              sum(TOTAL), \
              min(QUANTITY), \
              count(*) \
  from        PROSPECTS PRS, \
              PMT_METHODS PMT, \
              STATES STS, \
              PRODUCTS PRD, \
              ORDERS ORD \
  where       PRS.ACCT = ORD.ACCT and \
              PMT.PMT_METHOD = ORD.PMT_METHOD and \
              STS.STATE = ORD.TAX_STATE and \
              PRD.PRODUCT_NO = ORD.PRODUCT_NO and \
              PRS.COMPANY like '%Systems%' and \
              PMT.DESCRIPTION in ('Cash', 'Check') and \
              PRD.CATEGORY > 50 and \
              STS.DESCRIPTION = 'Colorado' and \
              ORD.QUANTITY > 5

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PMT_METHODS)PMT_METHODS where DESCRIPTION in ('Cash','Check') on 1 \
   with NOAUTORESET
   (2 PMT_METHODS, 2 Pre-intersect   <time>)
Export to queue M1 on 1 with ODXSI,SORT
   (2 rows exported   <time>)
Qualify (STATES)STATES where DESCRIPTION = 'Colorado' on 1 with NOAUTORESET
   (1 STATES, 1 Pre-intersect   <time>)
Join STATES using STATE to (ORDERS)ORDERS using TAX_STATE on 1 with NOAUTORESET
   (163 ORDERS, 163 Pre-intersect   <time>)
Join ORDERS using $UNIQUEKEY to (PRODUCTS)PRODUCTS using PRODUCT_NO on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PRODUCTS)PRODUCTS where and CATEGORY > '50' on 1 with NOAUTORESET, \
   PRESERVERS
   (81 ORDERS, 33 PRODUCTS, 65 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Join ORDERS using $UNIQUEKEY to (PROSPECTS)PROSPECTS using ACCT on 1 with \
   NOAUTORESET,PRESERVERS
   (Deferred join - counts unavailable   <time>)
Qualify (PROSPECTS)PROSPECTS where and COMPANY = '*Systems*' on 1 with \
   NOAUTORESET,PRESERVERS
   (81 ORDERS, 1 PROSPECTS, 4 Pre-intersect   <time>)
Join PROSPECTS using ACCT to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where and QUANTITY > '5' on 1 with NOAUTORESET
   (18 ORDERS, 46 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and $ODXID = 'queue(M1, 7)' on 1 with NOAUTORESET
   (7 ORDERS, 35 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for COUNT(*), MIN(QUANTITY), SUM(AMOUNT), \
   SUM(TOTAL) on 1
 Return SUM(ORD.AMOUNT), SUM(ORD.TOTAL), MIN(ORD.QUANTITY), COUNT('*')
-------------------------------------------------------------------------------
> ;same as 156 but count(*) only
> ; <TEST=MF5>
> ;160
> select         count(*) \
 (cont) >   from         pmt_methods pmt, \
 (cont) >                states sts, \
 (cont) >                orders ord \
 (cont) >   where        pmt.pmt_method = ord.pmt_method and \
 (cont) >                sts.state = ord.tax_state and \
 (cont) >                pmt.description in ('Cash', 'Check') and \
 (cont) >                sts.description = 'Texas'
----------------------------------- SUMMARY -----------------------------------
Select        count(*) \
  from        PMT_METHODS PMT, \
              STATES STS, \
              ORDERS ORD \
  where       PMT.PMT_METHOD = ORD.PMT_METHOD and \
              STS.STATE = ORD.TAX_STATE and \
              PMT.DESCRIPTION in ('Cash', 'Check') and \
              STS.DESCRIPTION = 'Texas'

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (PMT_METHODS)PMT_METHODS where DESCRIPTION in ('Cash','Check') on 1 \
   with NOAUTORESET
   (2 PMT_METHODS, 2 Pre-intersect   <time>)
Export to queue M1 on 1 with ODXSI,SORT
   (2 rows exported   <time>)
Qualify (STATES)STATES where DESCRIPTION = 'Texas' on 1 with NOAUTORESET
   (1 STATES, 1 Pre-intersect   <time>)
Join STATES using STATE to (ORDERS)ORDERS using TAX_STATE on 1 with NOAUTORESET
   (36 ORDERS, 36 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and $ODXID = 'queue(M1, 7)' on 1 with NOAUTORESET
   (6 ORDERS, 35 Pre-intersect   <time>)
Return COUNT('*')
-------------------------------------------------------------------------------
> ;
> ; long in-clauses turned into multifind
> ; <TEST=MF6>
> ;161
> select sum(total) from orders o, products p where o.product_no = p.product_no  \
 (cont) > and (category in (11,12,13,14,16,18,20,21,22,23,24,25,26,30,31,40,41,42,43,50,51,52,53,60,61,62,80,81,90,91,92,93,94,95) \
 (cont) > or   description in ( 'Desk', 'Chair', 'File', 'Phone', 'Credenza', 'Computer', 'Copier', 'Printer', 'Deskjet', 'Laserjet', 'Cellular', 'Cordless', 'Fax', 'Paper', 'Pens', 'Pencils', 'Markers', 'Erasers' ) ) \
 (cont) > and (order_date in ('01-20-1994','02-20-1994','03-20-1994','04-20-1994','05-20-1994','06-20-1994','07-20-1994','08-20-1994','09-20-1994','10-20-1994','11-20-1994','12-20-1994','01-20-1995','02-08-1995','02-20-1995','03-20-1995','04-20-1995','05-20-1995','06-20-1995','07-20-1995','08-20-1995','09-20-1995','10-20-1995','11-20-1995','12-20-1995','02-20-1996','04-20-1996','05-20-1996','06-23-1996','08-20-1996','09-20-1996','09-20-1993','10-20-1993','11-20-1993','12-20-1993','10-20-1996','02-14-2001') \
 (cont) > and quantity in (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59) \
 (cont) > and  acct in (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) and (tax_state = 'CO' or tax_state = 'TX'))
----------------------------------- SUMMARY -----------------------------------
Select        sum(TOTAL) \
  from        ORDERS O, \
              PRODUCTS P \
  where       O.PRODUCT_NO = P.PRODUCT_NO and \
              (CATEGORY in (11, 12, 13, 14, 16, 18, 20, 21, 22, 23, 24, 25, \
                26, 30, 31, 40, 41, 42, 43, 50, 51, 52, 53, 60, 61, 62, 80, \
                81, 90, 91, 92, 93, 94, 95) or \
               DESCRIPTION in ('Desk', 'Chair', 'File', 'Phone', 'Credenza', \
                'Computer', 'Copier', 'Printer', 'Deskjet', 'Laserjet', \
                'Cellular', 'Cordless', 'Fax', 'Paper', 'Pens', 'Pencils', \
                'Markers', 'Erasers')) and \
              (ORDER_DATE in ('01-20-1994', '02-20-1994', '03-20-1994', \
                '04-20-1994', '05-20-1994', '06-20-1994', '07-20-1994', \
                '08-20-1994', '09-20-1994', '10-20-1994', '11-20-1994', \
                '12-20-1994', '01-20-1995', '02-08-1995', '02-20-1995', \
                '03-20-1995', '04-20-1995', '05-20-1995', '06-20-1995', \
                '07-20-1995', '08-20-1995', '09-20-1995', '10-20-1995', \
                '11-20-1995', '12-20-1995', '02-20-1996', '04-20-1996', \
                '05-20-1996', '06-23-1996', '08-20-1996', '09-20-1996', \
                '09-20-1993', '10-20-1993', '11-20-1993', '12-20-1993', \
                '10-20-1996', '02-14-2001') and \
               QUANTITY in (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, \
                15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, \
                30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, \
                45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59) and \
               ACCT in (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, \
               16) and \
               (TAX_STATE = 'CO' or \
                TAX_STATE = 'TX'))

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
Notes:        34 values from an in-clause on column CATEGORY have been written
                to queue M1.  The threshold for writing to a file is 8.
              18 values from an in-clause on column DESCRIPTION have been
                written to queue M2.  The threshold for writing to a file is 8.
              37 values from an in-clause on column ORDER_DATE have been
                written to queue M3.  The threshold for writing to a file is 8.
              59 values from an in-clause on column QUANTITY have been written
                to queue M4.  The threshold for writing to a file is 8.
              16 values from an in-clause on column ACCT have been written to
                queue M5.  The threshold for writing to a file is 8.
----------------------------------- DETAILS -----------------------------------
Qualify (PRODUCTS)PRODUCTS where CATEGORY = 'queue(M1)' on 1 with NOAUTORESET
   (73 PRODUCTS, 73 Pre-intersect   <time>)
Qualify (PRODUCTS)PRODUCTS where or DESCRIPTION = 'queue(M2)' on 1 with \
   NOAUTORESET
   (84 PRODUCTS, 65 Pre-intersect   <time>)
Join PRODUCTS using PRODUCT_NO to (ORDERS)ORDERS using $UNIQUEKEY on 1 with \
   NOAUTORESET
   (Deferred join - counts unavailable   <time>)
Qualify (ORDERS)ORDERS where and ORDER_DATE = 'queue(M3)' on 1 with NOAUTORESET
   (104 ORDERS, 114 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and QUANTITY = 'queue(M4)' on 1 with NOAUTORESET
   (104 ORDERS, 200 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and ACCT = 'queue(M5)' on 1 with NOAUTORESET
   (104 ORDERS, 200 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and TAX_STATE = 'CO or TX' on 1 with NOAUTORESET
   (103 ORDERS, 199 Pre-intersect   <time>)
Aggregate ORDERS using AT for SUM(TOTAL) on 1
 Return SUM(O.TOTAL)
-------------------------------------------------------------------------------
> ;
> ; <SECTION=PARTITIONED_QUALIFY>
> ; <TEST=PQ1>
> ;162
> ;Character, single column
> ; No group by
> select max(total) from orders where status in ('CN', 'OR', 'SH', 'BO')
----------------------------------- SUMMARY -----------------------------------
Select        max(TOTAL) \
  from        ORDERS \
  where       STATUS in ('CN', 'OR', 'SH', 'BO')

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where STATUS in ('CN','''OR''','SH','BO') on 1 with \
   NOAUTORESET
   (200 ORDERS, 200 Pre-intersect   <time>)
Aggregate ORDERS using AT for MAX(TOTAL) on 1
Return MAX(ORDERS.TOTAL)
-------------------------------------------------------------------------------
> ;
> ; <TEST=PQ2>
> ;163
> ; Group by
> select product_no, min(total) from orders where product_no in ('P900', 'XPCP', 'S100', 'A940', 'G523') group by product_no
----------------------------------- SUMMARY -----------------------------------
Select        PRODUCT_NO, \
              min(TOTAL) \
  from        ORDERS \
  where       PRODUCT_NO in ('P900', 'XPCP', 'S100', 'A940', 'G523') \
  group by    PRODUCT_NO

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where PRODUCT_NO in ('P900','XPCP','S100','A940', \
   'G523') on 1 with NOAUTORESET
   (27 ORDERS, 27 Pre-intersect   <time>)
Aggregate ORDERS using PT for GROUP(PRODUCT_NO), MIN(TOTAL) partitioned by \
   PRODUCT_NO on 1
Return ORDERS.PRODUCT_NO, MIN(ORDERS.TOTAL)
-------------------------------------------------------------------------------
> ;
> ; <TEST=PQ3>
> select status, product_no, sum(amount) from orders \
 (cont) > where status in ('SH','CN') and \
 (cont) > product_no = 'A940' group by status, product_no
----------------------------------- SUMMARY -----------------------------------
Select        STATUS, \
              PRODUCT_NO, \
              sum(AMOUNT) \
  from        ORDERS \
  where       STATUS in ('SH', 'CN') and \
              PRODUCT_NO = 'A940' \
  group by    STATUS, \
              PRODUCT_NO

Version:      <version>
Optimization: MDKQUAL, AGGREGATION
Notes:        The aggregation on APOSTDQSAT required an Alternate Sort.
----------------------------------- DETAILS -----------------------------------
Qualify (ORDERS)ORDERS where STATUS in ('SH','CN') on 1 with NOAUTORESET
   (200 ORDERS, 200 Pre-intersect   <time>)
Qualify (ORDERS)ORDERS where and PRODUCT_NO = 'A940' on 1 with NOAUTORESET
   (8 ORDERS, 8 Pre-intersect   <time>)
Aggregate ORDERS using APOSTDQSAT for GROUP(STATUS), GROUP(PRODUCT_NO), \
   SUM(AMOUNT) on 1 with ALT SORT
Return ORDERS.STATUS, ORDERS.PRODUCT_NO, SUM(ORDERS.AMOUNT)
-------------------------------------------------------------------------------
> ;
> ;<COMMON>
> disconnect
Disconnected from instance 1
> 
> 
