replace isPersistent with isTemporary in params

for consistency

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

@@ -1147,7 +1147,7 @@ public class Parser {
                     queryAlias, querySQLOutput[0],
                     columnTemplateList, false/* no recursion */,
                     false/* do not add to session */,
-                    false /* isPersistent */,
+                    true /* isTemporary */,
                     session);
             TableFilter sourceTableFilter = new TableFilter(session,
                     temporarySourceTableView, queryAlias,
@@ -5168,16 +5168,16 @@ public class Parser {
 
         // this WITH statement might not be a temporary view - allow optional keyword to
         // tell us that this keyword. This feature will not be documented - H2 internal use only.
-        boolean isPersistent = readIf("PERSISTENT");
+        boolean isTemporary = !readIf("PERSISTENT");
 
         // this WITH statement is not a temporary view - it is part of a persistent view
         // as in CREATE VIEW abc AS WITH my_cte - this auto detects that condition
         if (session.isParsingCreateView()) {
-            isPersistent = true;
+        	isTemporary = false;
         }
 
         do {
-            viewsCreated.add(parseSingleCommonTableExpression(isPersistent));
+            viewsCreated.add(parseSingleCommonTableExpression(isTemporary));
         } while (readIf(","));
 
         Prepared p;
@@ -5219,13 +5219,13 @@ public class Parser {
 
         // clean up temporary views starting with last to first (in case of
         // dependencies) - but only if they are not persistent
-        if (!isPersistent) {
+        if (isTemporary) {
             p.setCteCleanups(viewsCreated);
         }
         return p;
     }
 
-    private TableView parseSingleCommonTableExpression(boolean isPersistent) {
+    private TableView parseSingleCommonTableExpression(boolean isTemporary) {
         String cteViewName = readIdentifierWithSchema();
         Schema schema = getSchema();
         ArrayList<Column> columns = Utils.newSmallArrayList();
@@ -5243,7 +5243,7 @@ public class Parser {
         }
 
         Table oldViewFound;
-        if (isPersistent) {
+        if (!isTemporary) {
             oldViewFound = getSchema().findTableOrView(session, cteViewName);
         } else {
             oldViewFound = session.findLocalTempTable(cteViewName);
@@ -5259,7 +5259,7 @@ public class Parser {
                 throw DbException.get(ErrorCode.TABLE_OR_VIEW_ALREADY_EXISTS_1,
                         cteViewName);
             }
-            if (isPersistent) {
+            if (!isTemporary) {
                 oldViewFound.lock(session, true, true);
                 database.removeSchemaObject(session, oldViewFound);
 
@@ -5275,33 +5275,33 @@ public class Parser {
          * data and table if we don't have a working CTE already.
          */
         Table recursiveTable = TableView.createShadowTableForRecursiveTableExpression(
-                isPersistent, session, cteViewName, schema, columns, database);
+        		isTemporary, session, cteViewName, schema, columns, database);
         List<Column> columnTemplateList;
         String[] querySQLOutput = {null};
         try {
             read("AS");
             read("(");
             Query withQuery = parseSelect();
-            if (isPersistent) {
+            if (!isTemporary) {
                 withQuery.session = session;
             }
             read(")");
             columnTemplateList = TableView.createQueryColumnTemplateList(cols, withQuery, querySQLOutput);
 
         } finally {
-            TableView.destroyShadowTableForRecursiveExpression(isPersistent, session, recursiveTable);
+            TableView.destroyShadowTableForRecursiveExpression(isTemporary, session, recursiveTable);
         }
 
         return createCTEView(cteViewName,
                 querySQLOutput[0], columnTemplateList,
                 true/* allowRecursiveQueryDetection */,
                 true/* add to session */,
-                isPersistent, session);
+                isTemporary, session);
     }
 
     private TableView createCTEView(String cteViewName,  String querySQL,
             List<Column> columnTemplateList, boolean allowRecursiveQueryDetection,
-            boolean addViewToSession, boolean isPersistent, Session targetSession) {
+            boolean addViewToSession, boolean isTemporary, Session targetSession) {
         Database db = targetSession.getDatabase();
         Schema schema = getSchemaWithDefault();
         int id = db.allocateObjectId();
@@ -5315,9 +5315,9 @@ public class Parser {
             view = new TableView(schema, id, cteViewName, querySQL,
                     parameters, columnTemplateArray, targetSession,
                     allowRecursiveQueryDetection, false /* literalsChecked */, true /* isTableExpression */,
-                    isPersistent);
+                    isTemporary);
             if (!view.isRecursiveQueryDetected() && allowRecursiveQueryDetection) {
-                if (isPersistent) {
+                if (!isTemporary) {
                     db.addSchemaObject(targetSession, view);
                     view.lock(targetSession, true, true);
                     db.removeSchemaObject(targetSession, view);
@@ -5327,17 +5327,17 @@ public class Parser {
                 view = new TableView(schema, id, cteViewName, querySQL, parameters,
                         columnTemplateArray, targetSession,
                         false/* assume recursive */, false /* literalsChecked */, true /* isTableExpression */,
-                        isPersistent);
+                        isTemporary);
             }
             // both removeSchemaObject and removeLocalTempTable hold meta locks
             db.unlockMeta(targetSession);
         }
         view.setTableExpression(true);
-        view.setTemporary(!isPersistent);
+        view.setTemporary(isTemporary);
         view.setHidden(true);
         view.setOnCommitDrop(false);
         if (addViewToSession) {
-            if (isPersistent) {
+            if (!isTemporary) {
                 db.addSchemaObject(targetSession, view);
                 view.unlock(targetSession);
                 db.unlockMeta(targetSession);

h2/src/main/org/h2/command/ddl/CreateView.java

@@ -119,10 +119,10 @@ public class CreateView extends SchemaCommand {
             if (isTableExpression) {
                 view = TableView.createTableViewMaybeRecursive(getSchema(), id, viewName, querySQL, null,
                         columnTemplatesAsStrings, session, false /* literalsChecked */, isTableExpression,
-                        true /* isPersistent */, db);
+                        false/*isTemporary*/, db);
             } else {
                 view = new TableView(getSchema(), id, viewName, querySQL, null, columnTemplatesAsUnknowns, session,
-                        false/* allow recursive */, false/* literalsChecked */, isTableExpression, true);
+                        false/* allow recursive */, false/* literalsChecked */, isTableExpression, false/*temporary*/);
             }
         } else {
             // TODO support isTableExpression in replace function...

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

@@ -66,9 +66,9 @@ public class TableView extends Table {
 
     public TableView(Schema schema, int id, String name, String querySQL,
             ArrayList<Parameter> params, Column[] columnTemplates, Session session,
-            boolean allowRecursive, boolean literalsChecked, boolean isTableExpression, boolean isPersistent) {
+            boolean allowRecursive, boolean literalsChecked, boolean isTableExpression, boolean isTemporary) {
         super(schema, id, name, false, true);
-        setTemporary(!isPersistent);
+        setTemporary(isTemporary);
         init(querySQL, params, columnTemplates, session, allowRecursive, literalsChecked, isTableExpression);
     }
 
@@ -566,7 +566,7 @@ public class TableView extends Table {
         TableView v = new TableView(mainSchema, 0, name,
                 querySQL, query.getParameters(), null /* column templates */, session,
                 false/* allow recursive */, true /* literals have already been checked when parsing original query */,
-                false /* is table expression */, false/* is persistent*/);
+                false /* is table expression */, true/*temporary*/);
         if (v.createException != null) {
             throw v.createException;
         }
@@ -726,16 +726,16 @@ public class TableView extends Table {
      * @param session the session
      * @param literalsChecked whether literals in the query are checked
      * @param isTableExpression if this is a table expression
-     * @param isPersistent whether the view is persisted
+     * @param isTemporary whether the view is persisted
      * @param db the database
      * @return the view
      */
     public static TableView createTableViewMaybeRecursive(Schema schema, int id, String name, String querySQL,
             ArrayList<Parameter> parameters, Column[] columnTemplates, Session session,
-            boolean literalsChecked, boolean isTableExpression, boolean isPersistent, Database db) {
+            boolean literalsChecked, boolean isTableExpression, boolean isTemporary, Database db) {
 
 
-        Table recursiveTable = TableView.createShadowTableForRecursiveTableExpression(isPersistent, session, name,
+        Table recursiveTable = createShadowTableForRecursiveTableExpression(isTemporary, session, name,
                 schema, Arrays.asList(columnTemplates), db);
 
         List<Column> columnTemplateList;
@@ -747,25 +747,25 @@ public class TableView extends Table {
 
         try {
             Prepared withQuery = session.prepare(querySQL, false, false);
-            if (isPersistent) {
+            if (!isTemporary) {
                 withQuery.setSession(session);
             }
             columnTemplateList = TableView.createQueryColumnTemplateList(columnNames.toArray(new String[1]),
                     (Query) withQuery, querySQLOutput);
 
         } finally {
-            TableView.destroyShadowTableForRecursiveExpression(isPersistent, session, recursiveTable);
+            destroyShadowTableForRecursiveExpression(isTemporary, session, recursiveTable);
         }
 
         // build with recursion turned on
         TableView view = new TableView(schema, id, name, querySQL,
                 parameters, columnTemplateList.toArray(columnTemplates), session,
-                true/* try recursive */, literalsChecked, isTableExpression, isPersistent);
+                true/* try recursive */, literalsChecked, isTableExpression, isTemporary);
 
         // is recursion really detected ? if not - recreate it without recursion flag
         // and no recursive index
         if (!view.isRecursiveQueryDetected()) {
-            if (isPersistent) {
+            if (!isTemporary) {
                 db.addSchemaObject(session, view);
                 view.lock(session, true, true);
                 session.getDatabase().removeSchemaObject(session, view);
@@ -779,7 +779,7 @@ public class TableView extends Table {
             }
             view = new TableView(schema, id, name, querySQL, parameters,
                     columnTemplates, session,
-                    false/* detected not recursive */, literalsChecked, isTableExpression, isPersistent);
+                    false/* detected not recursive */, literalsChecked, isTableExpression, isTemporary);
         }
 
         return view;
@@ -823,7 +823,7 @@ public class TableView extends Table {
     /**
      * Create a table for a recursive query.
      *
-     * @param isPersistent whether the table is persisted
+     * @param isTemporary whether the table is persisted
      * @param targetSession the session
      * @param cteViewName the name
      * @param schema the schema
@@ -831,7 +831,7 @@ public class TableView extends Table {
      * @param db the database
      * @return the table
      */
-    public static Table createShadowTableForRecursiveTableExpression(boolean isPersistent, Session targetSession,
+    public static Table createShadowTableForRecursiveTableExpression(boolean isTemporary, Session targetSession,
             String cteViewName, Schema schema, List<Column> columns, Database db) {
 
         // create table data object
@@ -839,16 +839,16 @@ public class TableView extends Table {
         recursiveTableData.id = db.allocateObjectId();
         recursiveTableData.columns = new ArrayList<>(columns);
         recursiveTableData.tableName = cteViewName;
-        recursiveTableData.temporary = !isPersistent;
+        recursiveTableData.temporary = isTemporary;
         recursiveTableData.persistData = true;
-        recursiveTableData.persistIndexes = isPersistent;
+        recursiveTableData.persistIndexes = !isTemporary;
         recursiveTableData.create = true;
         recursiveTableData.session = targetSession;
 
         // this gets a meta table lock that is not released
         Table recursiveTable = schema.createTable(recursiveTableData);
 
-        if (isPersistent) {
+        if (!isTemporary) {
             // this unlock is to prevent lock leak from schema.createTable()
             db.unlockMeta(targetSession);
             synchronized (targetSession) {
@@ -863,14 +863,14 @@ public class TableView extends Table {
     /**
      * Remove a table for a recursive query.
      *
-     * @param isPersistent whether the table is persisted
+     * @param isTemporary whether the table is persisted
      * @param targetSession the session
      * @param recursiveTable the table
      */
-    public static void destroyShadowTableForRecursiveExpression(boolean isPersistent, Session targetSession,
+    public static void destroyShadowTableForRecursiveExpression(boolean isTemporary, Session targetSession,
             Table recursiveTable) {
         if (recursiveTable != null) {
-            if (isPersistent) {
+            if (!isTemporary) {
                 recursiveTable.lock(targetSession, true, true);
                 targetSession.getDatabase().removeSchemaObject(targetSession, recursiveTable);