Improved EXPLAIN plan formatting and documentation.

h2/src/main/org/h2/command/dml/Insert.java

@@ -188,9 +188,12 @@ public class Insert extends Prepared implements ResultTarget {
         if (list.size() > 0) {
             buff.append("VALUES ");
             int row = 0;
+            if (list.size() > 1) {
+                buff.append("\n");
+            }
             for (Expression[] expr : list) {
                 if (row++ > 0) {
-                    buff.append(", ");
+                    buff.append(",\n");
                 }
                 buff.append('(');
                 buff.resetCount();

h2/src/main/org/h2/command/dml/Update.java

@@ -140,14 +140,14 @@ public class Update extends Prepared {
 
     public String getPlanSQL() {
         StatementBuilder buff = new StatementBuilder("UPDATE ");
-        buff.append(tableFilter.getPlanSQL(false)).append("\nSET ");
+        buff.append(tableFilter.getPlanSQL(false)).append("\nSET\n    ");
         Table table = tableFilter.getTable();
         int columnCount = table.getColumns().length;
         for (int i = 0; i < columnCount; i++) {
             Expression newExpr = expressions[i];
             if (newExpr != null) {
                 Column column = table.getColumn(i);
-                buff.appendExceptFirst(",\n");
+                buff.appendExceptFirst(",\n    ");
                 buff.append(column.getName()).append(" = ").append(newExpr.getSQL());
             }
         }

h2/src/main/org/h2/expression/ConditionAndOr.java

@@ -46,10 +46,10 @@ public class ConditionAndOr extends Condition {
         String sql;
         switch (andOrType) {
         case AND:
-            sql = left.getSQL() + " AND " + right.getSQL();
+            sql = left.getSQL() + "\n    AND " + right.getSQL();
             break;
         case OR:
-            sql = left.getSQL() + " OR " + right.getSQL();
+            sql = left.getSQL() + "\n    OR " + right.getSQL();
             break;
         default:
             throw DbException.throwInternalError("andOrType=" + andOrType);

h2/src/main/org/h2/expression/ConditionInSelect.java

@@ -15,6 +15,7 @@ import org.h2.message.DbException;
 import org.h2.result.ResultInterface;
 import org.h2.table.ColumnResolver;
 import org.h2.table.TableFilter;
+import org.h2.util.StringUtils;
 import org.h2.value.Value;
 import org.h2.value.ValueBoolean;
 import org.h2.value.ValueNull;
@@ -101,7 +102,7 @@ public class ConditionInSelect extends Condition {
     }
 
     public String getSQL() {
-        return "(" + left.getSQL() + " IN(" + query.getPlanSQL() + "))";
+        return "(" + left.getSQL() + " IN(\n" + StringUtils.indent(query.getPlanSQL(), 4, false) + "))";
     }
 
     public void updateAggregate(Session session) {

h2/src/main/org/h2/index/FunctionIndex.java

@@ -91,4 +91,8 @@ public class FunctionIndex extends BaseIndex {
         return functionTable.getRowCountApproximation();
     }
 
+    public String getPlanSQL() {
+        return "function";
+    }
+
 }

h2/src/main/org/h2/index/MetaIndex.java

@@ -97,4 +97,8 @@ public class MetaIndex extends BaseIndex {
         return MetaTable.ROW_COUNT_APPROXIMATION;
     }
 
+    public String getPlanSQL() {
+        return "meta";
+    }
+
 }

h2/src/main/org/h2/table/TableFilter.java

@@ -616,13 +616,16 @@ public class TableFilter implements ColumnResolver {
             }
         }
         if (nestedJoin != null) {
-            buff.append("(\n");
+            StringBuffer buffNested = new StringBuffer();
             TableFilter n = nestedJoin;
             do {
-                buff.append(n.getPlanSQL(n != nestedJoin));
-                buff.append("\n");
+                buffNested.append(n.getPlanSQL(n != nestedJoin));
+                buffNested.append("\n");
                 n = (TableFilter) n.getJoin();
             } while (n != null);
+
+            buff.append("(\n");
+            buff.append(StringUtils.indent(buffNested.toString(), 4, false));
             buff.append(") ON ");
             if (joinCondition == null) {
                 // need to have a ON expression,
@@ -638,21 +641,24 @@ public class TableFilter implements ColumnResolver {
             buff.append(' ').append(Parser.quoteIdentifier(alias));
         }
         if (index != null) {
-            buff.append(" /* ");
+            buff.append("\n");
             StatementBuilder planBuff = new StatementBuilder();
             planBuff.append(index.getPlanSQL());
             if (indexConditions.size() > 0) {
                 planBuff.append(": ");
                 for (IndexCondition condition : indexConditions) {
-                    planBuff.appendExceptFirst(" AND ");
+                    planBuff.appendExceptFirst("\n    AND ");
                     planBuff.append(condition.getSQL());
                 }
             }
             String plan = StringUtils.quoteRemarkSQL(planBuff.toString());
-            buff.append(plan).append(" */");
+            if (plan.indexOf('\n') >= 0) {
+                plan += "\n";
+            }
+            buff.append(StringUtils.indent("/* " + plan + " */", 4, false));
         }
         if (isJoin) {
-            buff.append(" ON ");
+            buff.append("\n    ON ");
             if (joinCondition == null) {
                 // need to have a ON expression, otherwise the nesting is
                 // unclear
@@ -662,13 +668,13 @@ public class TableFilter implements ColumnResolver {
             }
         }
         if (filterCondition != null) {
-            buff.append(" /* WHERE ");
+            buff.append("\n");
             String condition = StringUtils.unEnclose(filterCondition.getSQL());
-            condition = StringUtils.quoteRemarkSQL(condition);
-            buff.append(condition).append(" */");
+            condition = "/* WHERE " + StringUtils.quoteRemarkSQL(condition) + "\n*/";
+            buff.append(StringUtils.indent(condition, 4, false));
         }
         if (scanCount > 0) {
-            buff.append(" /* scanCount: ").append(scanCount).append(" */");
+            buff.append("\n    /* scanCount: ").append(scanCount).append(" */");
         }
         return buff.toString();
     }

h2/src/main/org/h2/table/TableView.java

@@ -269,7 +269,7 @@ public class TableView extends Table {
 
     public String getSQL() {
         if (isTemporary()) {
-            return "(" + querySQL + ")";
+            return "(\n" + StringUtils.indent(querySQL) + ")";
         }
         return super.getSQL();
     }

h2/src/main/org/h2/util/StringUtils.java

@@ -582,20 +582,23 @@ public class StringUtils {
 
     /**
      * Indents a string with 4 spaces.
+     *
      * @param s the string
      * @return the indented string
      */
-    private static String indent(String s) {
-        return indent(s, 4);
+    public static String indent(String s) {
+        return indent(s, 4, true);
     }
 
     /**
      * Indents a string with spaces.
+     *
      * @param s the string
      * @param spaces the number of spaces
+     * @param newline append a newline if there is none
      * @return the indented string
      */
-    private static String indent(String s, int spaces) {
+    public static String indent(String s, int spaces, boolean newline) {
         StringBuilder buff = new StringBuilder(s.length() + spaces);
         for (int i = 0; i < s.length();) {
             for (int j = 0; j < spaces; j++) {
@@ -606,7 +609,7 @@ public class StringUtils {
             buff.append(s.substring(i, n));
             i = n;
         }
-        if (!s.endsWith("\n")) {
+        if (newline && !s.endsWith("\n")) {
             buff.append('\n');
         }
         return buff.toString();

h2/src/test/org/h2/samples/optimizations.sql

@@ -21,8 +21,10 @@ SELECT COUNT(*) FROM TEST;
 
 -- Display the query plan - 'direct lookup' means the index is used
 EXPLAIN SELECT COUNT(*) FROM TEST;
---> SELECT COUNT(*)
--->    FROM PUBLIC.TEST /* PUBLIC.TEST.tableScan */
+--> SELECT
+-->        COUNT(*)
+-->    FROM PUBLIC.TEST
+-->        /* PUBLIC.TEST.tableScan */
 -->    /* direct lookup */
 ;
 
@@ -56,8 +58,10 @@ SELECT DISTINCT TYPE FROM TEST ORDER BY TYPE LIMIT 3;
 
 -- Display the query plan - 'index sorted' means the index is used to order
 EXPLAIN SELECT DISTINCT TYPE FROM TEST ORDER BY TYPE LIMIT 3;
---> SELECT DISTINCT TYPE
--->    FROM PUBLIC.TEST /* PUBLIC.IDX_TEST_TYPE */
+--> SELECT DISTINCT
+-->        TYPE
+-->    FROM PUBLIC.TEST
+-->        /* PUBLIC.IDX_TEST_TYPE */
 -->    ORDER BY 1
 -->    LIMIT 3
 -->    /* distinct */
@@ -89,8 +93,11 @@ SELECT MIN(VALUE), MAX(VALUE) FROM TEST;
 
 -- Display the query plan - 'direct lookup' means it's optimized
 EXPLAIN SELECT MIN(VALUE), MAX(VALUE) FROM TEST;
---> SELECT MIN(VALUE), MAX(VALUE)
--->    FROM PUBLIC.TEST /* PUBLIC.TEST.tableScan */
+--> SELECT
+-->        MIN(VALUE),
+-->        MAX(VALUE)
+-->    FROM PUBLIC.TEST
+-->        /* PUBLIC.TEST.tableScan */
 -->    /* direct lookup */
 ;
 
@@ -130,17 +137,29 @@ FROM (SELECT DISTINCT TYPE FROM TEST) T ORDER BY TYPE;
 EXPLAIN SELECT TYPE, (SELECT VALUE FROM TEST T2 WHERE T.TYPE = T2.TYPE
 ORDER BY TYPE, VALUE LIMIT 1) MIN
 FROM (SELECT DISTINCT TYPE FROM TEST) T ORDER BY TYPE;
---> SELECT TYPE, (SELECT VALUE
--->    FROM PUBLIC.TEST T2 /* PUBLIC.IDX_TEST_TYPE_VALUE: TYPE = T.TYPE */
+--> SELECT
+-->        TYPE,
+-->        (SELECT
+-->            VALUE
+-->        FROM PUBLIC.TEST T2
+-->            /* PUBLIC.IDX_TEST_TYPE_VALUE: TYPE = T.TYPE */
 -->        WHERE T.TYPE = T2.TYPE
 -->        ORDER BY =TYPE, 1
 -->        LIMIT 1
 -->        /* index sorted */) AS MIN
--->    FROM (SELECT DISTINCT TYPE
--->    FROM PUBLIC.TEST /* PUBLIC.IDX_TEST_TYPE_VALUE */
--->    /* distinct */) T /* SELECT DISTINCT TYPE
--->    FROM PUBLIC.TEST /++ PUBLIC.IDX_TEST_TYPE_VALUE ++/
--->    /++ distinct ++/ */
+-->    FROM (
+-->        SELECT DISTINCT
+-->            TYPE
+-->        FROM PUBLIC.TEST
+-->            /* PUBLIC.IDX_TEST_TYPE_VALUE */
+-->        /* distinct */
+-->    ) T
+-->        /* SELECT DISTINCT
+-->            TYPE
+-->        FROM PUBLIC.TEST
+-->            /++ PUBLIC.IDX_TEST_TYPE_VALUE ++/
+-->        /++ distinct ++/
+-->         */
 -->    ORDER BY 1
 ;
 
@@ -171,8 +190,10 @@ SELECT VALUE FROM TEST ORDER BY VALUE LIMIT 3;
 
 -- Display the query plan - 'index sorted' means the index is used
 EXPLAIN SELECT VALUE FROM TEST ORDER BY VALUE LIMIT 10;
---> SELECT VALUE
--->    FROM PUBLIC.TEST /* PUBLIC.IDX_TEST_VALUE */
+--> SELECT
+-->        VALUE
+-->    FROM PUBLIC.TEST
+-->        /* PUBLIC.IDX_TEST_VALUE */
 -->    ORDER BY 1
 -->    LIMIT 10
 -->    /* index sorted */
@@ -190,8 +211,10 @@ SELECT VALUE FROM TEST ORDER BY VALUE DESC LIMIT 3;
 
 -- Display the query plan - 'index sorted' means the index is used
 EXPLAIN SELECT VALUE FROM TEST ORDER BY VALUE DESC LIMIT 10;
---> SELECT VALUE
--->    FROM PUBLIC.TEST /* PUBLIC.IDX_TEST_VALUE_D */
+--> SELECT
+-->        VALUE
+-->    FROM PUBLIC.TEST
+-->        /* PUBLIC.IDX_TEST_VALUE_D */
 -->    ORDER BY 1 DESC
 -->    LIMIT 10
 -->    /* index sorted */
@@ -216,8 +239,10 @@ SELECT * FROM TEST WHERE ID IN(1, 1000);
 
 -- Display the query plan
 EXPLAIN SELECT * FROM TEST WHERE ID IN(1, 1000);
---> SELECT TEST.ID
--->    FROM PUBLIC.TEST /* PUBLIC.PRIMARY_KEY_2: ID IN(1, 1000) */
+--> SELECT
+-->        TEST.ID
+-->    FROM PUBLIC.TEST
+-->        /* PUBLIC.PRIMARY_KEY_2: ID IN(1, 1000) */
 -->    WHERE ID IN(1, 1000)
 ;
 
@@ -236,9 +261,13 @@ INSERT INTO TEST SELECT X, MOD(X, 10) FROM SYSTEM_RANGE(1, 1000);
 
 -- Display the query plan
 EXPLAIN SELECT * FROM TEST WHERE ID IN (10, 20) AND DATA IN (1, 2);
---> SELECT TEST.ID, TEST.DATA
--->    FROM PUBLIC.TEST /* PUBLIC.PRIMARY_KEY_2: ID IN(10, 20) */
--->    WHERE (ID IN(10, 20)) AND (DATA IN(1, 2))
+--> SELECT
+-->        TEST.ID,
+-->        TEST.DATA
+-->    FROM PUBLIC.TEST
+-->        /* PUBLIC.PRIMARY_KEY_2: ID IN(10, 20) */
+-->    WHERE (ID IN(10, 20))
+-->        AND (DATA IN(1, 2))
 ;
 
 DROP TABLE TEST;

h2/src/test/org/h2/test/db/TestScript.java

@@ -259,7 +259,16 @@ public class TestScript extends TestBase {
         if (s == null) {
             return "null";
         }
-        return s.replace('\n', ' ');
+        s = s.replace('\n', ' ');
+        s = StringUtils.replaceAll(s, "    ", " ");
+        while (true) {
+            String s2 = StringUtils.replaceAll(s, "  ", " ");
+            if (s2.length() == s.length()) {
+                break;
+            }
+            s = s2;
+        }
+        return s;
     }
 
     private void writeResultSet(String sql, ResultSet rs) throws Exception {

h2/src/test/org/h2/test/test-1.3.txt

@@ -26,6 +26,12 @@ explain insert into test(id) direct sorted select x from system_range(1, 100);
 > INSERT INTO PUBLIC.TEST(ID) DIRECT SORTED SELECT X FROM SYSTEM_RANGE(1, 100) /* PUBLIC.RANGE_INDEX */
 > rows: 1
 
+explain select * from test limit 10 sample_size 10;
+> PLAN
+> -----------------------------------------------------------------------------------
+> SELECT TEST.ID FROM PUBLIC.TEST /* PUBLIC.TEST.tableScan */ LIMIT 10 SAMPLE_SIZE 10
+> rows: 1
+
 drop table test;
 > ok
 
@@ -462,7 +468,7 @@ create memory table test(id int);
 
 script nodata nopasswords nosettings;
 > SCRIPT
-> --------------------------------------------------
+> -----------------------------------------------
 > -- 0 +/- SELECT COUNT(*) FROM PUBLIC.TEST;
 > CREATE DOMAIN INT AS VARCHAR;
 > CREATE MEMORY TABLE PUBLIC.TEST( ID VARCHAR );
@@ -861,8 +867,8 @@ insert into t2 select x from system_range(1, 1000);
 
 explain select count(*) from t1 where t1.id in ( select t2.id from t2 );
 > PLAN
-> -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-> SELECT COUNT(*) FROM PUBLIC.T1 /* PUBLIC.PRIMARY_KEY_A: ID IN(SELECT DISTINCT T2.ID FROM PUBLIC.T2 /++ PUBLIC.T2.tableScan ++/) */ WHERE T1.ID IN(SELECT DISTINCT T2.ID FROM PUBLIC.T2 /* PUBLIC.T2.tableScan */)
+> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+> SELECT COUNT(*) FROM PUBLIC.T1 /* PUBLIC.PRIMARY_KEY_A: ID IN(SELECT DISTINCT T2.ID FROM PUBLIC.T2 /++ PUBLIC.T2.tableScan ++/) */ WHERE T1.ID IN( SELECT DISTINCT T2.ID FROM PUBLIC.T2 /* PUBLIC.T2.tableScan */)
 > rows: 1
 
 select count(*) from t1 where t1.id in ( select t2.id from t2 );
@@ -1215,8 +1221,8 @@ explain select * from (select dir_num, count(*) as cnt from multi_pages  t, b_ho
 where t.bh_id=bh.id and bh.site='Hello' group by dir_num) as x
 where cnt < 1000 order by dir_num asc;
 > PLAN
-> --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-> SELECT X.DIR_NUM, X.CNT FROM (SELECT DIR_NUM, COUNT(*) AS CNT FROM PUBLIC.MULTI_PAGES T /* PUBLIC.MULTI_PAGES.tableScan */ INNER JOIN PUBLIC.B_HOLDING BH /* PUBLIC.PRIMARY_KEY_3: ID = T.BH_ID */ ON 1=1 WHERE (BH.SITE = 'Hello') AND (T.BH_ID = BH.ID) GROUP BY DIR_NUM) X /* SELECT DIR_NUM, COUNT(*) AS CNT FROM PUBLIC.MULTI_PAGES T /++ PUBLIC.MULTI_PAGES.tableScan ++/ INNER JOIN PUBLIC.B_HOLDING BH /++ PUBLIC.PRIMARY_KEY_3: ID = T.BH_ID ++/ ON 1=1 WHERE (BH.SITE = 'Hello') AND (T.BH_ID = BH.ID) GROUP BY DIR_NUM HAVING COUNT(*) <= ?1: CNT < 1000 */ WHERE CNT < 1000 ORDER BY 1
+> ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+> SELECT X.DIR_NUM, X.CNT FROM ( SELECT DIR_NUM, COUNT(*) AS CNT FROM PUBLIC.MULTI_PAGES T /* PUBLIC.MULTI_PAGES.tableScan */ INNER JOIN PUBLIC.B_HOLDING BH /* PUBLIC.PRIMARY_KEY_3: ID = T.BH_ID */ ON 1=1 WHERE (BH.SITE = 'Hello') AND (T.BH_ID = BH.ID) GROUP BY DIR_NUM ) X /* SELECT DIR_NUM, COUNT(*) AS CNT FROM PUBLIC.MULTI_PAGES T /++ PUBLIC.MULTI_PAGES.tableScan ++/ INNER JOIN PUBLIC.B_HOLDING BH /++ PUBLIC.PRIMARY_KEY_3: ID = T.BH_ID ++/ ON 1=1 WHERE (BH.SITE = 'Hello') AND (T.BH_ID = BH.ID) GROUP BY DIR_NUM HAVING COUNT(*) <= ?1: CNT < 1000 */ WHERE CNT < 1000 ORDER BY 1
 > rows (ordered): 1
 
 select dir_num, count(*) as cnt from multi_pages  t, b_holding bh
@@ -2444,7 +2450,7 @@ insert into test values('AA');
 
 script nodata nopasswords nosettings;
 > SCRIPT
-> -------------------------------------------------------------------------------
+> ---------------------------------------------------------------------------
 > -- 2 +/- SELECT COUNT(*) FROM PUBLIC.TEST;
 > CREATE MEMORY TABLE PUBLIC.TEST( NAME VARCHAR CHECK (NAME = UPPER(NAME)) );
 > CREATE USER IF NOT EXISTS SA PASSWORD '' ADMIN;
@@ -2518,7 +2524,7 @@ select DOMAIN_NAME, COLUMN_DEFAULT, IS_NULLABLE, DATA_TYPE, PRECISION, SCALE, TY
 
 script nodata nopasswords nosettings;
 > SCRIPT
-> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 > -- 1 +/- SELECT COUNT(*) FROM PUBLIC.ADDRESS;
 > -- 1 +/- SELECT COUNT(*) FROM PUBLIC.TEST;
 > ALTER TABLE PUBLIC.ADDRESS ADD CONSTRAINT PUBLIC.CONSTRAINT_E PRIMARY KEY(ID);
@@ -2581,7 +2587,7 @@ create memory table a(k10 blob(10k), m20 blob(20m), g30 clob(30g));
 
 script NODATA NOPASSWORDS NOSETTINGS drop;
 > SCRIPT
-> -------------------------------------------------------------------------------------------------------
+> -------------------------------------------------------------------------------------------
 > -- 0 +/- SELECT COUNT(*) FROM PUBLIC.A;
 > CREATE MEMORY TABLE PUBLIC.A( K10 BLOB(10240), M20 BLOB(20971520), G30 CLOB(32212254720) );
 > CREATE USER IF NOT EXISTS SA PASSWORD '' ADMIN;
@@ -2988,8 +2994,8 @@ where exists (select 1 from test t4 where t2.id=t4.id);
 
 explain select * from test t1 where id in(select id from test t2 where t1.id=t2.id);
 > PLAN
-> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-> SELECT T1.ID, T1.NAME FROM PUBLIC.TEST T1 /* PUBLIC.TEST.tableScan */ WHERE ID IN(SELECT DISTINCT ID FROM PUBLIC.TEST T2 /* PUBLIC.PRIMARY_KEY_2: ID = T1.ID */ WHERE T1.ID = T2.ID)
+> -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+> SELECT T1.ID, T1.NAME FROM PUBLIC.TEST T1 /* PUBLIC.TEST.tableScan */ WHERE ID IN( SELECT DISTINCT ID FROM PUBLIC.TEST T2 /* PUBLIC.PRIMARY_KEY_2: ID = T1.ID */ WHERE T1.ID = T2.ID)
 > rows: 1
 
 select * from test t1 where id in(select id from test t2 where t1.id=t2.id);
@@ -3027,8 +3033,8 @@ select * from test t1 where id in(id);
 
 explain select * from test t1 where id in(select id from test);
 > PLAN
-> ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-> SELECT T1.ID, T1.NAME FROM PUBLIC.TEST T1 /* PUBLIC.PRIMARY_KEY_2: ID IN(SELECT DISTINCT ID FROM PUBLIC.TEST /++ PUBLIC.TEST.tableScan ++/) */ WHERE ID IN(SELECT DISTINCT ID FROM PUBLIC.TEST /* PUBLIC.TEST.tableScan */)
+> ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+> SELECT T1.ID, T1.NAME FROM PUBLIC.TEST T1 /* PUBLIC.PRIMARY_KEY_2: ID IN(SELECT DISTINCT ID FROM PUBLIC.TEST /++ PUBLIC.TEST.tableScan ++/) */ WHERE ID IN( SELECT DISTINCT ID FROM PUBLIC.TEST /* PUBLIC.TEST.tableScan */)
 > rows: 1
 
 select * from test t1 where id in(select id from test);
@@ -4259,7 +4265,7 @@ create sequence test_seq;
 
 script NODATA NOPASSWORDS NOSETTINGS drop;
 > SCRIPT
-> ------------------------------------------------------------------------------
+> ---------------------------------------------------------------------------
 > -- 0 +/- SELECT COUNT(*) FROM PUBLIC.TEST;
 > ALTER TABLE PUBLIC.TEST ADD CONSTRAINT PUBLIC.CONSTRAINT_2 PRIMARY KEY(ID);
 > CREATE MEMORY TABLE PUBLIC.TEST( ID INT NOT NULL, IM_IE VARCHAR(10) );
@@ -4947,7 +4953,7 @@ insert into test values(2, 'Cafe', X'cafe');
 
 script simple nopasswords nosettings;
 > SCRIPT
-> -------------------------------------------------------------------------------
+> ---------------------------------------------------------------------------
 > -- 3 +/- SELECT COUNT(*) FROM PUBLIC.TEST;
 > ALTER TABLE PUBLIC.TEST ADD CONSTRAINT PUBLIC.CONSTRAINT_2 PRIMARY KEY(ID);
 > CREATE MEMORY TABLE PUBLIC.TEST( ID INT NOT NULL, C CLOB, B BLOB );
@@ -5481,7 +5487,7 @@ SELECT * FROM TEST_SEQ ORDER BY ID;
 
 SCRIPT SIMPLE NOPASSWORDS NOSETTINGS;
 > SCRIPT
-> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+> --------------------------------------------------------------------------------------------------------------------------------------------------------------
 > -- 1 +/- SELECT COUNT(*) FROM PUBLIC.TEST;
 > -- 4 +/- SELECT COUNT(*) FROM PUBLIC.TEST_SEQ;
 > ALTER TABLE PUBLIC.TEST ADD CONSTRAINT PUBLIC.CONSTRAINT_2 PRIMARY KEY(ID);
@@ -5516,7 +5522,7 @@ DROP TABLE TEST_SEQ;
 
 SCRIPT NOPASSWORDS NOSETTINGS;
 > SCRIPT
-> ---------------------------------------------------------------------------------------------------------------------------------------------
+> ---------------------------------------------------------------------------------------------------------------------------------
 > -- 1 +/- SELECT COUNT(*) FROM PUBLIC.TEST;
 > ALTER TABLE PUBLIC.TEST ADD CONSTRAINT PUBLIC.CONSTRAINT_2 PRIMARY KEY(ID);
 > CREATE MEMORY TABLE PUBLIC.TEST( ID INT NOT NULL, CREATEDATE VARCHAR(255) DEFAULT '2001-01-01' NOT NULL, MODIFY_DATE TIMESTAMP );
@@ -5529,7 +5535,7 @@ ALTER TABLE TEST ADD NAME VARCHAR(255) NULL BEFORE CREATEDATE;
 
 SCRIPT NOPASSWORDS NOSETTINGS;
 > SCRIPT
-> --------------------------------------------------------------------------------------------------------------------------------------------------------------------
+> ----------------------------------------------------------------------------------------------------------------------------------------------------
 > -- 1 +/- SELECT COUNT(*) FROM PUBLIC.TEST;
 > ALTER TABLE PUBLIC.TEST ADD CONSTRAINT PUBLIC.CONSTRAINT_2 PRIMARY KEY(ID);
 > CREATE MEMORY TABLE PUBLIC.TEST( ID INT NOT NULL, NAME VARCHAR(255), CREATEDATE VARCHAR(255) DEFAULT '2001-01-01' NOT NULL, MODIFY_DATE TIMESTAMP );
@@ -5949,14 +5955,14 @@ EXPLAIN PLAN FOR SELECT * FROM TEST T1 WHERE ID IN(1, 2);
 
 EXPLAIN PLAN FOR SELECT * FROM TEST T1 WHERE ID IN(SELECT ID FROM TEST);
 > PLAN
-> ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-> SELECT T1.ID, T1.NAME FROM PUBLIC.TEST T1 /* PUBLIC.PRIMARY_KEY_2: ID IN(SELECT DISTINCT ID FROM PUBLIC.TEST /++ PUBLIC.TEST.tableScan ++/) */ WHERE ID IN(SELECT DISTINCT ID FROM PUBLIC.TEST /* PUBLIC.TEST.tableScan */)
+> ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+> SELECT T1.ID, T1.NAME FROM PUBLIC.TEST T1 /* PUBLIC.PRIMARY_KEY_2: ID IN(SELECT DISTINCT ID FROM PUBLIC.TEST /++ PUBLIC.TEST.tableScan ++/) */ WHERE ID IN( SELECT DISTINCT ID FROM PUBLIC.TEST /* PUBLIC.TEST.tableScan */)
 > rows: 1
 
 EXPLAIN PLAN FOR SELECT * FROM TEST T1 WHERE ID NOT IN(SELECT ID FROM TEST);
 > PLAN
-> --------------------------------------------------------------------------------------------------------------------------------------------------------
-> SELECT T1.ID, T1.NAME FROM PUBLIC.TEST T1 /* PUBLIC.TEST.tableScan */ WHERE NOT (ID IN(SELECT DISTINCT ID FROM PUBLIC.TEST /* PUBLIC.TEST.tableScan */))
+> ---------------------------------------------------------------------------------------------------------------------------------------------------------
+> SELECT T1.ID, T1.NAME FROM PUBLIC.TEST T1 /* PUBLIC.TEST.tableScan */ WHERE NOT (ID IN( SELECT DISTINCT ID FROM PUBLIC.TEST /* PUBLIC.TEST.tableScan */))
 > rows: 1
 
 EXPLAIN PLAN FOR SELECT CAST(ID AS VARCHAR(255)) FROM TEST;
@@ -8472,7 +8478,7 @@ ALTER INDEX IDX_ID RENAME TO IDX_ID2;
 
 SCRIPT NOPASSWORDS NOSETTINGS;
 > SCRIPT
-> ------------------------------------------------------------------------------
+> ---------------------------------------------------------------------------
 > -- 0 +/- SELECT COUNT(*) FROM PUBLIC.TEST2;
 > -- 0 +/- SELECT COUNT(*) FROM PUBLIC.TEST;
 > ALTER TABLE PUBLIC.TEST ADD CONSTRAINT PUBLIC.CONSTRAINT_2 PRIMARY KEY(ID);
@@ -9021,7 +9027,7 @@ select ltrim(null) en, '>' || ltrim('a') || '<' ea, '>' || ltrim(' a ') || '<' e
 
 select TRIM(BOTH '_' FROM '__A__') A, TRIM(LEADING FROM '    B    ') BS, TRIM(TRAILING 'x' FROM 'xAx') XA from test;
 > A BS XA
-> - ----- --
+> - -- --
 > A B  xA
 > rows: 1
 
@@ -9067,7 +9073,7 @@ soundex('VanDeusen') V532, soundex('Ashcraft') A261 from test;
 
 select space(null) en, '>' || space(1) || '<' es, '>' || space(3) || '<' e2 from test;
 > EN   ES  E2
-> ---- --- -----
+> ---- --- ---
 > null > < > <
 > rows: 1