fwd-h2-11745.patch

         private boolean canFastDelete(int limitRows)
+        {
            Table table = targetTableFilter.getTable();
            // a table-wide fast delete would also bypass the undo log of any multiplex which overrides
            // the no-undo option to be undoable, so it cannot be used once overrides are in play
            return table.isNoUndo() &&
                   !table.hasMultiplexNoUndo() &&
                   condition == null &&
                   (limitRows == -1 || limitRows >= table.getRowCount(session)) &&
                   !table.hasTriggers() &&

        throws SQLException;
        /**
         * Set the no-undo option of a single multiplex, overriding the option the table was created
         * with.
         * <p>
         * A multiplexed table backs several logically independent tables, which need not agree on the
         * no-undo option, so it cannot be a property of the SQL table alone.  Call this once, when the
         * multiplex is opened and before it holds any rows;  rows written under the previous setting
         * keep the undo records they were given.
+        *
         * @param   tableName
         *          The name of the table which holds the multiplex.
         * @param   multiplex
         *          The multiplex to set the option for.
         * @param   noUndo
         *          {@code true} if changes to this multiplex must not be undoable.
+        *
         * @throws  SQLException
         *          if the table does not exist.
         */
        public void setMultiplexNoUndo(String tableName, int multiplex, boolean noUndo)
        throws SQLException;
        /**
         * Retrieve a single row from a table by its recid. By convention, all H2 tables
         * targeted by this method have a primary key on a single integer column representing
         * the recid. Also, the recid should always be the first column of the table.

           ((FWDMultiplexedIndex) idx).killMultiplex(session, multiplex);
           session.cleanUndoLog(t, multiplex);
           // the multiplex is gone, so its no-undo override must not outlive it
           t.clearMultiplexNoUndo(multiplex);
+       }
        @Override
        public void setMultiplexNoUndo(String tableName, int multiplex, boolean noUndo)
        throws SQLException
+       {
           if (tableName == null)
+          {
              throw new SQLException("Invalid input: null values");
+          }
           Session session = getSession();
           Table t = session.findLocalTempTable(tableName.toUpperCase());
           if (t == null)
+          {
              throw new SQLException("Table not found: " + tableName);
+          }
           t.setMultiplexNoUndo(multiplex, noUndo);
+       }
        /**
         * Retrieve the number of rows that are currently in a specified table.
+        *

new/src/main/org/h2/engine/Session.java 2026-08-17 12:59:07 +0000
1016	1016	if (table.isMVStore()) {
1017	1017	return;
1018	1018	}
1019		if (table.isNoUndo()) {
	1019	// the no-undo option can be overridden per multiplex, so it is resolved from the row
	1020	if (table.isNoUndo(row)) {
1020	1021	return;
1021	1022	}
1022	1023	if (undoLogEnabled) {

      */
     public class UndoLog {
         /** The temp-tables always have the _MULTIPLEX on offset 1, after the PK (at offset 0). */
         private static final int MULTIPLEX_OFFSET = 1;
         private static final int MULTIPLEX_OFFSET = Table.MULTIPLEX_COLUMN;
         private final Database database;
         private final ArrayList<Long> storedEntriesPos = Utils.newSmallArrayList();
-...
            if (database.isPersistent()) {
               throw DbException.throwInternalError("It must be an in-memory database to execute a NOUNDO delete!");
+           }
            if (table.isNoUndo()) return;
            if (table.isNoUndo(multiplex)) return;
            for (UndoLogRecord r : records) {
               Table rt = r.getTable();

     import org.h2.result.SortOrder;
     import org.h2.table.Column;
     import org.h2.table.IndexColumn;
     import org.h2.table.Table;
     import org.h2.table.TableFilter;
     import org.h2.value.*;
-...
        /** The table for which this index is made */
        private final PageStoreTable tableData;
        /** {@code true} if this table is no-undo. Only such tables do the reclaiming currently */
        /**
         * {@code true} if this table is no-undo by default. Only no-undo tables do the reclaiming
         * currently. This is the table-wide setting captured at creation;  an individual multiplex may
         * override it, so read the effective value through {@link #isNoUndo(long)} rather than here.
         */
        private final boolean noUndo;
        /**
-...
+       }
        /**
         * Get the effective no-undo option of a multiplex of this index' table.
         * <p>
         * One multiplexed table backs several logically independent tables, which need not agree on the
         * no-undo option, so every decision which depends on it has to be made per multiplex rather
         * than from the table-wide {@link #noUndo} flag.
+        *
         * @param   multiplex
         *          The multiplex to test.
+        *
         * @return  {@code true} if changes to that multiplex are not undoable.
         */
        private boolean isNoUndo(long multiplex)
+       {
           return tableData.isNoUndo((int) multiplex);
+       }
        /**
         * Remove the index object.
         */
        @Override
-...
           Long batchNr = (row.getKey() - FIRST_KEY) / BATCH_SIZE;
           Batch batch = batches.get(batchNr);
           boolean forUpdate = tableData.isUpdating();
           // the option is resolved per multiplex, and the row is what identifies which one this is
           boolean noUndo = tableData.isNoUndo(row);
           batch.remove(row, forUpdate);
           rowCount--;
-...
           if (!forUpdate && batch.isEmpty())
+          {
              // make sure we don't alter the batches if this is an update; there is an upcoming add
              long multiplex = row.getValue(1).getInt();
              long multiplex = row.getValue(Table.MULTIPLEX_COLUMN).getInt();
              Batch last = lastBatches.get(multiplex);
              // for no-undo tables the clean-up can be performed now
-...
           // 2) the investigation shown that on-disk-like pages are used and some old batches *can*
           // be reclaimed by other multiplexes as long as we know it is clean.
           // Until we have a page-like implementation, this will do.
           if (forceReclaim && table.isNoUndo())
           if (forceReclaim && isNoUndo(multiplex))
+          {
              Batch batch = lastBatches.get((long) multiplex);
              if (batch == null)
-...
           Row row = getRow(session, primaryKey);
           // we can reclaim only empty slots when rollbacking UNDO records
           if (row != null || this.noUndo)
           if (row != null || isNoUndo(multiplex))
+          {
              return false;
+          }
-...
           ArrayList<Row> removedPKs = withPKs ? new ArrayList<>() : null;
           boolean clearBatches = !withPKs;
           boolean noUndo = isNoUndo(multiplex);
           Batch batch = (clearBatches && noUndo) ? lastBatches.remove(multiplex) : lastBatches.get(multiplex);
-...
           if (batch == null)
+          {
              long multiplex = row.getValue(1).getInt();
              batch = new Batch(FIRST_KEY + batchId * BATCH_SIZE, this.noUndo, multiplex);
              batch = new Batch(FIRST_KEY + batchId * BATCH_SIZE, isNoUndo(multiplex), multiplex);
              notifyNewBatch(batch, multiplex);
              batches.put(batchId, batch);
              lastBatches.put(multiplex, batch);
-...
           if (batch == null || batch.isFull())
+          {
              long nextOffset = getAndIncNextOffset(session);
              batch = new Batch(FIRST_KEY + nextOffset * BATCH_SIZE, this.noUndo, multiplex);
              batch = new Batch(FIRST_KEY + nextOffset * BATCH_SIZE, isNoUndo(multiplex), multiplex);
              notifyNewBatch(batch, multiplex);
              batches.put(nextOffset, batch);
              lastBatches.put(multiplex, batch);

         public static final int TYPE_MEMORY = 1;
         /**
          * Index of the multiplex column in a row of a multiplexed table. The first column is always
          * the recid and the second is always the multiplex.
+         *
          * @see org.h2.pagestore.db.MultiplexedScanIndex
          */
         public static final int MULTIPLEX_COLUMN = 1;
         /**
          * The columns of this table.
          */
         protected Column[] columns;
-...
          */
         private boolean isNoUndo;
         /**
          * Per-multiplex overrides of {@link #isNoUndo}, or {@code null} when every multiplex of this
          * table follows the table-wide flag.
          * <p>
          * A multiplexed table holds several logically independent tables, discriminated by the multiplex
          * column, and they need not agree on the no-undo option. Entries are added by
          * {@link #setMultiplexNoUndo} and dropped by {@link #clearMultiplexNoUndo} when a multiplex is
          * killed. The map is left {@code null} until an override is actually needed, so a table whose
          * multiplexes all follow the table-wide flag costs a single null check per row.
          * <p>
          * No synchronization is needed: multiplexing is used only for local temporary tables, whose
          * {@code Table} instance belongs to a single session.
          */
         private HashMap<Integer, Boolean> multiplexNoUndo = null;
         private boolean isUpdating = false;
         private final HashMap<String, Column> columnMap;
-...
            this.isNoUndo = isNoUndo;
+       }
        /**
         * Set the no-undo option of a single multiplex of this table, overriding the table-wide flag.
         * <p>
         * The option has to be settable per multiplex because one multiplexed table backs several
         * logically independent tables which need not agree on it.  Set it before the multiplex holds
         * any rows;  changing it afterwards leaves the rows already written under the previous setting.
+        *
         * @param   multiplex
         *          The multiplex to set the option for.
         * @param   noUndo
         *          {@code true} if changes to this multiplex must not be undoable.
         */
        public void setMultiplexNoUndo(int multiplex, boolean noUndo) {
           if (multiplexNoUndo == null) {
              multiplexNoUndo = new HashMap<>();
+          }
           multiplexNoUndo.put(multiplex, noUndo);
+       }
        /**
         * Forget the no-undo option of a single multiplex.  This is called when a multiplex is killed,
         * so that the overrides do not accumulate for the life of the session.
+        *
         * @param   multiplex
         *          The multiplex to forget.
         */
        public void clearMultiplexNoUndo(int multiplex) {
           if (multiplexNoUndo != null) {
              multiplexNoUndo.remove(multiplex);
              if (multiplexNoUndo.isEmpty()) {
                 multiplexNoUndo = null;
+             }
+          }
+       }
        /**
         * Check whether this table carries any per-multiplex override.  A table-wide operation which
         * depends on the no-undo option cannot be applied when it does.
+        *
         * @return  {@code true} if at least one multiplex overrides the table-wide flag.
         */
        public boolean hasMultiplexNoUndo() {
           return multiplexNoUndo != null;
+       }
        /**
         * Get the effective no-undo option of a single multiplex.
+        *
         * @param   multiplex
         *          The multiplex to test.
+        *
         * @return  The override for that multiplex if there is one, else the table-wide flag.
         */
        public boolean isNoUndo(int multiplex) {
           if (multiplexNoUndo != null) {
              Boolean override = multiplexNoUndo.get(multiplex);
              if (override != null) {
                 return override;
+             }
+          }
           return isNoUndo;
+       }
        /**
         * Get the effective no-undo option for the multiplex the given row belongs to.
+        *
         * @param   row
         *          The row being written. May be {@code null}.
+        *
         * @return  The override for that row's multiplex if there is one, else the table-wide flag.
         */
        public boolean isNoUndo(Row row) {
           // the common case is a table whose multiplexes all agree, which costs only this check
           if (multiplexNoUndo == null || row == null) {
              return isNoUndo;
+          }
           Value value = row.getValue(MULTIPLEX_COLUMN);
           return (value instanceof ValueInt) ? isNoUndo(value.getInt()) : isNoUndo;
+       }
        public boolean hasIndexedColumn(int columnId)
+       {
           return true;

Project

General

Profile

FWD » Core Development » Database