Correctly update snapshot on rollback & improve TEXT handling (#522)

Author: gartens

core/src/main/java/org/polypheny/db/algebra/AlgFieldCollation.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019-2021 The Polypheny Project
+ * Copyright 2019-2024 The Polypheny Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -36,6 +36,7 @@
 
 import java.io.Serializable;
 import java.util.Objects;
+import lombok.Getter;
 import org.polypheny.db.algebra.constant.Monotonicity;
 
 
@@ -105,72 +106,52 @@ public enum Direction {
          * Converts the direction to a {@link Monotonicity}.
          */
         public Monotonicity monotonicity() {
-            switch ( this ) {
-                case ASCENDING:
-                    return Monotonicity.INCREASING;
-                case STRICTLY_ASCENDING:
-                    return Monotonicity.STRICTLY_INCREASING;
-                case DESCENDING:
-                    return Monotonicity.DECREASING;
-                case STRICTLY_DESCENDING:
-                    return Monotonicity.STRICTLY_DECREASING;
-                case CLUSTERED:
-                    return Monotonicity.MONOTONIC;
-                default:
-                    throw new AssertionError( "unknown: " + this );
-            }
+            //
+            return switch ( this ) {
+                case ASCENDING -> Monotonicity.INCREASING;
+                case STRICTLY_ASCENDING -> Monotonicity.STRICTLY_INCREASING;
+                case DESCENDING -> Monotonicity.DECREASING;
+                case STRICTLY_DESCENDING -> Monotonicity.STRICTLY_DECREASING;
+                case CLUSTERED -> Monotonicity.MONOTONIC;
+            };
         }
 
 
         /**
          * Converts a {@link Monotonicity} to a direction.
          */
         public static Direction of( Monotonicity monotonicity ) {
-            switch ( monotonicity ) {
-                case INCREASING:
-                    return ASCENDING;
-                case DECREASING:
-                    return DESCENDING;
-                case STRICTLY_INCREASING:
-                    return STRICTLY_ASCENDING;
-                case STRICTLY_DECREASING:
-                    return STRICTLY_DESCENDING;
-                case MONOTONIC:
-                    return CLUSTERED;
-                default:
-                    throw new AssertionError( "unknown: " + monotonicity );
-            }
+            return switch ( monotonicity ) {
+                case INCREASING -> ASCENDING;
+                case DECREASING -> DESCENDING;
+                case STRICTLY_INCREASING -> STRICTLY_ASCENDING;
+                case STRICTLY_DECREASING -> STRICTLY_DESCENDING;
+                case MONOTONIC -> CLUSTERED;
+                case CONSTANT, NOT_MONOTONIC -> throw new UnsupportedOperationException( "Cannot convert monotonicity " + monotonicity + " into a direction" );
+            };
         }
 
 
         /**
          * Returns the null direction if not specified. Consistent with Oracle, NULLS are sorted as if they were positive infinity.
          */
         public NullDirection defaultNullDirection() {
-            switch ( this ) {
-                case ASCENDING:
-                case STRICTLY_ASCENDING:
-                    return NullDirection.LAST;
-                case DESCENDING:
-                case STRICTLY_DESCENDING:
-                    return NullDirection.FIRST;
-                default:
-                    return NullDirection.UNSPECIFIED;
-            }
+            return switch ( this ) {
+                case ASCENDING, STRICTLY_ASCENDING -> NullDirection.LAST;
+                case DESCENDING, STRICTLY_DESCENDING -> NullDirection.FIRST;
+                default -> NullDirection.UNSPECIFIED;
+            };
         }
 
 
         /**
          * Returns whether this is {@link #DESCENDING} or {@link #STRICTLY_DESCENDING}.
          */
         public boolean isDescending() {
-            switch ( this ) {
-                case DESCENDING:
-                case STRICTLY_DESCENDING:
-                    return true;
-                default:
-                    return false;
-            }
+            return switch ( this ) {
+                case DESCENDING, STRICTLY_DESCENDING -> true;
+                default -> false;
+            };
         }
     }
 
@@ -195,11 +176,13 @@ public enum NullDirection {
     /**
      * 0-based index of field being sorted.
      */
+    @Getter
     private final int fieldIndex;
 
     /**
      * Direction of sorting.
      */
+    @Getter
     public final Direction direction;
 
     /**
@@ -269,16 +252,6 @@ public int hashCode() {
     }
 
 
-    public int getFieldIndex() {
-        return fieldIndex;
-    }
-
-
-    public AlgFieldCollation.Direction getDirection() {
-        return direction;
-    }
-
-
     public String toString() {
         if ( direction == Direction.ASCENDING && nullDirection == direction.defaultNullDirection() ) {
             return String.valueOf( fieldIndex );
@@ -296,14 +269,11 @@ public String shortString() {
         if ( nullDirection == direction.defaultNullDirection() ) {
             return direction.shortString;
         }
-        switch ( nullDirection ) {
-            case FIRST:
-                return direction.shortString + "-nulls-first";
-            case LAST:
-                return direction.shortString + "-nulls-last";
-            default:
-                return direction.shortString;
-        }
+        return switch ( nullDirection ) {
+            case FIRST -> direction.shortString + "-nulls-first";
+            case LAST -> direction.shortString + "-nulls-last";
+            default -> direction.shortString;
+        };
     }
 
 }

core/src/main/java/org/polypheny/db/algebra/constant/Monotonicity.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019-2021 The Polypheny Project
+ * Copyright 2019-2024 The Polypheny Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -72,22 +72,6 @@ public Monotonicity reverse() {
     }
 
 
-    /**
-     * Whether values of this monotonicity are decreasing. That is, if a value at a given point in a sequence is X, no point later in the sequence will have a value greater than X.
-     *
-     * @return whether values are decreasing
-     */
-    public boolean isDecreasing() {
-        switch ( this ) {
-            case STRICTLY_DECREASING:
-            case DECREASING:
-                return true;
-            default:
-                return false;
-        }
-    }
-
-
     /**
      * Returns whether values of this monotonicity may ever repeat after moving to another value: true for {@link #NOT_MONOTONIC} and {@link #CONSTANT}, false otherwise.
      *
@@ -105,4 +89,3 @@ public boolean mayRepeat() {
         }
     }
 }
-

core/src/main/java/org/polypheny/db/algebra/metadata/AlgMdColumnUniqueness.java

@@ -154,12 +154,9 @@ public Boolean areColumnsUnique( Exchange alg, AlgMetadataQuery mq, ImmutableBit
 
 
     public Boolean areColumnsUnique( Correlate alg, AlgMetadataQuery mq, ImmutableBitSet columns, boolean ignoreNulls ) {
-        switch ( alg.getJoinType() ) {
-            case ANTI:
-            case SEMI:
-                return mq.areColumnsUnique( alg.getLeft(), columns, ignoreNulls );
-            case LEFT:
-            case INNER:
+        return switch ( alg.getJoinType() ) {
+            case ANTI, SEMI -> mq.areColumnsUnique( alg.getLeft(), columns, ignoreNulls );
+            case LEFT, INNER -> {
                 final Pair<ImmutableBitSet, ImmutableBitSet> leftAndRightColumns = splitLeftAndRightColumns( alg.getLeft().getTupleType().getFieldCount(), columns );
                 final ImmutableBitSet leftColumns = leftAndRightColumns.left;
                 final ImmutableBitSet rightColumns = leftAndRightColumns.right;
@@ -170,16 +167,15 @@ public Boolean areColumnsUnique( Correlate alg, AlgMetadataQuery mq, ImmutableBi
                     Boolean leftUnique = mq.areColumnsUnique( left, leftColumns, ignoreNulls );
                     Boolean rightUnique = mq.areColumnsUnique( right, rightColumns, ignoreNulls );
                     if ( leftUnique == null || rightUnique == null ) {
-                        return null;
+                        yield null;
                     } else {
-                        return leftUnique && rightUnique;
+                        yield leftUnique && rightUnique;
                     }
                 } else {
-                    return null;
+                    yield null;
                 }
-            default:
-                throw new IllegalStateException( "Unknown join type " + alg.getJoinType() + " for correlate relation " + alg );
-        }
+            }
+        };
     }
 
 

core/src/main/java/org/polypheny/db/algebra/rules/JoinToCorrelateRule.java

@@ -51,7 +51,6 @@
 import org.polypheny.db.tools.AlgBuilderFactory;
 import org.polypheny.db.util.ImmutableBitSet;
 import org.polypheny.db.util.ImmutableBitSet.Builder;
-import org.polypheny.db.util.Util;
 
 
 /**
@@ -85,16 +84,10 @@ public JoinToCorrelateRule( AlgBuilderFactory algBuilderFactory ) {
     @Override
     public boolean matches( AlgOptRuleCall call ) {
         LogicalRelJoin join = call.alg( 0 );
-        switch ( join.getJoinType() ) {
-            case INNER:
-            case LEFT:
-                return true;
-            case FULL:
-            case RIGHT:
-                return false;
-            default:
-                throw Util.unexpected( join.getJoinType() );
-        }
+        return switch ( join.getJoinType() ) {
+            case INNER, LEFT -> true;
+            case FULL, RIGHT -> false;
+        };
     }
 
 
@@ -132,4 +125,3 @@ public RexNode visitIndexRef( RexIndexRef input ) {
     }
 
 }
-

core/src/main/java/org/polypheny/db/algebra/rules/PushProjector.java

@@ -206,20 +206,12 @@ public PushProjector( Project origProj, RexNode origFilter, AlgNode childRel, Ex
             childBitmap = ImmutableBitSet.range( 0, nFields );
             rightBitmap = ImmutableBitSet.range( nFields, nChildFields );
 
-            switch ( joinRel.getJoinType() ) {
-                case INNER:
-                    strongBitmap = ImmutableBitSet.of();
-                    break;
-                case RIGHT:  // All the left-input's columns must be strong
-                    strongBitmap = ImmutableBitSet.range( 0, nFields );
-                    break;
-                case LEFT: // All the right-input's columns must be strong
-                    strongBitmap = ImmutableBitSet.range( nFields, nChildFields );
-                    break;
-                case FULL:
-                default:
-                    strongBitmap = ImmutableBitSet.range( 0, nChildFields );
-            }
+            strongBitmap = switch ( joinRel.getJoinType() ) {
+                case INNER -> ImmutableBitSet.of();
+                case RIGHT -> ImmutableBitSet.range( 0, nFields );// All the left-input's columns must be strong
+                case LEFT -> ImmutableBitSet.range( nFields, nChildFields );// All the right-input's columns must be strong
+                case FULL -> ImmutableBitSet.range( 0, nChildFields );
+            };
 
         } else if ( childRel instanceof Correlate corrAlg ) {
             List<AlgDataTypeField> leftFields = corrAlg.getLeft().getTupleType().getFields();
@@ -240,20 +232,11 @@ public PushProjector( Project origProj, RexNode origFilter, AlgNode childRel, Ex
             // Required columns need to be included in project
             projRefs.or( BitSets.of( corrAlg.getRequiredColumns() ) );
 
-            switch ( joinType ) {
-                case INNER:
-                    strongBitmap = ImmutableBitSet.of();
-                    break;
-                case ANTI:
-                case SEMI:  // All the left-input's columns must be strong
-                    strongBitmap = ImmutableBitSet.range( 0, nFields );
-                    break;
-                case LEFT: // All the right-input's columns must be strong
-                    strongBitmap = ImmutableBitSet.range( nFields, nChildFields );
-                    break;
-                default:
-                    strongBitmap = ImmutableBitSet.range( 0, nChildFields );
-            }
+            strongBitmap = switch ( joinType ) {
+                case INNER -> ImmutableBitSet.of();
+                case ANTI, SEMI -> ImmutableBitSet.range( 0, nFields ); // All the left-input's columns must be strong
+                case LEFT -> ImmutableBitSet.range( nFields, nChildFields ); // All the right-input's columns must be strong
+            };
         } else {
             nFields = nChildFields;
             nFieldsRight = 0;

core/src/main/java/org/polypheny/db/catalog/impl/PolyCatalog.java

@@ -107,6 +107,8 @@ public class PolyCatalog extends Catalog implements PolySerializable {
     private final Collection<ConstraintCondition> commitConstraints = new ConcurrentLinkedDeque<>();
     private final Collection<Runnable> commitActions = new ConcurrentLinkedDeque<>();
 
+    // indicates if the state has advanced and the snapshot has to be recreated or can be reused // trx without ddl
+    private long lastCommitSnapshotId = 0;
 
     @Serialize
     @JsonProperty
@@ -267,6 +269,8 @@ public synchronized void commit() {
         this.dirty.set( false );
         this.commitConstraints.clear();
         this.commitActions.clear();
+
+        this.lastCommitSnapshotId = snapshot.id();
     }
 
 
@@ -288,19 +292,18 @@ public synchronized void commit() {
 
 
     public void rollback() {
-        long id = snapshot.id();
-
         commitActions.clear();
         commitConstraints.clear();
 
         restoreLastState();
 
         log.debug( "rollback" );
 
-        if ( id != snapshot.id() ) {
+        if ( lastCommitSnapshotId != snapshot.id() ) {
             updateSnapshot();
-        }
 
+            lastCommitSnapshotId = snapshot.id();
+        }
     }
 
 

core/src/main/java/org/polypheny/db/catalog/logistic/EntityType.java

@@ -17,9 +17,6 @@
 package org.polypheny.db.catalog.logistic;
 
 import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import org.polypheny.db.type.entity.PolyString;
-import org.polypheny.db.type.entity.PolyValue;
 
 @Getter
 public enum EntityType {
@@ -36,18 +33,4 @@ public enum EntityType {
         this.id = id;
     }
 
-
-    // Used for creating ResultSets
-    public PolyValue[] getParameterArray() {
-        return new PolyValue[]{ PolyString.of( name() ) };
-    }
-
-
-    // Required for building JDBC result set
-    @RequiredArgsConstructor
-    public static class PrimitiveTableType {
-
-        public final String tableType;
-
-    }
 }