diff --git a/build.gradle b/build.gradle
index 4fc6803e7..1f4c35ba0 100644
--- a/build.gradle
+++ b/build.gradle
@@ -68,7 +68,7 @@ jacocoTestCoverageVerification {
     violationRules {
         rule {
             limit {
-                minimum = 0.840
+                minimum = 0.837
             }
         }
     }
diff --git a/src/main/java/net/sf/jsqlparser/statement/update/Update.java b/src/main/java/net/sf/jsqlparser/statement/update/Update.java
index aebdf125f..8ead3c838 100644
--- a/src/main/java/net/sf/jsqlparser/statement/update/Update.java
+++ b/src/main/java/net/sf/jsqlparser/statement/update/Update.java
@@ -21,14 +21,7 @@
 import net.sf.jsqlparser.schema.Table;
 import net.sf.jsqlparser.statement.Statement;
 import net.sf.jsqlparser.statement.StatementVisitor;
-import net.sf.jsqlparser.statement.select.FromItem;
-import net.sf.jsqlparser.statement.select.Join;
-import net.sf.jsqlparser.statement.select.Limit;
-import net.sf.jsqlparser.statement.select.OrderByElement;
-import net.sf.jsqlparser.statement.select.PlainSelect;
-import net.sf.jsqlparser.statement.select.Select;
-import net.sf.jsqlparser.statement.select.SelectExpressionItem;
-import net.sf.jsqlparser.statement.select.WithItem;
+import net.sf.jsqlparser.statement.select.*;
 
 @SuppressWarnings({"PMD.CyclomaticComplexity"})
 public class Update implements Statement {
@@ -36,20 +29,20 @@ public class Update implements Statement {
     private List<WithItem> withItemsList;
     private Table table;
     private Expression where;
-    private List<Column> columns;
-    private List<Expression> expressions;
+    private final ArrayList<UpdateSet> updateSets = new ArrayList<>();
     private FromItem fromItem;
     private List<Join> joins;
     private List<Join> startJoins;
-    private Select select;
-    private boolean useColumnsBrackets = true;
-    private boolean useSelect = false;
     private OracleHint oracleHint = null;
     private List<OrderByElement> orderByElements;
     private Limit limit;
     private boolean returningAllColumns = false;
     private List<SelectExpressionItem> returningExpressionList = null;
 
+    public ArrayList<UpdateSet> getUpdateSets() {
+        return updateSets;
+    }
+
     @Override
     public void accept(StatementVisitor statementVisitor) {
         statementVisitor.visit(this);
@@ -104,20 +97,37 @@ public void setOracleHint(OracleHint oracleHint) {
         this.oracleHint = oracleHint;
     }
 
+    public void addUpdateSet(Column column, Expression expression) {
+        updateSets.add(new UpdateSet(column, expression));
+    }
+
+    public void addUpdateSet(UpdateSet updateSet) {
+        updateSets.add(updateSet);
+    }
+
+    @Deprecated
     public List<Column> getColumns() {
-        return columns;
+        return updateSets.get(0).columns;
     }
 
+    @Deprecated
     public List<Expression> getExpressions() {
-        return expressions;
+        return updateSets.get(0).expressions;
     }
 
+    @Deprecated
     public void setColumns(List<Column> list) {
-        columns = list;
+        if (updateSets.isEmpty()) {
+            updateSets.add(new UpdateSet());
+        }
+        updateSets.get(0).columns.clear();
+        updateSets.get(0).columns.addAll(list);
     }
 
+    @Deprecated
     public void setExpressions(List<Expression> list) {
-        expressions = list;
+        updateSets.get(0).expressions.clear();
+        updateSets.get(0).expressions.addAll(list);
     }
 
     public FromItem getFromItem() {
@@ -144,28 +154,49 @@ public void setStartJoins(List<Join> startJoins) {
         this.startJoins = startJoins;
     }
 
+    @Deprecated
     public Select getSelect() {
+        Select select = null;
+        if (updateSets.get(0).expressions.get(0) instanceof SubSelect) {
+            SubSelect subSelect = (SubSelect) updateSets.get(0).expressions.get(0);
+            select = new Select().withWithItemsList(subSelect.getWithItemsList()).withSelectBody(subSelect.getSelectBody());
+        }
+
         return select;
     }
 
+    @Deprecated
     public void setSelect(Select select) {
-        this.select = select;
+        if (select!=null) {
+            SubSelect subSelect = new SubSelect().withSelectBody(select.getSelectBody());
+            if (select.getWithItemsList() != null && select.getWithItemsList().size() > 0)
+                subSelect.setWithItemsList(select.getWithItemsList());
+
+            if (updateSets.get(0).expressions.isEmpty()) {
+                updateSets.get(0).expressions.add(subSelect);
+            } else {
+                updateSets.get(0).expressions.set(0, subSelect);
+            }
+        }
     }
 
+    @Deprecated
     public boolean isUseColumnsBrackets() {
-        return useColumnsBrackets;
+        return updateSets.get(0).usingBrackets;
     }
 
+    @Deprecated
     public void setUseColumnsBrackets(boolean useColumnsBrackets) {
-        this.useColumnsBrackets = useColumnsBrackets;
+        updateSets.get(0).usingBrackets = useColumnsBrackets;
     }
 
+    @Deprecated
     public boolean isUseSelect() {
-        return useSelect;
+        return (updateSets.get(0).expressions.get(0) instanceof SubSelect);
     }
 
+    @Deprecated
     public void setUseSelect(boolean useSelect) {
-        this.useSelect = useSelect;
     }
 
     public void setOrderByElements(List<OrderByElement> orderByElements) {
@@ -201,7 +232,7 @@ public void setReturningExpressionList(List<SelectExpressionItem> returningExpre
     }
 
     @Override
-    @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"})
+    @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity", "PMD.ExcessiveMethodLength"})
     public String toString() {
         StringBuilder b = new StringBuilder();
 
@@ -229,31 +260,64 @@ public String toString() {
         }
         b.append(" SET ");
 
-        if (!useSelect) {
-            for (int i = 0; i < getColumns().size(); i++) {
-                if (i != 0) {
-                    b.append(", ");
-                }
-                b.append(columns.get(i)).append(" = ");
-                b.append(expressions.get(i));
+        int j=0;
+        for (UpdateSet updateSet:updateSets) {
+            if (j > 0) {
+                b.append(", ");
             }
-        } else {
-            if (useColumnsBrackets) {
+
+            if (updateSet.usingBrackets) {
                 b.append("(");
             }
-            for (int i = 0; i < getColumns().size(); i++) {
-                if (i != 0) {
+
+            for (int i = 0; i < updateSet.columns.size(); i++) {
+                if (i > 0) {
                     b.append(", ");
                 }
-                b.append(columns.get(i));
+                b.append(updateSet.columns.get(i));
             }
-            if (useColumnsBrackets) {
+
+            if (updateSet.usingBrackets) {
                 b.append(")");
             }
+
             b.append(" = ");
-            b.append("(").append(select).append(")");
+
+            for (int i = 0; i < updateSet.expressions.size(); i++) {
+                if (i > 0) {
+                    b.append(", ");
+                }
+                b.append(updateSet.expressions.get(i));
+            }
+
+            j++;
         }
 
+//        if (!useSelect) {
+//            for (int i = 0; i < getColumns().size(); i++) {
+//                if (i != 0) {
+//                    b.append(", ");
+//                }
+//                b.append(columns.get(i)).append(" = ");
+//                b.append(expressions.get(i));
+//            }
+//        } else {
+//            if (useColumnsBrackets) {
+//                b.append("(");
+//            }
+//            for (int i = 0; i < getColumns().size(); i++) {
+//                if (i != 0) {
+//                    b.append(", ");
+//                }
+//                b.append(columns.get(i));
+//            }
+//            if (useColumnsBrackets) {
+//                b.append(")");
+//            }
+//            b.append(" = ");
+//            b.append("(").append(select).append(")");
+//        }
+
         if (fromItem != null) {
             b.append(" FROM ").append(fromItem);
             if (joins != null) {
diff --git a/src/main/java/net/sf/jsqlparser/statement/update/UpdateSet.java b/src/main/java/net/sf/jsqlparser/statement/update/UpdateSet.java
new file mode 100644
index 000000000..e90cb863b
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/statement/update/UpdateSet.java
@@ -0,0 +1,64 @@
+package net.sf.jsqlparser.statement.update;
+
+import net.sf.jsqlparser.expression.Expression;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
+import net.sf.jsqlparser.schema.Column;
+
+import java.util.ArrayList;
+import java.util.Objects;
+
+public class UpdateSet {
+    protected boolean usingBrackets = false;
+    protected ArrayList<Column> columns = new ArrayList<>();
+    protected ArrayList<Expression> expressions = new ArrayList<>();
+
+    public UpdateSet() {
+
+    }
+
+    public UpdateSet(Column column) {
+        this.columns.add(column);
+    }
+
+    public UpdateSet(Column column, Expression expression) {
+        this.columns.add(column);
+        this.expressions.add(expression);
+    }
+
+    public boolean isUsingBrackets() {
+        return usingBrackets;
+    }
+
+    public void setUsingBrackets(boolean usingBrackets) {
+        this.usingBrackets = usingBrackets;
+    }
+
+    public ArrayList<Column> getColumns() {
+        return columns;
+    }
+
+    public void setColumns(ArrayList<Column> columns) {
+        this.columns = Objects.requireNonNull(columns);
+    }
+
+    public ArrayList<Expression> getExpressions() {
+        return expressions;
+    }
+
+    public void setExpressions(ArrayList<Expression> expressions) {
+        this.expressions = Objects.requireNonNull(expressions);
+    }
+
+    public void add(Column column, Expression expression) {
+        columns.add(column);
+        expressions.add(expression);
+    };
+
+    public void add(Column column) {
+        columns.add(column);
+    };
+
+    public void add(ExpressionList expressionList) {
+        expressions.addAll(expressionList.getExpressions());
+    };
+}
diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/UpdateDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/UpdateDeParser.java
index 66a962579..3692ee011 100644
--- a/src/main/java/net/sf/jsqlparser/util/deparser/UpdateDeParser.java
+++ b/src/main/java/net/sf/jsqlparser/util/deparser/UpdateDeParser.java
@@ -11,24 +11,20 @@
 
 import java.util.Iterator;
 
-import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.ExpressionVisitor;
 import net.sf.jsqlparser.expression.ExpressionVisitorAdapter;
-import net.sf.jsqlparser.schema.Column;
 import net.sf.jsqlparser.statement.select.Join;
 import net.sf.jsqlparser.statement.select.OrderByElement;
 import net.sf.jsqlparser.statement.select.OrderByVisitor;
-import net.sf.jsqlparser.statement.select.Select;
 import net.sf.jsqlparser.statement.select.SelectExpressionItem;
 import net.sf.jsqlparser.statement.select.SelectVisitor;
-import net.sf.jsqlparser.statement.select.SelectVisitorAdapter;
 import net.sf.jsqlparser.statement.select.WithItem;
 import net.sf.jsqlparser.statement.update.Update;
+import net.sf.jsqlparser.statement.update.UpdateSet;
 
 public class UpdateDeParser extends AbstractDeParser<Update> implements OrderByVisitor {
 
     private ExpressionVisitor expressionVisitor = new ExpressionVisitorAdapter();
-    private SelectVisitor selectVisitor = new SelectVisitorAdapter();
 
     public UpdateDeParser() {
         super(new StringBuilder());
@@ -37,11 +33,10 @@ public UpdateDeParser() {
     public UpdateDeParser(ExpressionVisitor expressionVisitor, SelectVisitor selectVisitor, StringBuilder buffer) {
         super(buffer);
         this.expressionVisitor = expressionVisitor;
-        this.selectVisitor = selectVisitor;
     }
 
     @Override
-    @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"})
+    @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity", "PMD.ExcessiveMethodLength"})
     public void deParse(Update update) {
          if (update.getWithItemsList() != null && !update.getWithItemsList().isEmpty()) {
             buffer.append("WITH ");
@@ -66,40 +61,71 @@ public void deParse(Update update) {
         }
         buffer.append(" SET ");
 
-        if (!update.isUseSelect()) {
-            for (int i = 0; i < update.getColumns().size(); i++) {
-                Column column = update.getColumns().get(i);
-                column.accept(expressionVisitor);
-
-                buffer.append(" = ");
-
-                Expression expression = update.getExpressions().get(i);
-                expression.accept(expressionVisitor);
-                if (i < update.getColumns().size() - 1) {
-                    buffer.append(", ");
-                }
+        int j=0;
+        for (UpdateSet updateSet:update.getUpdateSets()) {
+            if (j > 0) {
+                buffer.append(", ");
             }
-        } else {
-            if (update.isUseColumnsBrackets()) {
+
+            if (updateSet.isUsingBrackets()) {
                 buffer.append("(");
             }
-            for (int i = 0; i < update.getColumns().size(); i++) {
-                if (i != 0) {
+            for (int i = 0; i < updateSet.getColumns().size(); i++) {
+                if (i > 0) {
                     buffer.append(", ");
                 }
-                Column column = update.getColumns().get(i);
-                column.accept(expressionVisitor);
+                updateSet.getColumns().get(i).accept(expressionVisitor);
             }
-            if (update.isUseColumnsBrackets()) {
+            if (updateSet.isUsingBrackets()) {
                 buffer.append(")");
             }
+
             buffer.append(" = ");
-            buffer.append("(");
-            Select select = update.getSelect();
-            select.getSelectBody().accept(selectVisitor);
-            buffer.append(")");
+
+            for (int i = 0; i < updateSet.getExpressions().size(); i++) {
+                if (i > 0) {
+                    buffer.append(", ");
+                }
+                updateSet.getExpressions().get(i).accept(expressionVisitor);
+            }
+
+            j++;
         }
 
+//        if (!update.isUseSelect()) {
+//            for (int i = 0; i < update.getColumns().size(); i++) {
+//                Column column = update.getColumns().get(i);
+//                column.accept(expressionVisitor);
+//
+//                buffer.append(" = ");
+//
+//                Expression expression = update.getExpressions().get(i);
+//                expression.accept(expressionVisitor);
+//                if (i < update.getColumns().size() - 1) {
+//                    buffer.append(", ");
+//                }
+//            }
+//        } else {
+//            if (update.isUseColumnsBrackets()) {
+//                buffer.append("(");
+//            }
+//            for (int i = 0; i < update.getColumns().size(); i++) {
+//                if (i != 0) {
+//                    buffer.append(", ");
+//                }
+//                Column column = update.getColumns().get(i);
+//                column.accept(expressionVisitor);
+//            }
+//            if (update.isUseColumnsBrackets()) {
+//                buffer.append(")");
+//            }
+//            buffer.append(" = ");
+//            buffer.append("(");
+//            Select select = update.getSelect();
+//            select.getSelectBody().accept(selectVisitor);
+//            buffer.append(")");
+//        }
+
         if (update.getFromItem() != null) {
             buffer.append(" FROM ").append(update.getFromItem());
             if (update.getJoins() != null) {
diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
index 55a36f115..918ac7d2a 100644
--- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
+++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
@@ -1111,14 +1111,14 @@ Update Update( List<WithItem> with ):
     Update update = new Update();
     Table table = null;
     List<Join> startJoins = null;
-    Expression where = null;
+
+    UpdateSet updateSet = null;
     Column tableColumn = null;
-    List<Expression> expList = new ArrayList<Expression>();
-    List<Column> columns = new ArrayList<Column>();
-    Expression value = null;
+    Expression valueExpression = null;
+    ExpressionList expressionList;
+    Expression where = null;
     FromItem fromItem = null;
     List<Join> joins = null;
-    Select select = null;
     Limit limit = null;
     List<OrderByElement> orderByElements;
     boolean useColumnsBrackets = false;
@@ -1130,21 +1130,34 @@ Update Update( List<WithItem> with ):
 
     <K_SET>
     (
-    LOOKAHEAD(3) tableColumn=Column() "=" value=SimpleExpression() { columns.add(tableColumn); expList.add(value); }
-        ("," tableColumn=Column() "=" value=SimpleExpression() { columns.add(tableColumn); expList.add(value); } )*
+         LOOKAHEAD(3) (
+            tableColumn=Column() "=" valueExpression=SimpleExpression() { update.addUpdateSet(tableColumn, valueExpression); }
+            ("," tableColumn=Column() "=" valueExpression=SimpleExpression() { update.addUpdateSet(tableColumn, valueExpression); } )*
+        )
+        |
+        (
+            { updateSet = new UpdateSet(); update.addUpdateSet(updateSet); }
 
-    |
+            [ "(" { updateSet.setUsingBrackets(true); } ]
+            tableColumn=Column() { updateSet.add(tableColumn); }
+            ("," tableColumn=Column() { updateSet.add(tableColumn); } )*
+            [ ")" ]
 
-    ( "(" { useColumnsBrackets = true; } tableColumn=Column() { columns.add(tableColumn); } ("," tableColumn=Column() { columns.add(tableColumn); } )* ")"
-    | tableColumn=Column() { columns.add(tableColumn); } ("," tableColumn=Column() { columns.add(tableColumn); } )* )
-     "="
-        "("
-        (
-            { update.setUseSelect(true); }
-            select = SelectWithWithItems( )
+            "="
+
+            expressionList = ComplexExpressionList() { updateSet.add(expressionList); }
+            (
+                ","
+                tableColumn=Column() { updateSet = new UpdateSet(tableColumn); update.addUpdateSet(updateSet); }
+                ("," tableColumn=Column() { updateSet.add(tableColumn); } )*
+
+                "="
+                "("
+                expressionList = ComplexExpressionList() { updateSet.add(expressionList); }
+                ")"
+            ) *
         )
-        ")"
-   )
+    )
 
    [ <K_FROM>
       fromItem=FromItem()
@@ -1162,14 +1175,10 @@ Update Update( List<WithItem> with ):
 
    {
         return update.withWithItemsList(with)
-              .withColumns(columns)
-        	  .withExpressions(expList)
               .withTable(table)
               .withStartJoins(startJoins)
               .withFromItem(fromItem)
               .withJoins(joins)
-              .withSelect(select)
-              .withUseColumnsBrackets(useColumnsBrackets)
               .withReturningExpressionList(returning);
    }
 }
@@ -2616,12 +2625,9 @@ GroupByElement GroupByColumnReferences():
                     | expr = SimpleExpression() { groupBy.addGroupingSet(expr); } ) )*
             ")"
           )
-          | LOOKAHEAD(3) (
-              "(" list = SimpleExpressionList(true)  ")" { groupBy.setGroupByExpressionList(list); }
-          )
           |
           LOOKAHEAD(2) (  
-            list = SimpleExpressionList(false) { groupBy.setGroupByExpressionList(list); }
+            list = ComplexExpressionList() { groupBy.setGroupByExpressionList(list.withUsingBrackets(false)); }
           )
     )
     {
@@ -3285,13 +3291,15 @@ ExpressionList ComplexExpressionList() #ExpressionList:
         LOOKAHEAD(2) expr=OracleNamedFunctionParameter()
         | expr=Expression() 
     ) { expressions.add(expr); }
+
     (
-        "," 
-        (   
+        LOOKAHEAD(2) ","
+        (
             LOOKAHEAD(2) expr=OracleNamedFunctionParameter()
             | expr=Expression() 
         ) { expressions.add(expr); }
     )*
+
     {
         retval.setExpressions(expressions);
         return retval;
@@ -4264,7 +4272,7 @@ Expression CaseWhenExpression() #CaseWhenExpression:
     <K_CASE> { caseCounter++; }
     [ switchExp=Condition() ]
     ( clause=WhenThenSearchCondition() { whenClauses.add(clause); } )+
-    [<K_ELSE> (LOOKAHEAD( ["("] CaseWhenExpression() [")"] ) ["("] elseExp=CaseWhenExpression() [")" { ((CaseExpression) elseExp).setUsingBrackets(true); } ] 
+    [<K_ELSE> (LOOKAHEAD( ["("] CaseWhenExpression() [")"] ( <K_WHEN> | <K_ELSE> | <K_END> ) ) ["("] elseExp=CaseWhenExpression() [")" { ((CaseExpression) elseExp).setUsingBrackets(true); } ] 
               | elseExp=Condition()
               )
     ]
@@ -4285,8 +4293,10 @@ WhenClause WhenThenSearchCondition():
 }
 {
     <K_WHEN> whenExp=Expression()
-    <K_THEN> (LOOKAHEAD( ["("] CaseWhenExpression() [")"] ) ["("] thenExp=CaseWhenExpression() [")" { ((CaseExpression) thenExp).setUsingBrackets(true); }]
-              | thenExp=Expression()
+    <K_THEN> (
+                LOOKAHEAD( ["("] CaseWhenExpression() [")"] ( <K_WHEN> | <K_ELSE> | <K_END> ) ) ["("] thenExp=CaseWhenExpression() [")" { ((CaseExpression) thenExp).setUsingBrackets(true); }]
+                | 
+                thenExp=Expression()
               )
     {
        whenThen.setWhenExpression(whenExp);
diff --git a/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java b/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java
index adc4a8f3d..e5c5bc581 100644
--- a/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java
+++ b/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java
@@ -4701,6 +4701,7 @@ public void testCastToRowConstructorIssue1267() throws JSQLParserException {
         assertSqlCanBeParsedAndDeparsed(sqlStr, true);
     }
   
+    @Test
     public void testCollisionWithSpecialStringFunctionsIssue1284() throws JSQLParserException {
         assertSqlCanBeParsedAndDeparsed(
           "SELECT test( a in (1) AND 2=2) ", true);
@@ -4715,4 +4716,64 @@ public void testCollisionWithSpecialStringFunctionsIssue1284() throws JSQLParser
             "recv_time >= toDateTime('2021-07-20 00:00:00')\n" +
             "and recv_time < toDateTime('2021-07-21 00:00:00')", true);
     }
+    
+    @Test
+    public void testNestedCaseComplexExpressionIssue1306() throws JSQLParserException {
+        // with extra brackets
+        assertSqlCanBeParsedAndDeparsed(
+            "SELECT CASE\n" +
+            "WHEN 'USD' = 'USD'\n" +
+            "THEN 0\n" +
+            "ELSE CASE\n" +
+            "WHEN 'USD' = 'EURO'\n" +
+            "THEN ( CASE\n" +
+            "WHEN 'A' = 'B'\n" +
+            "THEN 0\n" +
+            "ELSE 1\n" +
+            "END * 100 )\n" +
+            "ELSE 2\n" +
+            "END\n" +
+            "END AS \"column1\"\n" +
+            "FROM test_schema.table_name\n" +
+            "", true);
+        
+        // without brackets
+        assertSqlCanBeParsedAndDeparsed(
+            "SELECT CASE\n" +
+            "WHEN 'USD' = 'USD'\n" +
+            "THEN 0\n" +
+            "ELSE CASE\n" +
+            "WHEN 'USD' = 'EURO'\n" +
+            "THEN CASE\n" +
+            "WHEN 'A' = 'B'\n" +
+            "THEN 0\n" +
+            "ELSE 1\n" +
+            "END * 100 \n" +
+            "ELSE 2\n" +
+            "END\n" +
+            "END AS \"column1\"\n" +
+            "FROM test_schema.table_name\n" +
+            "", true);
+    }
+
+    @Test
+    public void testGroupByComplexExpressionIssue1308() throws JSQLParserException {
+        // without extra brackets
+        assertSqlCanBeParsedAndDeparsed(
+                "select * \n" +
+                        "from dual \n" +
+                        "group by case when 1=1 then 'X' else 'Y' end, column1", true);
+
+        // with extra  brackets for List
+        assertSqlCanBeParsedAndDeparsed(
+                "select * \n" +
+                        "from dual \n" +
+                        "group by (case when 1=1 then 'X' else 'Y' end, column1)", true);
+
+        // with extra brackets for Expression
+        assertSqlCanBeParsedAndDeparsed(
+                "select * \n" +
+                        "from dual \n" +
+                        "group by (case when 1=1 then 'X' else 'Y' end), column1", true);
+    }
 }
diff --git a/src/test/java/net/sf/jsqlparser/statement/update/UpdateTest.java b/src/test/java/net/sf/jsqlparser/statement/update/UpdateTest.java
index 82d11a5c5..565cd493a 100644
--- a/src/test/java/net/sf/jsqlparser/statement/update/UpdateTest.java
+++ b/src/test/java/net/sf/jsqlparser/statement/update/UpdateTest.java
@@ -17,7 +17,6 @@
 import net.sf.jsqlparser.expression.StringValue;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
 import net.sf.jsqlparser.parser.CCJSqlParserManager;
-import net.sf.jsqlparser.schema.Column;
 import static net.sf.jsqlparser.test.TestUtils.*;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -32,13 +31,13 @@ public void testUpdate() throws JSQLParserException {
         String statement = "UPDATE mytable set col1='as', col2=?, col3=565 Where o >= 3";
         Update update = (Update) parserManager.parse(new StringReader(statement));
         assertEquals("mytable", update.getTable().toString());
-        assertEquals(3, update.getColumns().size());
-        assertEquals("col1", ((Column) update.getColumns().get(0)).getColumnName());
-        assertEquals("col2", ((Column) update.getColumns().get(1)).getColumnName());
-        assertEquals("col3", ((Column) update.getColumns().get(2)).getColumnName());
-        assertEquals("as", ((StringValue) update.getExpressions().get(0)).getValue());
-        assertTrue(update.getExpressions().get(1) instanceof JdbcParameter);
-        assertEquals(565, ((LongValue) update.getExpressions().get(2)).getValue());
+        assertEquals(3, update.getUpdateSets().size());
+        assertEquals("col1", update.getUpdateSets().get(0).getColumns().get(0).getColumnName());
+        assertEquals("col2", update.getUpdateSets().get(1).getColumns().get(0).getColumnName());
+        assertEquals("col3", update.getUpdateSets().get(2).getColumns().get(0).getColumnName());
+        assertEquals("as", ((StringValue) update.getUpdateSets().get(0).getExpressions().get(0)).getValue());
+        assertTrue(update.getUpdateSets().get(1).getExpressions().get(0) instanceof JdbcParameter);
+        assertEquals(565, ((LongValue) update.getUpdateSets().get(2).getExpressions().get(0)).getValue());
 
         assertTrue(update.getWhere() instanceof GreaterThanEquals);
     }
@@ -189,4 +188,47 @@ public void testWith() throws JSQLParserException {
   
     assertSqlCanBeParsedAndDeparsed(statement, true);
   }
+
+    @Test
+    public void testUpdateSetsIssue1316() throws JSQLParserException {
+        String statement =
+                "update test\n" +
+                        "set (a, b) = (select '1', '2')";
+        assertSqlCanBeParsedAndDeparsed(statement, true);
+
+        statement =
+                "update test\n" +
+                        "set (a, b) = ('1', '2')";
+        assertSqlCanBeParsedAndDeparsed(statement, true);
+
+        statement =
+                "update test\n" +
+                        "set (a, b) = values ('1', '2')";
+        assertSqlCanBeParsedAndDeparsed(statement, true);
+
+        statement =
+                "update test\n" +
+                        "set (a, b) = (1, (select 2))";
+        assertSqlCanBeParsedAndDeparsed(statement, true);
+
+        statement =
+                "UPDATE\n" +
+                        "prpjpaymentbill b\n" +
+                        "SET\n" +
+                        "(\n" +
+                        "b.packagecode,\n" +
+                        "b.packageremark,\n" +
+                        "b.agentcode\n" +
+                        ") =\n" +
+                        "(SELECT\n" +
+                        "p.payrefreason,\n" +
+                        "p.classcode,\n" +
+                        "p.riskcode\n" +
+                        "FROM\n" +
+                        "prpjcommbill p where p.policertiid='SDDH200937010330006366' ),\n" +
+                        "b.payrefnotype = '05',\n" +
+                        "b.packageunit = '4101170402'\n" +
+                        "where b.payrefno='B370202091026000005' ";
+        assertSqlCanBeParsedAndDeparsed(statement, true);
+    }
 }
diff --git a/src/test/java/net/sf/jsqlparser/util/deparser/StatementDeParserTest.java b/src/test/java/net/sf/jsqlparser/util/deparser/StatementDeParserTest.java
index 6cf67c89d..bc8e2954d 100644
--- a/src/test/java/net/sf/jsqlparser/util/deparser/StatementDeParserTest.java
+++ b/src/test/java/net/sf/jsqlparser/util/deparser/StatementDeParserTest.java
@@ -16,6 +16,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import net.sf.jsqlparser.statement.update.UpdateSet;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -195,8 +196,6 @@ public void shouldUseProvidedDeParsersWhenDeParsingSelect() {
     @SuppressWarnings("PMD.JUnitTestsShouldIncludeAssert")
     public void shouldUseProvidedDeParsersWhenDeParsingUpdateNotUsingSelect() {
         Update update = new Update();
-        List<Column> columns = new ArrayList<Column>();
-        List<Expression> expressions = new ArrayList<Expression>();
         Expression where = mock(Expression.class);
         List<OrderByElement> orderByElements = new ArrayList<OrderByElement>();
         Column column1 = new Column();
@@ -208,14 +207,12 @@ public void shouldUseProvidedDeParsersWhenDeParsingUpdateNotUsingSelect() {
         Expression orderByElement1Expression = mock(Expression.class);
         Expression orderByElement2Expression = mock(Expression.class);
 
-        update.setColumns(columns);
-        update.setExpressions(expressions);
         update.setWhere(where);
         update.setOrderByElements(orderByElements);
-        columns.add(column1);
-        columns.add(column2);
-        expressions.add(expression1);
-        expressions.add(expression2);
+
+        update.addUpdateSet(column1, expression1);
+        update.addUpdateSet(column2, expression2);
+
         orderByElements.add(orderByElement1);
         orderByElements.add(orderByElement2);
         orderByElement1.setExpression(orderByElement1Expression);
@@ -237,7 +234,6 @@ public void shouldUseProvidedDeParsersWhenDeParsingUpdateNotUsingSelect() {
     public void shouldUseProvidedDeParsersWhenDeParsingUpdateUsingSelect() {
         Update update = new Update();
         List<Column> columns = new ArrayList<Column>();
-        Select select = new Select();
         Expression where = mock(Expression.class);
         List<OrderByElement> orderByElements = new ArrayList<OrderByElement>();
         Column column1 = new Column();
@@ -248,14 +244,19 @@ public void shouldUseProvidedDeParsersWhenDeParsingUpdateUsingSelect() {
         Expression orderByElement1Expression = mock(Expression.class);
         Expression orderByElement2Expression = mock(Expression.class);
 
-        update.setUseSelect(true);
-        update.setColumns(columns);
-        update.setSelect(select);
         update.setWhere(where);
         update.setOrderByElements(orderByElements);
-        columns.add(column1);
-        columns.add(column2);
-        select.setSelectBody(selectBody);
+
+        SubSelect subSelect = new SubSelect().withSelectBody(selectBody);
+        ExpressionList expressionList = new ExpressionList().addExpressions(subSelect);
+
+        UpdateSet updateSet=new UpdateSet();
+        updateSet.add(column1);
+        updateSet.add(column2);
+        updateSet.add(expressionList);
+
+        update.addUpdateSet(updateSet);
+
         orderByElements.add(orderByElement1);
         orderByElements.add(orderByElement2);
         orderByElement1.setExpression(orderByElement1Expression);
@@ -265,7 +266,7 @@ public void shouldUseProvidedDeParsersWhenDeParsingUpdateUsingSelect() {
 
         then(expressionDeParser).should().visit(column1);
         then(expressionDeParser).should().visit(column2);
-        then(selectBody).should().accept(selectDeParser);
+        then(expressionDeParser).should().visit(subSelect);
         then(where).should().accept(expressionDeParser);
         then(orderByElement1Expression).should().accept(expressionDeParser);
         then(orderByElement2Expression).should().accept(expressionDeParser);