diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-1.sqlpp b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-1.sqlpp
index 800052f..3590b8b 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-1.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-1.sqlpp
@@ -34,5 +34,5 @@
 
 create  index TestSetIndex  on TestSet (idx) type btree;
 
-delete x from TestSet
- where ((x.id = 'one') or (x.id = 'two'));
+delete from TestSet
+ where id = 'one' or id = 'two';
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-2.sqlpp b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-2.sqlpp
index a6000e2..f7cae59 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-2.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-2.sqlpp
@@ -34,5 +34,5 @@
 
 create  index TestSetIndex  on TestSet (idx) type btree;
 
-delete x from TestSet
- where ((x.idx = 'one') or (x.idx = 'two'));
+delete from TestSet
+ where idx = 'one' or idx = 'two';
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-3.sqlpp b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-3.sqlpp
index 8dfbc49..29b017f 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-3.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/disjunction-to-join-delete-3.sqlpp
@@ -34,5 +34,5 @@
 
 create  index TestSetIndex  on TestSet (idx) type btree;
 
-delete x from TestSet
- where ((x.`no-idx` = 'one') or (x.`no-idx` = 'two'));
+delete from TestSet
+ where `no-idx` = 'one' or `no-idx` = 'two';
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete-all.sqlpp b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete-all.sqlpp
index 4f5793d..8824b06 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete-all.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete-all.sqlpp
@@ -58,5 +58,4 @@
 
 create  table LineID(LineIDType) primary key l_orderkey on group1;
 
-delete l from LineItems_q1
-;
+delete from LineItems_q1;
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete-rtree-secondary-index.sqlpp b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete-rtree-secondary-index.sqlpp
index 2cc5c3b..2156a23 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete-rtree-secondary-index.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete-rtree-secondary-index.sqlpp
@@ -46,5 +46,5 @@
 
 create  index rtree_index_point  on MyData (point) type rtree;
 
-delete m from MyData
- where (m.id > 5);
+delete from MyData
+ where id > 5;
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete.sqlpp b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete.sqlpp
index f68e261..d41c817 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/scan-delete.sqlpp
@@ -58,5 +58,5 @@
 
 create  table LineID(LineIDType) primary key l_orderkey on group1;
 
-delete l from LineItems_q1
- where (l.l_shipdate <= '1998-09-02');
+delete from LineItems_q1
+ where l_shipdate <= '1998-09-02';
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/dont-skip-primary-index-search-in-delete.sqlpp b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/dont-skip-primary-index-search-in-delete.sqlpp
index b7f8751..464f2e3 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/dont-skip-primary-index-search-in-delete.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/dont-skip-primary-index-search-in-delete.sqlpp
@@ -52,5 +52,5 @@
 
 create  table Customers(CustomerType) primary key cid;
 
-delete c from Customers
- where (c.cid /*+ skip-index */  < 10);
+delete from Customers
+ where cid /*+ skip-index */  < 10;
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-ngram-index-search-in-delete.sqlpp b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-ngram-index-search-in-delete.sqlpp
index 9111891..c2a2a3b 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-ngram-index-search-in-delete.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-ngram-index-search-in-delete.sqlpp
@@ -41,5 +41,5 @@
 
 create  index ngram_index  on DBLP (title) type ngram (3);
 
-delete o from DBLP
- where  /*+ skip-index */ test.contains(o.title,'Multimedia');
+delete from DBLP
+ where  /*+ skip-index */ contains(title,'Multimedia');
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-rtree-index-search-in-delete.sqlpp b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-rtree-index-search-in-delete.sqlpp
index c431b42..e3727fb 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-rtree-index-search-in-delete.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-rtree-index-search-in-delete.sqlpp
@@ -45,5 +45,5 @@
 
 create  index rtree_index_point  on MyData (point) type rtree;
 
-delete m from MyData
- where  /*+ skip-index */ test.`spatial-intersect`(m.point,test.`create-polygon`([0.0,1.0,0.0,4.0,12.0,4.0,12.0,1.0]));
+delete from MyData
+ where  /*+ skip-index */ `spatial-intersect`(point, `create-polygon`([0.0,1.0,0.0,4.0,12.0,4.0,12.0,1.0]));
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-secondary-btree-index-search-in-delete.sqlpp b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-secondary-btree-index-search-in-delete.sqlpp
index b54fc9c..a4e4955 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-secondary-btree-index-search-in-delete.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-secondary-btree-index-search-in-delete.sqlpp
@@ -53,5 +53,5 @@
 
 create  index age_index  on Customers (age) type btree;
 
-delete c from Customers
- where (c.age /*+ skip-index */  < 20);
+delete from Customers
+ where age /*+ skip-index */  < 20;
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-word-index-search-in-delete.sqlpp b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-word-index-search-in-delete.sqlpp
index 44702cc..1d51c9c 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-word-index-search-in-delete.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/queries_sqlpp/skip-index/skip-word-index-search-in-delete.sqlpp
@@ -41,5 +41,5 @@
 
 create  index keyword_index  on DBLP (title) type keyword;
 
-delete o from DBLP
- where ( /*+ skip-index */ test.`similarity-jaccard`(test.`word-tokens`(o.title),test.`word-tokens`('Transactions for Cooperative Environments')) >= 0.500000f);
+delete from DBLP
+ where  /*+ skip-index */ `similarity-jaccard`(`word-tokens`(title), `word-tokens`('Transactions for Cooperative Environments')) >= 0.500000f;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/compact-dataset-and-its-indexes/compact-dataset-and-its-indexes.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/compact-dataset-and-its-indexes/compact-dataset-and-its-indexes.4.update.sqlpp
index 3e22ee1..2dd6408 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/compact-dataset-and-its-indexes/compact-dataset-and-its-indexes.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/compact-dataset-and-its-indexes/compact-dataset-and-its-indexes.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete l from LineItem
- where ((l.l_suppkey >= 2) or (l.l_linenumber > 1));
+delete from LineItem
+ where l_suppkey >= 2 or l_linenumber > 1;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp
index 3e22ee1..2dd6408 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete l from LineItem
- where ((l.l_suppkey >= 2) or (l.l_linenumber > 1));
+delete from LineItem
+ where l_suppkey >= 2 or l_linenumber > 1;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-from-loaded-dataset/delete-from-loaded-dataset.2.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-from-loaded-dataset/delete-from-loaded-dataset.2.update.sqlpp
index f4351d3..3d33488 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-from-loaded-dataset/delete-from-loaded-dataset.2.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-from-loaded-dataset/delete-from-loaded-dataset.2.update.sqlpp
@@ -22,5 +22,5 @@
 
 load  table LineItem using localfs ((`path`=`asterix_nc1://data/tpch0.001/lineitem.tbl`),(`format`=`delimited-text`),(`delimiter`=`|`)) pre-sorted;
 
-delete l from LineItem
- where (l.l_orderkey >= 10);
+delete from LineItem as l
+ where l.l_orderkey >= 10;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-multi-statement/delete-multi-statement.2.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-multi-statement/delete-multi-statement.2.update.sqlpp
index baf2f25..3e1a700 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-multi-statement/delete-multi-statement.2.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-multi-statement/delete-multi-statement.2.update.sqlpp
@@ -36,17 +36,16 @@
 
 load  table Customer using localfs ((`path`=`asterix_nc1://data/tpch0.001/customer.tbl`),(`format`=`delimited-text`),(`delimiter`=`|`));
 
-delete l from LineItem
-;
-delete o from Orders
-;
-delete s from Supplier
-;
-delete s from Region
-;
-delete s from Nation
-;
-delete s from Part
-;
-delete s from Partsupp
-;
+delete from LineItem;
+
+delete from Orders;
+
+delete from Supplier;
+
+delete from Region;
+
+delete from Nation;
+
+delete from Part;
+
+delete from Partsupp;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-syntax-change.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-syntax-change.sqlpp
index 9a80c54..12dec48 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-syntax-change.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-syntax-change.sqlpp
@@ -53,8 +53,9 @@
 
 load  table LineItem using localfs ((`path`=`asterix_nc1://data/tpch0.001/lineitem.tbl`),(`format`=`delimited-text`),(`delimiter`=`|`)) pre-sorted;
 
-delete l from LineItem
- where (l.l_orderkey >= 10);
+delete from LineItem
+ where l_orderkey >= 10;
+
 write output to asterix_nc1:`rttest/dml_delete-syntax-change.adm`
 select element c
 from  LineItem as c
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-syntax-change/delete-syntax-change.2.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-syntax-change/delete-syntax-change.2.update.sqlpp
index f4351d3..19ece72 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-syntax-change/delete-syntax-change.2.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/delete-syntax-change/delete-syntax-change.2.update.sqlpp
@@ -22,5 +22,5 @@
 
 load  table LineItem using localfs ((`path`=`asterix_nc1://data/tpch0.001/lineitem.tbl`),(`format`=`delimited-text`),(`delimiter`=`|`)) pre-sorted;
 
-delete l from LineItem
- where (l.l_orderkey >= 10);
+delete from LineItem
+ where l_orderkey >= 10;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/query-issue205/query-issue205.2.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/query-issue205/query-issue205.2.update.sqlpp
index 6c5cd3c..146436d 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/query-issue205/query-issue205.2.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/query-issue205/query-issue205.2.update.sqlpp
@@ -30,5 +30,5 @@
 select element {'id':'1234','stat':{'age':50,'salary':120000},'deptCode':32};
 insert into Employees
 select element {'id':'5678','stat':{'age':40,'salary':100000},'deptCode':16};
-delete l from Employees
- where (l.id = '1234');
+
+delete from Employees where id = '1234';
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-btree-secondary-index-nullable/scan-delete-btree-secondary-index-nullable.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-btree-secondary-index-nullable/scan-delete-btree-secondary-index-nullable.4.update.sqlpp
index 0b60e5e..9c2cf0c 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-btree-secondary-index-nullable/scan-delete-btree-secondary-index-nullable.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-btree-secondary-index-nullable/scan-delete-btree-secondary-index-nullable.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete c from Customers
- where (c.cid >= 200);
+delete from Customers
+ where cid >= 200;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-btree-secondary-index-open/scan-delete-btree-secondary-index-open.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-btree-secondary-index-open/scan-delete-btree-secondary-index-open.4.update.sqlpp
index 26005e7..180ef79 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-btree-secondary-index-open/scan-delete-btree-secondary-index-open.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-btree-secondary-index-open/scan-delete-btree-secondary-index-open.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete c from CustomersOpen
- where (c.cid >= 200);
+delete from CustomersOpen
+ where cid >= 200;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index-nullable/scan-delete-inverted-index-ngram-secondary-index-nullable.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index-nullable/scan-delete-inverted-index-ngram-secondary-index-nullable.4.update.sqlpp
index 49d7527..0060256 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index-nullable/scan-delete-inverted-index-ngram-secondary-index-nullable.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index-nullable/scan-delete-inverted-index-ngram-secondary-index-nullable.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete o from DBLP
- where (o.id > 50);
+delete from DBLP
+ where id > 50;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index-open/scan-delete-inverted-index-ngram-secondary-index-open.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index-open/scan-delete-inverted-index-ngram-secondary-index-open.4.update.sqlpp
index dd73b8c..394c3d7 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index-open/scan-delete-inverted-index-ngram-secondary-index-open.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index-open/scan-delete-inverted-index-ngram-secondary-index-open.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete o from DBLPOpen
- where (o.id > 50);
+delete from DBLPOpen
+ where id > 50;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index/scan-delete-inverted-index-ngram-secondary-index.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index/scan-delete-inverted-index-ngram-secondary-index.4.update.sqlpp
index bf8504e..abf1233 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index/scan-delete-inverted-index-ngram-secondary-index.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-ngram-secondary-index/scan-delete-inverted-index-ngram-secondary-index.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete o from DBLP
- where (o.id > 50);
+delete from DBLP
+ where id > 50;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index-nullable/scan-delete-inverted-index-word-secondary-index-nullable.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index-nullable/scan-delete-inverted-index-word-secondary-index-nullable.4.update.sqlpp
index fc34d5c..9fb7044 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index-nullable/scan-delete-inverted-index-word-secondary-index-nullable.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index-nullable/scan-delete-inverted-index-word-secondary-index-nullable.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete o from DBLP
- where (o.id < 50);
+delete from DBLP
+ where id < 50;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index-open/scan-delete-inverted-index-word-secondary-index-open.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index-open/scan-delete-inverted-index-word-secondary-index-open.4.update.sqlpp
index f601add..7557e8f 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index-open/scan-delete-inverted-index-word-secondary-index-open.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index-open/scan-delete-inverted-index-word-secondary-index-open.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete o from DBLPOpen
- where (o.id < 50);
+delete from DBLPOpen
+ where id < 50;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index/scan-delete-inverted-index-word-secondary-index.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index/scan-delete-inverted-index-word-secondary-index.4.update.sqlpp
index 9d04a30..877acf3 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index/scan-delete-inverted-index-word-secondary-index.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-inverted-index-word-secondary-index/scan-delete-inverted-index-word-secondary-index.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete o from DBLP
- where (o.id < 50);
+delete from DBLP
+ where id < 50;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index-nullable/scan-delete-rtree-secondary-index-nullable.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index-nullable/scan-delete-rtree-secondary-index-nullable.4.update.sqlpp
index 7d4cf25..dab4d98 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index-nullable/scan-delete-rtree-secondary-index-nullable.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index-nullable/scan-delete-rtree-secondary-index-nullable.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete m from MyData
- where (m.id > 10);
+delete from MyData
+ where id > 10;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index-open/scan-delete-rtree-secondary-index-open.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index-open/scan-delete-rtree-secondary-index-open.4.update.sqlpp
index 136519e..23b4585 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index-open/scan-delete-rtree-secondary-index-open.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index-open/scan-delete-rtree-secondary-index-open.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete m from MyDataOpen
- where (m.id > 10);
+delete from MyDataOpen
+ where id > 10;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp
index 7d4cf25..dab4d98 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete m from MyData
- where (m.id > 10);
+delete from MyData
+ where id > 10;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-constant-merge-policy/using-constant-merge-policy.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-constant-merge-policy/using-constant-merge-policy.4.update.sqlpp
index 3e22ee1..2dd6408 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-constant-merge-policy/using-constant-merge-policy.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-constant-merge-policy/using-constant-merge-policy.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete l from LineItem
- where ((l.l_suppkey >= 2) or (l.l_linenumber > 1));
+delete from LineItem
+ where l_suppkey >= 2 or l_linenumber > 1;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-correlated-prefix-merge-policy/using-correlated-prefix-merge-policy.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-correlated-prefix-merge-policy/using-correlated-prefix-merge-policy.4.update.sqlpp
index 3e22ee1..2dd6408 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-correlated-prefix-merge-policy/using-correlated-prefix-merge-policy.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-correlated-prefix-merge-policy/using-correlated-prefix-merge-policy.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete l from LineItem
- where ((l.l_suppkey >= 2) or (l.l_linenumber > 1));
+delete from LineItem
+ where l_suppkey >= 2 or l_linenumber > 1;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-no-merge-policy/using-no-merge-policy.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-no-merge-policy/using-no-merge-policy.4.update.sqlpp
index 3e22ee1..2dd6408 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-no-merge-policy/using-no-merge-policy.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-no-merge-policy/using-no-merge-policy.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete l from LineItem
- where ((l.l_suppkey >= 2) or (l.l_linenumber > 1));
+delete from LineItem
+ where l_suppkey >= 2 or l_linenumber > 1;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-prefix-merge-policy/using-prefix-merge-policy.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-prefix-merge-policy/using-prefix-merge-policy.4.update.sqlpp
index 3e22ee1..2dd6408 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-prefix-merge-policy/using-prefix-merge-policy.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dml/using-prefix-merge-policy/using-prefix-merge-policy.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete l from LineItem
- where ((l.l_suppkey >= 2) or (l.l_linenumber > 1));
+delete from LineItem
+ where l_suppkey >= 2 or l_linenumber > 1;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/compact-dataset-and-its-indexes/compact-dataset-and-its-indexes.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/compact-dataset-and-its-indexes/compact-dataset-and-its-indexes.4.update.sqlpp
index 481e443..56c630b 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/compact-dataset-and-its-indexes/compact-dataset-and-its-indexes.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/compact-dataset-and-its-indexes/compact-dataset-and-its-indexes.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete l from LineItem
- where ((l.nested.l_suppkey >= 2) or (l.nested.l_linenumber > 1));
+delete from LineItem
+ where nested.l_suppkey >= 2 or nested.l_linenumber > 1;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp
index 6f40734..d5db77b 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp
@@ -20,5 +20,5 @@
 use TinySocial;
 
 
-delete l from TweetMessages
- where ((l.user.name >= 'Oli Jackson') or (l.user.statuses_count > 362));
+delete from TweetMessages
+ where user.name >= 'Oli Jackson' or user.statuses_count > 362;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-btree-secondary-index-nullable/scan-delete-btree-secondary-index-nullable.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-btree-secondary-index-nullable/scan-delete-btree-secondary-index-nullable.4.update.sqlpp
index 014a578..c188e67 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-btree-secondary-index-nullable/scan-delete-btree-secondary-index-nullable.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-btree-secondary-index-nullable/scan-delete-btree-secondary-index-nullable.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete c from Customers
- where (c.nested.cid >= 200);
+delete from Customers c
+ where c.nested.cid >= 200;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-ngram-secondary-index-nullable/scan-delete-inverted-index-ngram-secondary-index-nullable.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-ngram-secondary-index-nullable/scan-delete-inverted-index-ngram-secondary-index-nullable.4.update.sqlpp
index ef88973..692c067 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-ngram-secondary-index-nullable/scan-delete-inverted-index-ngram-secondary-index-nullable.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-ngram-secondary-index-nullable/scan-delete-inverted-index-ngram-secondary-index-nullable.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete o from DBLP
- where (o.nested.id > 50);
+delete from DBLP
+ where nested.id > 50;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-ngram-secondary-index/scan-delete-inverted-index-ngram-secondary-index.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-ngram-secondary-index/scan-delete-inverted-index-ngram-secondary-index.4.update.sqlpp
index 8be2b45..158a99a 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-ngram-secondary-index/scan-delete-inverted-index-ngram-secondary-index.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-ngram-secondary-index/scan-delete-inverted-index-ngram-secondary-index.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete o from DBLP
- where (o.nested.id > 50);
+delete from DBLP
+ where nested.id > 50;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-word-secondary-index-nullable/scan-delete-inverted-index-word-secondary-index-nullable.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-word-secondary-index-nullable/scan-delete-inverted-index-word-secondary-index-nullable.4.update.sqlpp
index dde942d..cd82d04 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-word-secondary-index-nullable/scan-delete-inverted-index-word-secondary-index-nullable.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-word-secondary-index-nullable/scan-delete-inverted-index-word-secondary-index-nullable.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete o from DBLP
- where (o.nested.id < 50);
+delete from DBLP
+ where nested.id < 50;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-word-secondary-index/scan-delete-inverted-index-word-secondary-index.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-word-secondary-index/scan-delete-inverted-index-word-secondary-index.4.update.sqlpp
index c2eb9d0..3de28a5 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-word-secondary-index/scan-delete-inverted-index-word-secondary-index.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-inverted-index-word-secondary-index/scan-delete-inverted-index-word-secondary-index.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete o from DBLP
- where (o.nested.id < 50);
+delete from DBLP
+ where nested.id < 50;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-rtree-secondary-index-nullable/scan-delete-rtree-secondary-index-nullable.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-rtree-secondary-index-nullable/scan-delete-rtree-secondary-index-nullable.4.update.sqlpp
index ec7f98c..1b735f5 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-rtree-secondary-index-nullable/scan-delete-rtree-secondary-index-nullable.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-rtree-secondary-index-nullable/scan-delete-rtree-secondary-index-nullable.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete m from MyData
- where (m.nested.id > 10);
+delete from MyData
+ where nested.id > 10;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp
index ec7f98c..1b735f5 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/nested-index-dml/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp
@@ -20,5 +20,5 @@
 use test;
 
 
-delete m from MyData
- where (m.nested.id > 10);
+delete from MyData
+ where nested.id > 10;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp
index d501af7..71a5f53 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/delete-from-loaded-dataset-with-index/delete-from-loaded-dataset-with-index.4.update.sqlpp
@@ -26,5 +26,5 @@
 use test;
 
 
-delete l from LineItem
- where ((l.l_suppkey >= 2) or (l.l_linenumber > 1));
+delete from LineItem
+ where l_suppkey >= 2 or l_linenumber > 1;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/delete-from-loaded-dataset/delete-from-loaded-dataset.2.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/delete-from-loaded-dataset/delete-from-loaded-dataset.2.update.sqlpp
index 7a349b1..4cd1a81 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/delete-from-loaded-dataset/delete-from-loaded-dataset.2.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/delete-from-loaded-dataset/delete-from-loaded-dataset.2.update.sqlpp
@@ -28,5 +28,5 @@
 
 load  table LineItem using localfs ((`path`=`asterix_nc1://data/tpch0.001/lineitem.tbl`),(`format`=`delimited-text`),(`delimiter`=`|`)) pre-sorted;
 
-delete l from LineItem
- where (l.l_orderkey >= 10);
+delete from LineItem
+ where l_orderkey >= 10;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp
index ab871bf..5a6708a 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/temp-dataset/scan-delete-rtree-secondary-index/scan-delete-rtree-secondary-index.4.update.sqlpp
@@ -25,5 +25,5 @@
 use test;
 
 
-delete m from MyData
- where (m.id > 10);
+delete from MyData
+ where id > 10;
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/tinysocial/tinysocial-suite-open/tinysocial-suite.21.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/tinysocial/tinysocial-suite-open/tinysocial-suite.21.update.sqlpp
index 21f2b22..e590467 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/tinysocial/tinysocial-suite-open/tinysocial-suite.21.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/tinysocial/tinysocial-suite-open/tinysocial-suite.21.update.sqlpp
@@ -23,5 +23,5 @@
 use TinySocial;
 
 
-delete tm from TweetMessages
- where (tm.tweetid = '13');
+delete from TweetMessages
+ where tweetid = '13';
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/tinysocial/tinysocial-suite/tinysocial-suite.21.update.sqlpp b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/tinysocial/tinysocial-suite/tinysocial-suite.21.update.sqlpp
index 21f2b22..e590467 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/tinysocial/tinysocial-suite/tinysocial-suite.21.update.sqlpp
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/tinysocial/tinysocial-suite/tinysocial-suite.21.update.sqlpp
@@ -23,5 +23,5 @@
 use TinySocial;
 
 
-delete tm from TweetMessages
- where (tm.tweetid = '13');
+delete from TweetMessages
+ where tweetid = '13';
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_parser_sqlpp/user-defined-functions/udf30/udf30.1.ast b/asterixdb/asterix-app/src/test/resources/runtimets/results_parser_sqlpp/user-defined-functions/udf30/udf30.1.ast
index e69de29..83b1f68 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_parser_sqlpp/user-defined-functions/udf30/udf30.1.ast
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_parser_sqlpp/user-defined-functions/udf30/udf30.1.ast
@@ -0,0 +1,13 @@
+FunctionDecl abc([$y]) {
+  LiteralExpr [LONG] [3]
+}
+
+Query:
+Let Variable [ Name=$z ]
+  :=
+  FunctionCall Metadata.dataset@1[
+    LiteralExpr [STRING] [y]
+  ]
+SELECT ELEMENT [
+Variable [ Name=$z ]
+]
diff --git a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppDeleteRewriteVisitor.java b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppDeleteRewriteVisitor.java
index efff18e..bfb1e44 100644
--- a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppDeleteRewriteVisitor.java
+++ b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/visitor/SqlppDeleteRewriteVisitor.java
@@ -51,7 +51,7 @@
 
     @Override
     public Void visit(DeleteStatement deleteStmt, Void visitArg) {
-        List<Expression> arguments = new ArrayList<Expression>();
+        List<Expression> arguments = new ArrayList<>();
         Identifier dataverseName = deleteStmt.getDataverseName();
         Identifier datasetName = deleteStmt.getDatasetName();
         String arg = dataverseName == null ? datasetName.getValue()
diff --git a/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.html b/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.html
index b80aa61..2f7b7c6 100644
--- a/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.html
+++ b/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.html
@@ -510,7 +510,7 @@
 <TR>
 <TD ALIGN=RIGHT VALIGN=BASELINE><A NAME="prod11">DeleteStatement</A></TD>
 <TD ALIGN=CENTER VALIGN=BASELINE>::=</TD>
-<TD ALIGN=LEFT VALIGN=BASELINE>&lt;DELETE&gt; <A HREF="#prod50">Variable</A> &lt;FROM&gt; <A HREF="#prod31">QualifiedName</A> ( &lt;WHERE&gt; <A HREF="#prod44">Expression</A> )?</TD>
+<TD ALIGN=LEFT VALIGN=BASELINE>&lt;DELETE&gt; &lt;FROM&gt; <A HREF="#prod31">QualifiedName</A> ( ( &lt;AS&gt; )? <A HREF="#prod50">Variable</A> )? ( &lt;WHERE&gt; <A HREF="#prod44">Expression</A> )?</TD>
 </TR>
 <TR>
 <TD ALIGN=RIGHT VALIGN=BASELINE><A NAME="prod12">UpdateStatement</A></TD>
diff --git a/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.jj b/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.jj
index 9b0c71c..9f62ef2 100644
--- a/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.jj
+++ b/asterixdb/asterix-lang-sqlpp/src/main/javacc/SQLPP.jj
@@ -930,7 +930,7 @@
 
 DeleteStatement DeleteStatement() throws ParseException:
 {
-  VariableExpr var = null;
+  VariableExpr varExpr = null;
   Expression condition = null;
   Pair<Identifier, Identifier> nameComponents;
   // This is related to the new metadata lock management
@@ -939,19 +939,26 @@
 
 }
 {
-  <DELETE> var = Variable()
+  <DELETE>
   <FROM> nameComponents  = QualifiedName()
+         ((<AS>)? varExpr = Variable())?
   (<WHERE> condition = Expression())?
-    {
+  {
       // First we get the dataverses and datasets that we want to lock
       List<String> dataverses = getDataverses();
       List<String> datasets = getDatasets();
       // we remove the pointer to the dataverses and datasets
       setDataverses(null);
       setDatasets(null);
-      return new DeleteStatement(var, nameComponents.first, nameComponents.second,
+
+      if(varExpr == null){
+        varExpr = new VariableExpr();
+        VarIdentifier var = SqlppVariableUtil.toInternalVariableIdentifier(nameComponents.second.getValue());
+        varExpr.setVar(var);
+      }
+      return new DeleteStatement(varExpr, nameComponents.first, nameComponents.second,
           condition, getVarCounter(), dataverses, datasets);
-    }
+  }
 }
 
 UpdateStatement UpdateStatement() throws ParseException:
