Merge branch 'master' of https://github.com/h2database/h2database into Issue#589

h2/src/main/org/h2/command/Parser.java

@@ -76,6 +76,7 @@ import org.h2.command.dml.ExecuteProcedure;
 import org.h2.command.dml.Explain;
 import org.h2.command.dml.Insert;
 import org.h2.command.dml.Merge;
+import org.h2.command.dml.MergeUsing;
 import org.h2.command.dml.NoOperation;
 import org.h2.command.dml.Query;
 import org.h2.command.dml.Replace;
@@ -845,6 +846,11 @@ public class Parser {
         }
         TableFilter filter = readSimpleTableFilter(0);
         command.setTableFilter(filter);
+        parseDeleteGivenTable(command, limit, start);
+        return command;
+    }
+
+    private void parseDeleteGivenTable(Delete command, Expression limit, int start) {
         if (readIf("WHERE")) {
             Expression condition = readExpression();
             command.setCondition(condition);
@@ -854,7 +860,6 @@ public class Parser {
         }
         command.setLimit(limit);
         setSQL(command, "DELETE", start);
-        return command;
     }
 
     private IndexColumn[] parseIndexColumnList() {
@@ -1098,17 +1103,31 @@ public class Parser {
            table_reference ::= table / view / sub-query
      */
     /* TODO Finish coding*/
-    private Merge parseMergeUsing(Merge command) {
+    private MergeUsing parseMergeUsing(Merge oldCommand) {        
+        MergeUsing command = new MergeUsing(oldCommand);
+        
         if (readIf("(")) {
             if (isSelect()) {
                 command.setQuery(parseSelect());
                 read(")");
             }
+            command.setQueryAlias(readFromAlias(null, Arrays.asList("ON")));
         }
         else{
             List<String> excludeIdentifiers = Arrays.asList("ON");
             TableFilter sourceTableFilter = readSimpleTableFilterWithAliasExcludes(0,excludeIdentifiers);
             command.setSourceTableFilter(sourceTableFilter);  
+            
+            StringBuilder buff = new StringBuilder(
+                    "SELECT * FROM "+sourceTableFilter.getTable().getName());
+            if(sourceTableFilter.getTableAlias()!=null){
+                buff.append(" AS "+sourceTableFilter.getTableAlias());
+            }
+            //ArrayList<Value> paramValues = New.arrayList();
+            Prepared preparedQuery = prepare(session, buff.toString(), null/*paramValues*/);
+            System.out.println("class="+preparedQuery.getClass());
+            command.setQuery((Select)preparedQuery);
+            
         }        
         read("ON");
         read("(");
@@ -1123,22 +1142,26 @@ public class Parser {
                 TableFilter filter = command.getTargetTableFilter();
                 updateCommand.setTableFilter(filter);
                 parseUpdateSetClause(updateCommand, filter);
-                command.setUpdateOrDeleteCommand(updateCommand);
+                command.setUpdateCommand(updateCommand);
             }
             if (readIf("DELETE")){
                 Delete deleteCommand = new Delete(session);
                 TableFilter filter = command.getTargetTableFilter();
                 deleteCommand.setTableFilter(filter);
-                command.setUpdateOrDeleteCommand(deleteCommand);
+                parseDeleteGivenTable(deleteCommand,null,lastParseIndex);
+                command.setDeleteCommand(deleteCommand);
             }
    
+            
         }
         if(readIf("WHEN")&&readIf("NOT")&&readIf("MATCHED")&&readIf("THEN")){
+            if (readIf("INSERT")){
                 Insert insertCommand = new Insert(session);
                 insertCommand.setTable(command.getTargetTable());
                 parseInsertGivenTable(insertCommand,command.getTargetTable());
                 command.setInsertCommand(insertCommand);
             }
+        }
 
         return command;
     }
@@ -1380,6 +1403,10 @@ public class Parser {
                 }
             }
         }
+        // inherit alias for temporary views (usually CTE's) from table name
+        if(table.isView() && table.isTemporary() && alias==null){
+            alias = table.getName();
+        }
         return new TableFilter(session, table, alias, rightsChecked,
                 currentSelect, orderInFrom++, indexHints);
     }
@@ -1401,19 +1428,22 @@ public class Parser {
         return IndexHints.createUseIndexHints(indexNames);
     }
 
-    private String readFromAlias(String alias) {
+    private String readFromAlias(String alias, List<String> excludeIdentifiers) {
         if (readIf("AS")) {
             alias = readAliasIdentifier();
-        } else if (currentTokenType == IDENTIFIER) {
-            // left and right are not keywords (because they are functions as
-            // well)
-            if (!isToken("LEFT") && !isToken("RIGHT") && !isToken("FULL")) {
+        } else if (currentTokenType == IDENTIFIER && !excludeIdentifiers.contains(currentToken)) {
                 alias = readAliasIdentifier();
         }
-        }
         return alias;
     }
     
+    private String readFromAlias(String alias) {
+        // left and right are not keywords (because they are functions as
+        // well)
+        List<String> excludeIdentifiers = Arrays.asList("LEFT","RIGHT","FULL");;
+        return readFromAlias(alias, excludeIdentifiers);
+    }
+
     private Prepared parseTruncate() {
         read("TABLE");
         Table table = readTableOrView();

h2/src/main/org/h2/command/Prepared.java

@@ -454,4 +454,8 @@ public abstract class Prepared {
     public void setCteCleanups(List<TableView> cteCleanups) {
         this.cteCleanups = cteCleanups;
     }
+
+    public Session getSession() {
+        return session;
+    }
 }

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

@@ -33,17 +33,13 @@ import org.h2.value.Value;
  */
 public class Merge extends Prepared {
 
-    private Table targetTable;
-    private TableFilter targetTableFilter;
-    private Column[] columns;
-    private Column[] keys;
-    private final ArrayList<Expression[]> valuesExpressionList = New.arrayList();
-    private Query query;
-    private Prepared update;
-    private TableFilter sourceTableFilter;
-    private ArrayList<Expression> conditions = new ArrayList<Expression>();
-    private Prepared updateOrDeleteCommand;
-    private Insert insertCommand;
+    protected Table targetTable;
+    protected TableFilter targetTableFilter;
+    protected Column[] columns;
+    protected Column[] keys;
+    protected final ArrayList<Expression[]> valuesExpressionList = New.arrayList();
+    protected Query query;
+    protected Prepared update;
 
     public Merge(Session session) {
         super(session);
@@ -141,7 +137,7 @@ public class Merge extends Prepared {
         return count;
     }
 
-    private void merge(Row row) {
+    protected void merge(Row row) {
         ArrayList<Parameter> k = update.getParameters();
         for (int i = 0; i < columns.length; i++) {
             Column col = columns[i];
@@ -316,14 +312,6 @@ public class Merge extends Prepared {
         return true;
     }
 
-    public void setSourceTableFilter(TableFilter sourceTableFilter) {
-        this.sourceTableFilter = sourceTableFilter;        
-    }
-
-    public void addCondition(Expression condition) {
-        this.conditions .add(condition);        
-    }
-
     public Table getTargetTable() {
         return targetTable;
     }
@@ -337,20 +325,6 @@ public class Merge extends Prepared {
         setTargetTable(targetTableFilter.getTable());
     }
 
-    public Prepared getUpdateOrDeleteCommand() {
-        return updateOrDeleteCommand;
-    }
-
-    public void setUpdateOrDeleteCommand(Prepared updateOrDelete) {
-        this.updateOrDeleteCommand = updateOrDelete;
-    }
 
-    public Insert getInsertCommand() {
-        return insertCommand;
-    }
-
-    public void setInsertCommand(Insert insertCommand) {
-        this.insertCommand = insertCommand;
-    }
 
 }

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

@@ -40,6 +40,7 @@ public class TestGeneralCommonTableQueries extends TestBase {
         testDelete();
         testMerge();
         testCreateTable();
+        testNestedSQL();
     }
 
     private void testSimpleSelect() throws Exception {
@@ -388,4 +389,53 @@ public class TestGeneralCommonTableQueries extends TestBase {
         conn.close();
         deleteDb("commonTableExpressionQueries");
     }
+    
+    private void testNestedSQL() throws Exception {
+        deleteDb("commonTableExpressionQueries");
+        Connection conn = getConnection("commonTableExpressionQueries");
+        PreparedStatement prep;
+        ResultSet rs;
+
+        prep = conn.prepareStatement(
+            "WITH T1 AS (                        "+
+            "        SELECT *                    "+
+            "        FROM TABLE (                "+
+            "            K VARCHAR = ('a', 'b'), "+
+            "            V INTEGER = (1, 2)      "+
+            "    )                               "+
+            "),                                  "+
+            "                                    "+
+            "                                    "+
+            "T2 AS (                             "+
+            "        SELECT *                    "+
+            "        FROM TABLE (                "+
+            "            K VARCHAR = ('a', 'b'), "+
+            "            V INTEGER = (3, 4)      "+
+            "    )                               "+
+            "),                                  "+
+            "                                    "+
+            "                                    "+
+            "JOIN_CTE AS (                       "+
+            "    SELECT T1.*                     "+
+            "                                    "+
+            "    FROM                            "+
+            "        T1                          "+
+            "        JOIN T2 ON (                "+
+            "            T1.K = T2.K             "+
+            "        )                           "+
+            ")                                   "+
+            "                                    "+
+            "SELECT * FROM JOIN_CTE");
+
+        rs = prep.executeQuery();
+
+        for (String keyLetter : new String[] { "a", "b" }) {
+            assertTrue(rs.next());
+            assertContains("ab",rs.getString(1));
+            assertEquals(rs.getString(1),keyLetter);
+            assertTrue(rs.getInt(2)!=0);
+        }
+        conn.close();
+        deleteDb("commonTableExpressionQueries");
+    }    
 }
\ No newline at end of file

h2/src/test/org/h2/test/testScript.sql

@@ -10333,8 +10333,8 @@ explain with recursive r(n) as (
 )
 select n from r;
 > PLAN
-> -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-> WITH RECURSIVE R(N) AS ( (SELECT 1 FROM SYSTEM_RANGE(1, 1) /* PUBLIC.RANGE_INDEX */) UNION ALL (SELECT (N + 1) FROM PUBLIC.R /* PUBLIC.R.tableScan */ WHERE N < 3) ) SELECT N FROM R /* null */
+> -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+> WITH RECURSIVE R(N) AS ( (SELECT 1 FROM SYSTEM_RANGE(1, 1) /* PUBLIC.RANGE_INDEX */) UNION ALL (SELECT (N + 1) FROM PUBLIC.R /* PUBLIC.R.tableScan */ WHERE N < 3) ) SELECT N FROM R R /* null */
 > rows: 1
 
 select sum(n) from (