text: --
  --   Licensed to the Apache Software Foundation (ASF) under one or more
  --   contributor license agreements.  See the NOTICE file distributed with
  --   this work for additional information regarding copyright ownership.
  --   The ASF licenses this file to You under the Apache License, Version 2.0
  --   (the "License"); you may not use this file except in compliance with
  --   the License.  You may obtain a copy of the License at
  --
  --      http://www.apache.org/licenses/LICENSE-2.0
  --
  --   Unless required by applicable law or agreed to in writing, software
  --   distributed under the License is distributed on an "AS IS" BASIS,
  --   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  --   See the License for the specific language governing permissions and
  --   limitations under the License.
  --
  -- This test is an adaptation of the Wisconsin benchmark, as documented in
  -- The Benchmark Handbook, Second Edition (edited by Jim Gray).  The structure
  -- of the tables and the data in the tables are taken from there.
  --
  -- The original benchmark talks about clustered and non-clustered
  -- indexes - as far as I can tell, this really means indexes where the
  -- row ordering is or is not the same as in the base table.  It does
  -- not mean special types of indexes.  I am putting in queries that
  -- use both ordered and unordered indexes, despite the fact that
  -- our optimizer does not currently distinguish these cases.
  --
  -- Another difference is that the original Wisconsin benchmark is a performance
  -- test, while this test is only intended to ensure that the optimizer comes
  -- up with the right query plan.  Therefore, this test doesn't include those
  -- parts of the Wisconsin benchmark where the optimizer has no choice of
  -- access path (e.g. single-table query with no indexes), nor does it include
  -- the projection and update queries.
  --
  -- This test only does the first variation of each query, since that is
  -- all that is documented in The Benchmark Handbook (it wouldn't be a true
  -- academic reference text if everything were spelled out).
  --
  -- After the original Wisconsin queries are a bunch of queries that use the
  -- Wisconsin schema but that were written at Cloudscape specifically for
  -- testing our optimizer.
  
  autocommit off;
  
  set isolation serializable;
  
  call SYSCS_UTIL.SYSCS_SET_RUNTIMESTATISTICS(1);
  maximumdisplaywidth 8000;
  
  -- Wisconsin Query 3
  
  get cursor c as
  	'select * from TENKTUP1
  	where unique2 between 0 and 99';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Wisconsin Query 4
  
  get cursor c as
  	'select * from TENKTUP1
  	where unique2 between 792 and 1791';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Wisconsin Query 5
  get cursor c as
  	'select * from TENKTUP1
  	where unique1 between 0 and 99';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Wisconsin Query 6
  get cursor c as
  	'select * from TENKTUP1
  	where unique1 between 792 and 1791';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Wisconsin Query 7
  get cursor c as
  	'select *
  	from TENKTUP1
  	where unique2 = 2001';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Wisconsin Query 12
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where (TENKTUP1.unique2 = TENKTUP2.unique2)
  	and (TENKTUP2.unique2 < 1000)';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Wisconsin Query 13
  get cursor c as
  	'select * from TENKTUP1, BPRIME
  	where (TENKTUP1.unique2 = BPRIME.UNIQUE2)';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Wisconsin query 14
  -- NOTE: This could benefit from transitive closure, which our optimizer
  -- doesn't do (yet).
  -- Note that after fix for optimizer bug 5868, in runtime statistics info, we will see 2 qualifiers for table TENKTUP2. This is because as fix for
  -- bug 5868, while getting rid of a redundant predicate which is a start and/or stop AND a qualifier, we mark the predicate we are going to keep 
  -- as start and/or stop AND as a qualifier. Prior to fix of bug 5868, we were disregarding the qualifier flag on the redundant predicate if it 
  -- was a start and/or stop predicate too.
  get cursor c as
  	'select * from ONEKTUP, TENKTUP1, TENKTUP2
  	where (ONEKTUP.unique2 = TENKTUP1.unique2)
  	and (TENKTUP1.unique2 = TENKTUP2.unique2)
  	and (TENKTUP1.unique2 < 1000)';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Wisconsin Query 15
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where (TENKTUP1.unique1 = TENKTUP2.unique1)
  	and (TENKTUP1.unique1 < 1000)';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Wisconsin Query 16
  get cursor c as
  	'select * from TENKTUP1, BPRIME
  	where (TENKTUP1.unique1 = BPRIME.unique1)';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Wisconsin Query 17
  
  -- NOTE: This could benefit from transitive closure, which our optimizer
  -- doesn't do (yet).
  -- Note that after fix for optimizer bug 5868, in runtime statistics info, we will see 2 qualifiers for table TENKTUP2. This is because as fix for
  -- bug 5868, while getting rid of a redundant predicate which is a start and/or stop AND a qualifier, we mark the predicate we are going to keep 
  -- as start and/or stop AND as a qualifier. Prior to fix of bug 5868, we were disregarding the qualifier flag on the redundant predicate if it 
  -- was a start and/or stop predicate too.
  
  get cursor c as
  	'select * from ONEKTUP, TENKTUP1, TENKTUP2
  	where (ONEKTUP.unique1 = TENKTUP1.unique1)
  	and (TENKTUP1.unique1 = TENKTUP2.unique1)
  	and (TENKTUP1.unique1 < 1000)';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- This is the end of the Wisconsin queries.  Now do some queries that are
  -- not part of the original Wisconsin benchmark, using the Wisconsin schema.
  
  -- Single-table queries using index on column 'two'
  
  -- 50% selectivity index that doesn't cover query - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where two = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 50% selectivity index with 0 matching rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where two = 3';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 100% of rows - should do table scan
  get cursor c as
  	'select * from TENKTUP1
  	where two >= 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 0 rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where two > 1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 50% selectivity index that covers query - should do index scan
  get cursor c as
  	'select two from TENKTUP1
  	where two = 1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Single-table queries using index on column 'four'
  
  -- 25% selectivity index that doesn't cover query - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where four = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 25% selectivity index with 0 matching rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where four = 4';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 75% of rows - should do table scan
  get cursor c as
  	'select * from TENKTUP1
  	where four >= 1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 0 rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where four > 3';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 25% selectivity index that covers query - should do index scan
  get cursor c as
  	'select four from TENKTUP1
  	where four = 2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Single-table queries using index on column 'twentyPercent'
  
  -- 20% selectivity index that doesn't cover query - should use index
  get cursor c as
  	'select * from TENKTUP1
  	where twentyPercent = 2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 20% selectivity index with 0 matching rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where twentyPercent = 5';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 60% of rows - should do table scan
  get cursor c as
  	'select * from TENKTUP1
  	where twentyPercent > 1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 0 rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where twentyPercent > 4';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 20% selectivity index that covers query - should do index scan
  get cursor c as
  	'select twentyPercent from TENKTUP1
  	where twentyPercent = 3';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Single-table queries using index on column 'ten'
  
  -- 10% selectivity index that doesn't cover query - should use index
  get cursor c as
  	'select * from TENKTUP1
  	where ten = 5';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 10% selectivity index with 0 matching rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where ten = 10';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 50% of rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where ten <= 4';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 60% of rows - should do table scan
  get cursor c as
  	'select * from TENKTUP1
  	where ten <= 5';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 0 rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where ten > 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 10% selectivity index that covers query - should do index scan
  get cursor c as
  	'select ten from TENKTUP1
  	where ten = 7';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Single-table queries using index on column 'twenty'
  
  -- 5% selectivity index that doesn't cover query - should use index
  get cursor c as
  	'select * from TENKTUP1
  	where twenty = 17';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 5% selectivity index with 0 matching rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where twenty = 20';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 50% of rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where twenty <= 9';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 55% of rows - should do table scan
  get cursor c as
  	'select * from TENKTUP1
  	where twenty <= 10';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 0 rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where twenty < 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 5% selectivity index that covers query - should do index scan
  get cursor c as
  	'select twenty from TENKTUP1
  	where twenty = 19';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Single-table queries using index on column 'onePercent'
  
  -- 1% selectivity index that doesn't cover query - should use index
  get cursor c as
  	'select * from TENKTUP1
  	where onePercent = 63';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 1% selectivity index with 0 matching rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where onePercent = 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 50% of rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where onePercent > 49';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 60% of rows - should do table scan
  get cursor c as
  	'select * from TENKTUP1
  	where onePercent > 40';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 0 rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where onePercent > 101';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 1% selectivity index that covers query - should do index scan
  get cursor c as
  	'select onePercent from TENKTUP1
  	where onePercent = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Single-table queries using index on column 'evenOnePercent'
  
  -- 1% selectivity index that doesn't cover query - should use index
  get cursor c as
  	'select * from TENKTUP1
  	where evenOnePercent = 64';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 1% selectivity index with 0 matching rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where evenOnePercent = 200';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 50% of rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where evenOnePercent > 99';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 60% of rows - should do table scan
  get cursor c as
  	'select * from TENKTUP1
  	where evenOnePercent > 80';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 0 rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where evenOnePercent > 198';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 1% selectivity index that covers query - should do index scan
  get cursor c as
  	'select evenOnePercent from TENKTUP1
  	where evenOnePercent = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Single-table queries using index on column 'oddOnePercent'
  
  -- 1% selectivity index that doesn't cover query - should use index
  get cursor c as
  	'select * from TENKTUP1
  	where oddOnePercent = 63';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 1% selectivity index with 0 matching rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where oddOnePercent = 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 40% of rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where oddOnePercent > 120';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 60% of rows - should do table scan
  get cursor c as
  	'select * from TENKTUP1
  	where oddOnePercent > 80';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 0 rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where oddOnePercent > 199';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 1% selectivity index that covers query - should do index scan
  get cursor c as
  	'select oddOnePercent from TENKTUP1
  	where oddOnePercent = 1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Single-table queries using index on column 'stringu1'
  
  -- unique index that doesn't cover query - should use index
  get cursor c as
  	'select * from TENKTUP1
  	where stringu1 = ''AAAAJKLxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- unique index with 0 matching rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where stringu1 = ''AAAAZZZxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 50% of rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where stringu1 > ''AAAAHKHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 51% of rows - should do table scan
  get cursor c as
  	'select * from TENKTUP1
  	where stringu1 > ''AAAAHOCxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 0 rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where stringu1 > ''AAAAOUPxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- unique index that covers query - should do index scan
  get cursor c as
  	'select stringu1 from TENKTUP1
  	where stringu1 = ''AAAAAABxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Single-table queries using index on column 'stringu2'
  
  -- unique index that doesn't cover query - should use index
  get cursor c as
  	'select * from TENKTUP1
  	where stringu2 = ''AAAAJKLxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- unique index with 0 matching rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where stringu2 = ''AAAAZZZxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 50% of rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where stringu2 > ''AAAAHKHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 51% of rows - should do table scan
  get cursor c as
  	'select * from TENKTUP1
  	where stringu2 > ''AAAAHOCxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 0 rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where stringu2 > ''AAAAOUPxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- unique index that covers query - should do index scan
  get cursor c as
  	'select stringu2 from TENKTUP1
  	where stringu2 = ''AAAAAABxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Single-table queries using index on column 'string4'
  
  -- 25% selectivity index that doesn't cover query - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where string4 = ''AAAAxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 25% selectivity index with 0 matching rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where string4 = ''EEEExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 50% of rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where string4 > ''HHHHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- matches 0 rows - should do index scan
  get cursor c as
  	'select * from TENKTUP1
  	where string4 > ''VVVVxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 25% selectivity index that covers query - should do index scan
  get cursor c as
  	'select string4 from TENKTUP1
  	where string4 = ''OOOOxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx''';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Now test equijoins with different selectivities and different numbers
  -- of outer rows.  The approach taken is that different join columns are
  -- used, and that TENKTUP1 has indexes on all the joining columns, while
  -- TENKTUP2 does not.  We use the unique1 column of TENKTUP2 to select
  -- different numbers of rows.  The two tables will always appear in the
  -- FROM clause with TENKTUP1 first, and TENKTUP2 second - it is up to
  -- the optimizer to figure out which should come first in the join order.
  
  -- Joins on unique1
  
  -- Join on unique1, all rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 60% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 25% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 10% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 5% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 1% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 1 row in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on two
  
  -- Join on two, all rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 60% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 25% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 10% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 5% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 1% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 1 row in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on four
  
  -- Join on four, all rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 60% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 25% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 10% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 5% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 1% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 1 row in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on ten
  
  -- Join on ten, all rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 60% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 25% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 10% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 5% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 1% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 1 row in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on twenty
  
  -- Join on twenty, all rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 60% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 25% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 10% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 5% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 1% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 1 row in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on onePercent
  
  -- Join on onePercent, all rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 60% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 25% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 10% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 5% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 1% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 1 row in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on twentyPercent
  
  -- Join on twentyPercent, all rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 60% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 25% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 10% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 5% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 1% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 1 row in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on stringu1
  
  -- Join on stringu1, all rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 60% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 25% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 10% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 5% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 1% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 1 row in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on string4
  
  -- Join on string4, all rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 60% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 25% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 10% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 5% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 1% of rows in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 1 row in TENKTUP2
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Now do the same equijoin tests, but select only one column from TENKTUP1.
  -- This way, it can choose hash join where appropriate (it avoids it where
  -- it thinks the hash table will take too much memory).
  
  -- Joins on unique1
  
  -- Join on unique1, all rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 60% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 25% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 10% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 5% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 1% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on unique1, 1 row in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.unique1 = TENKTUP2.unique1
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on two
  
  -- Join on two, all rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 60% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 25% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 10% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 5% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 1% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on two, 1 row in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on four
  
  -- Join on four, all rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 60% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 25% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 10% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 5% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 1% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on four, 1 row in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.four = TENKTUP2.four
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on ten
  
  -- Join on ten, all rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 60% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 25% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 10% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 5% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 1% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on ten, 1 row in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.ten = TENKTUP2.ten
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on twenty
  
  -- Join on twenty, all rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 60% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 25% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 10% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 5% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 1% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twenty, 1 row in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twenty = TENKTUP2.twenty
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on onePercent
  
  -- Join on onePercent, all rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 60% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 25% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 10% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 5% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 1% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on onePercent, 1 row in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on twentyPercent
  
  -- Join on twentyPercent, all rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 60% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 25% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 10% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 5% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 1% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on twentyPercent, 1 row in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.twentyPercent = TENKTUP2.twentyPercent
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on stringu1
  
  -- Join on stringu1, all rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 60% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 25% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 10% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 5% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 1% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on stringu1, 1 row in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.stringu1 = TENKTUP2.stringu1
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joins on string4
  
  -- Join on string4, all rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 60% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 < 6000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 25% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 < 2500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 10% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 < 1000';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 5% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 < 500';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 1% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 < 100';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Join on string4, 1 row in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.string4 = TENKTUP2.string4
  	and TENKTUP2.unique1 = 0';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Test the effect of ORDER BY on access path.  The optimizer takes
  -- the cost of sorting into account, and may choose an access path
  -- in the same order as the ORDER BY, especially if the sort is
  -- expensive.
  --
  -- First try single-table queries.
  
  -- No where clause, try ordering on different indexed columns
  
  get cursor c as
  	'select * from TENKTUP1 order by unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by two';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by four';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by ten';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by twenty';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by onePercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by twentyPercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by evenOnePercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by oddOnePercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by stringu1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by stringu2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1 order by string4';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Now try the same thing with covering indexes
  
  get cursor c as
  	'select unique1 from TENKTUP1 order by unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select unique2 from TENKTUP1 order by unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select two from TENKTUP1 order by two';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select four from TENKTUP1 order by four';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select ten from TENKTUP1 order by ten';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select twenty from TENKTUP1 order by twenty';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select onePercent from TENKTUP1 order by onePercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select twentyPercent from TENKTUP1 order by twentyPercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select evenOnePercent from TENKTUP1 order by evenOnePercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select oddOnePercent from TENKTUP1 order by oddOnePercent';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select stringu1 from TENKTUP1 order by stringu1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select stringu2 from TENKTUP1 order by stringu2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select string4 from TENKTUP1 order by string4';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Where clause on same column as order by, with different selectivities.
  
  -- 60%
  get cursor c as
  	'select * from TENKTUP1 where unique1 < 6000 order by unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 25%
  get cursor c as
  	'select * from TENKTUP1 where unique1 < 2500 order by unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 10%
  get cursor c as
  	'select * from TENKTUP1 where unique1 < 1000 order by unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 5%
  get cursor c as
  	'select * from TENKTUP1 where unique1 < 500 order by unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 1%
  get cursor c as
  	'select * from TENKTUP1 where unique1 < 100 order by unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- one row
  get cursor c as
  	'select * from TENKTUP1 where unique1 = 0 order by unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Where clause and order by on different columns - non-covering
  
  -- 60%
  get cursor c as
  	'select * from TENKTUP1 where unique1 < 6000 order by unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 25%
  get cursor c as
  	'select * from TENKTUP1 where unique1 < 2500 order by unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 10%
  get cursor c as
  	'select * from TENKTUP1 where unique1 < 1000 order by unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 5%
  get cursor c as
  	'select * from TENKTUP1 where unique1 < 500 order by unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 1%
  get cursor c as
  	'select * from TENKTUP1 where unique1 < 100 order by unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- one row
  get cursor c as
  	'select * from TENKTUP1 where unique1 = 0 order by unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Where clause and order by on different columns - covering
  
  create index TK1UNIQUE1TWO on TENKTUP1(unique1, two);
  create index TK1TWOUNIQUE1 on TENKTUP1(two, unique1);
  
  -- 60%
  get cursor c as
  	'select two from TENKTUP1 where unique1 < 6000 order by two';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 25%
  get cursor c as
  	'select two from TENKTUP1 where unique1 < 2500 order by two';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 10%
  get cursor c as
  	'select two from TENKTUP1 where unique1 < 1000 order by two';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 5%
  get cursor c as
  	'select two from TENKTUP1 where unique1 < 500 order by two';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 1%
  get cursor c as
  	'select two from TENKTUP1 where unique1 < 100 order by two';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- one row
  -- RESOLVE: For some reason, this avoids the sort by choosing the
  -- index on column two, rather than by treating it as a one-row table.
  -- It does not do this if you run the query by itself, outside of this
  -- test.
  get cursor c as
  	'select two from TENKTUP1 where unique1 = 0 order by two';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  drop index TK1UNIQUE1TWO;
  
  -- Constant search condition on first column of index, order on second
  -- column.
  get cursor c as
  	'select two, unique1 from TENKTUP1 where two = 0 order by unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Constant search condition on first column of index, order on first and second
  -- columns.
  get cursor c as
  	'select two, unique1 from TENKTUP1 where two = 0 order by two, unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  drop index TK1TWOUNIQUE1;
  
  commit;
  
  -- Now test sort avoidance with joins.
  --
  -- First try two-way joins where the order by column is in only one table
  
  -- Order by column same as joining column
  --
  -- 100% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 60% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP2.unique1 < 6000
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 25% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP2.unique1 < 2500
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- force TENKTUP1 as the outermost join table to make sure 
  -- that no sorting is necessary. DERBY-3926
  get cursor c as
  	'select * from --DERBY-PROPERTIES joinOrder=FIXED
  	 TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP2.unique1 < 2500
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- This time, force TENKTUP2 as the outermost join table to make sure 
  -- that still no sorting is necessary. DERBY-3926
  -- DERBY-4331 backs out part of DERBY-3926, the expected plan now does not
  -- do sort avoidance.  
  -- When DERBY-4339 is implemented, the following query plan should not have
  -- a sort node.
  -- The plan is forced to use TENKTUP2 as outermost
  -- join.  It knows that query result is sorted on TENKTUP2.unique1, but does not
  -- recognize that because "TENKTUP1.unique1 = TENKTUP2.unique1" that query
  -- is also sorted on TENKTUP1.unique1 and could avoid a sort.
  get cursor c as
  	'select * from --DERBY-PROPERTIES joinOrder=FIXED
  	 TENKTUP2, TENKTUP1
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP2.unique1 < 2500
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 25% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP2.unique1 < 2500
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 10% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP2.unique1 < 1000
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 5% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP2.unique1 < 500
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 1% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP2.unique1 < 100
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- one row from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP2.unique1 = 0
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Order by column different from joining column
  --
  -- 100% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique2 = TENKTUP2.unique2
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 60% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique2 = TENKTUP2.unique2
  	 and TENKTUP2.unique1 < 6000
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 25% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique2 = TENKTUP2.unique2
  	 and TENKTUP2.unique1 < 2500
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 25% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique2 = TENKTUP2.unique2
  	 and TENKTUP2.unique1 < 2500
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 10% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique2 = TENKTUP2.unique2
  	 and TENKTUP2.unique1 < 1000
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 5% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique2 = TENKTUP2.unique2
  	 and TENKTUP2.unique1 < 500
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- 1% of rows from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique2 = TENKTUP2.unique2
  	 and TENKTUP2.unique1 < 100
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- one row from joining table
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique2 = TENKTUP2.unique2
  	 and TENKTUP2.unique1 = 0
  	 order by TENKTUP1.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Sort avoidance with joins and order by on columns in different tables
  --
  -- order on joining columns
  -- DERBY-4339, DERBY-4331
  -- until DERBY-4339 is implemented the following query will not do sort
  -- avoidance.  The current code does not use the knowledge that
  -- TENKTUP1.unique1 = TENKTUP2.unique1 to infer that a plan that is sorted
  -- on TENKTUP1.unique1 or TENKTUP2.unique1 is also sorted correctly for an
  -- order by TENKTUP1.unique1, TENKTUP2.unique1.
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- order on joining columns with qualifications on non-joining columns
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 6000
  	 and TENKTUP2.unique2 < 6000
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 2500
  	 and TENKTUP2.unique2 < 2500
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 1000
  	 and TENKTUP2.unique2 < 1000
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 500
  	 and TENKTUP2.unique2 < 500
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 100
  	 and TENKTUP2.unique2 < 100
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 = 0
  	 and TENKTUP2.unique2 = 0
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 6000
  	 and TENKTUP2.unique2 = 0
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 2500
  	 and TENKTUP2.unique2 < 100
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 1000
  	 and TENKTUP2.unique2 < 500
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- order on non-joining columns
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 order by TENKTUP1.unique2, TENKTUP2.unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- order on non-joining columns with qualifications on non-joining columns
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 6000
  	 and TENKTUP2.unique2 < 6000
  	 order by TENKTUP1.unique2, TENKTUP2.unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 2500
  	 and TENKTUP2.unique2 < 2500
  	 order by TENKTUP1.unique2, TENKTUP2.unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 1000
  	 and TENKTUP2.unique2 < 1000
  	 order by TENKTUP1.unique2, TENKTUP2.unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 500
  	 and TENKTUP2.unique2 < 500
  	 order by TENKTUP1.unique2, TENKTUP2.unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 100
  	 and TENKTUP2.unique2 < 100
  	 order by TENKTUP1.unique2, TENKTUP2.unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 = 0
  	 and TENKTUP2.unique2 = 0
  	 order by TENKTUP1.unique2, TENKTUP2.unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 6000
  	 and TENKTUP2.unique2 = 0
  	 order by TENKTUP1.unique2, TENKTUP2.unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 2500
  	 and TENKTUP2.unique2 < 100
  	 order by TENKTUP1.unique2, TENKTUP2.unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and TENKTUP1.unique2 < 1000
  	 and TENKTUP2.unique2 < 500
  	 order by TENKTUP1.unique2, TENKTUP2.unique2';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Three-way join, order on columns from only two tables
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2, ONEKTUP
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and ONEKTUP.unique1 = TENKTUP1.unique1
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2, ONEKTUP
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and ONEKTUP.unique1 = TENKTUP1.unique1
  	 and TENKTUP1.unique1 < 6000
  	 and TENKTUP2.unique1 < 6000
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2, ONEKTUP
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and ONEKTUP.unique1 = TENKTUP1.unique1
  	 and TENKTUP1.unique1 = 0
  	 and TENKTUP2.unique1 = 0
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2, ONEKTUP
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and ONEKTUP.unique1 = TENKTUP1.unique1
  	 and TENKTUP1.unique2 < 6000
  	 and TENKTUP2.unique2 < 6000
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2, ONEKTUP
  	 where TENKTUP1.unique1 = TENKTUP2.unique1
  	 and ONEKTUP.unique1 = TENKTUP1.unique1
  	 and TENKTUP1.unique2 = 0
  	 and TENKTUP2.unique2 = 0
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Joining columns different from ordering columns
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2, ONEKTUP
  	 where TENKTUP1.unique2 = TENKTUP2.unique2
  	 and ONEKTUP.unique2 = TENKTUP1.unique2
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2, ONEKTUP
  	 where TENKTUP1.unique2 = TENKTUP2.unique2
  	 and ONEKTUP.unique2 = TENKTUP1.unique2
  	 and TENKTUP1.unique2 < 6000
  	 and TENKTUP2.unique2 < 6000
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2, ONEKTUP
  	 where TENKTUP1.unique2 = TENKTUP2.unique2
  	 and ONEKTUP.unique2 = TENKTUP1.unique2
  	 and TENKTUP1.unique2 = 0
  	 and TENKTUP2.unique2 = 0
  	 order by TENKTUP1.unique1, TENKTUP2.unique1';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Values clause is a single-row result set, so should not cause optimizer
  -- to require sort.
  
  get cursor c as
  	'select * from TENKTUP1, (values 1) as t(x)
  	 where TENKTUP1.unique1 = t.x
  	 order by TENKTUP1.unique1, t.x';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Try with a join on unique column and order on non-unique column
  get cursor c as
  	'select * from TENKTUP1, (values 1) as t(x)
  	 where TENKTUP1.unique1 = t.x
  	 order by TENKTUP1.two, t.x';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, (values 1) as t(x)
  	 where TENKTUP1.two = t.x
  	 order by TENKTUP1.two, t.x';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, (values 1) as t(x)
  	 where TENKTUP1.four = t.x
  	 order by TENKTUP1.four, t.x';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, (values 1) as t(x)
  	 where TENKTUP1.ten = t.x
  	 order by TENKTUP1.ten, t.x';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, (values 1) as t(x)
  	 where TENKTUP1.twenty = t.x
  	 order by TENKTUP1.twenty, t.x';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, (values 1) as t(x)
  	 where TENKTUP1.onePercent = t.x
  	 order by TENKTUP1.onePercent, t.x';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, (values 1) as t(x)
  	 where TENKTUP1.tenPercent = t.x
  	 order by TENKTUP1.tenPercent, t.x';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, (values 1) as t(x)
  	 where TENKTUP1.twentyPercent = t.x
  	 order by TENKTUP1.twentyPercent, t.x';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  get cursor c as
  	'select * from TENKTUP1, (values 1) as t(x)
  	 where TENKTUP1.fiftyPercent = t.x
  	 order by TENKTUP1.fiftyPercent, t.x';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Test for bug 2307:
  -- Join between primary & foreign keys, w/= clause on foreign tab &
  -- ORDER on indexed col of prim. tab returns rows in wrong order
  
  get cursor c as
  	'select * from TENKTUP1, TENKTUP2
  	 where TENKTUP1.unique1 = TENKTUP2.ten
  	 and TENKTUP2.onePercent = 63
  	 order by TENKTUP1.two';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- Test multi-level outer join
  
  -- Extra-wide output because many tables.
  maximumdisplaywidth 8000;
  get cursor c as
  	'select * from TENKTUP1
  		left outer join TENKTUP2 on
  		(
  			TENKTUP1.unique1 = TENKTUP2.unique1
  		)
  		left outer join ONEKTUP on
  		(
  			TENKTUP2.unique2 = ONEKTUP.unique2
  		)
  		left outer join BPRIME on
  		(
  			ONEKTUP.onePercent = BPRIME.onePercent
  		)';
  close c;
  
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  commit;
  
  -- tests to show selectivity - rowcount estimates
  -- the numbers skip a value for reference to original Cloudscape test cases
  -- with identical queries using properties useStatistics=false.
  -- do simple joins on columns and look at row count/cost.
  
  -- Join on two, all rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two';
  close c;
  -- 1, join on two--all rows
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  -- Join on two, 60% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 6000';
  close c;
  -- 3, join on two--60%
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  -- Join on two, 25% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 2500';
  close c;
  -- 5, join on two--25%
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  -- Join on two, 10% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 1000';
  close c;
  -- 7, join on two--10%
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  -- Join on two, 5% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 500';
  close c;
  -- 9, join on two--5%
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  -- Join on two, 1% of rows in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 < 100';
  close c;
  -- 11, join on two--1%
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  -- Join on two, 1 row in TENKTUP2
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.two = TENKTUP2.two
  	and TENKTUP2.unique1 = 0';
  close c;
  -- 13, join on two--1 row
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  --  now do joins on a very low cardinality table
  
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from 
  	TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent';
  close c;
  
  -- 15, join on onePercent--all rows
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 6000';
  close c;
  -- 17, join on onePercent--60%
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 2500';
  close c;
  -- 19, join on onePercent--25%
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 1000';
  close c;
  -- 21, join on onePercent--10%
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 500';
  close c;
  -- 23, join on onePercent--5%
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 < 100';
  close c;
  -- 25, join on onePercent--1%
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  get cursor c as
  	'select TENKTUP1.unique2, TENKTUP2.* from TENKTUP1, TENKTUP2
  	where TENKTUP1.onePercent = TENKTUP2.onePercent
  	and TENKTUP2.unique1 = 0';
  close c;
  -- 27, join on onePercent--1 row
  values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS();
  
  -- cleanup
  drop table TENKTUP1;
  drop table TENKTUP2;
  drop table ONEKTUP;
  drop table BPRIME;
  