Merge lp:~nwilliams/akiban-server/types2-elimination-part-1 into lp:~akiban-technologies/akiban-server/trunk

[Nathan Williams]

Eliminate usePvalues boolean from API and API.Ordering.

First pass of many to come. Entirely delete parameter, adjust, and collapse if(Types3Switch) blocks if edits were made in the area.

Includes new static check at start-up for a bigger warning should anything else (e.g. FTS) still be switching to 2.

Yaml test tweaks:
- Cache, setting to 'true' still clears as intended
- Year, no longer worry about types2 behavior
- Decimal, don't worry about value inserted under types2

[Thomas Jones-Low (tjoneslo)]

This look like a lot of unused code being deleted.

review: Approve

[Akiban Build User (build-akiban)]

There were 2 failures during build/test:

* job system-tests-mtr failed at build number 3455: http://172.16.20.104:8080/job/system-tests-mtr/3455/

* view must-pass failed: system-tests-mtr is red

review: Needs Fixing

[Thomas Jones-Low (tjoneslo)]

Unrelated.

review: Approve

=== modified file 'src/main/java/com/akiban/qp/operator/API.java'
--- src/main/java/com/akiban/qp/operator/API.java	2013-03-22 20:05:57 +0000
+++ src/main/java/com/akiban/qp/operator/API.java	2013-04-30 23:23:36 +0000
@@ -30,8 +30,6 @@
 import com.akiban.server.aggregation.Aggregators;
 import com.akiban.server.collation.AkCollator;
 import com.akiban.server.expression.Expression;
-import com.akiban.server.expression.std.FieldExpression;
-import com.akiban.server.t3expressions.T3RegistryService;
 import com.akiban.server.types.AkType;
 import com.akiban.server.types3.TAggregator;
 import com.akiban.server.types3.TComparison;
@@ -44,6 +42,8 @@
 
 public class API
 {
+    private static final boolean USE_PVALUES = Types3Switch.ON;
+
     // Aggregate
 
     public static Operator aggregate_Partial(Operator inputOperator,
@@ -237,30 +237,16 @@
 
     public static Operator limit_Default(Operator inputOperator, int limitRows)
     {
-        return limit_Default(inputOperator, limitRows, Types3Switch.ON);
-    }
-
-    public static Operator limit_Default(Operator inputOperator, int limitRows, boolean usePVals)
-    {
-        return new Limit_Default(inputOperator, limitRows, usePVals);
-    }
-
-    public static Operator limit_Default(Operator inputOperator,
-                                         int skipRows,
-                                         boolean skipIsBinding,
-                                         int limitRows,
-                                         boolean limitIsBinding)
-    {
-        return limit_Default(inputOperator, skipRows, skipIsBinding, limitRows, limitIsBinding, Types3Switch.ON);
-    }
+        return new Limit_Default(inputOperator, limitRows, Types3Switch.ON);
+    }
+
     public static Operator limit_Default(Operator inputOperator,
                                                  int skipRows,
                                                  boolean skipIsBinding,
                                                  int limitRows,
-                                                 boolean limitIsBinding,
-                                                 boolean usePVals)
+                                                 boolean limitIsBinding)
     {
-        return new Limit_Default(inputOperator, skipRows, skipIsBinding, limitRows, limitIsBinding, usePVals);
+        return new Limit_Default(inputOperator, skipRows, skipIsBinding, limitRows, limitIsBinding, Types3Switch.ON);
     }
 
     // AncestorLookup
@@ -289,14 +275,13 @@
      * tableType
      * @param indexType the index to scan
      * @return the scan operator
-     * @deprecated use {@link #indexScan_Default(IndexRowType, IndexKeyRange, Ordering, IndexScanSelector, boolean)}
+     * @deprecated use {@link #indexScan_Default(IndexRowType, IndexKeyRange, Ordering, IndexScanSelector)}
      */
     @Deprecated
     @SuppressWarnings("deprecation")
     public static Operator indexScan_Default(IndexRowType indexType)
     {
-        boolean usePValues = Types3Switch.ON;
-        return indexScan_Default(indexType, false, IndexKeyRange.unbounded(indexType, usePValues), usePValues);
+        return indexScan_Default(indexType, false, IndexKeyRange.unbounded(indexType, USE_PVALUES));
     }
 
     /**
@@ -305,43 +290,30 @@
      * @param indexType the index to scan
      * @param reverse whether to scan in reverse order
      * @return the scan operator
-     * @deprecated use {@link #indexScan_Default(IndexRowType, IndexKeyRange, Ordering, IndexScanSelector, boolean)}
+     * @deprecated use {@link #indexScan_Default(IndexRowType, IndexKeyRange, Ordering, IndexScanSelector)}
      */
     @Deprecated
     @SuppressWarnings("deprecation")
     public static Operator indexScan_Default(IndexRowType indexType, boolean reverse)
     {
-        boolean usePValues = Types3Switch.ON;
-        return indexScan_Default(indexType, reverse, IndexKeyRange.unbounded(indexType, usePValues), usePValues);
+        return indexScan_Default(indexType, reverse, IndexKeyRange.unbounded(indexType, USE_PVALUES));
     }
 
+    /**
+     * Creates a scan operator for the given index, using LEFT JOIN semantics after the indexType's tableType.
+     * @param indexType the index to scan
+     * @param reverse whether to scan in reverse order
+     * @param indexKeyRange the scan range
+     * @return the scan operator
+     * @deprecated use {@link #indexScan_Default(IndexRowType, IndexKeyRange, Ordering, IndexScanSelector)}
+     */
+    @Deprecated
     public static Operator indexScan_Default(IndexRowType indexType, boolean reverse, IndexKeyRange indexKeyRange)
     {
-        return indexScan_Default(indexType, reverse, indexKeyRange, Types3Switch.ON);
-    }
-    /**
-     * Creates a scan operator for the given index, using LEFT JOIN semantics after the indexType's tableType.
-     * @param indexType the index to scan
-     * @param reverse whether to scan in reverse order
-     * @param indexKeyRange the scan range
-     * @return the scan operator
-     * @deprecated use {@link #indexScan_Default(IndexRowType, IndexKeyRange, Ordering, IndexScanSelector, boolean)}
-     */
-    @Deprecated
-    @SuppressWarnings("deprecation")
-    public static Operator indexScan_Default(IndexRowType indexType, boolean reverse, IndexKeyRange indexKeyRange, boolean usePValues)
-    {
         if (indexKeyRange == null) {
-            indexKeyRange = IndexKeyRange.unbounded(indexType, usePValues);
+            indexKeyRange = IndexKeyRange.unbounded(indexType, USE_PVALUES);
         }
-        return indexScan_Default(indexType, reverse, indexKeyRange, indexType.tableType(), usePValues);
-    }
-    public static Operator indexScan_Default(IndexRowType indexType,
-                                             boolean reverse,
-                                             IndexKeyRange indexKeyRange,
-                                             UserTableRowType innerJoinUntilRowType)
-    {
-        return indexScan_Default(indexType, reverse, indexKeyRange, innerJoinUntilRowType, Types3Switch.ON);
+        return indexScan_Default(indexType, reverse, indexKeyRange, indexType.tableType());
     }
 
     /**
@@ -351,28 +323,27 @@
      * @param indexKeyRange the scan range
      * @param innerJoinUntilRowType the table after which the scan should start using LEFT JOIN GI semantics.
      * @return the scan operator
-     * @deprecated use {@link #indexScan_Default(IndexRowType, IndexKeyRange, Ordering, IndexScanSelector, boolean)}
+     * @deprecated use {@link #indexScan_Default(IndexRowType, IndexKeyRange, Ordering, IndexScanSelector)}
      */
     @Deprecated
     public static Operator indexScan_Default(IndexRowType indexType,
                                              boolean reverse,
                                              IndexKeyRange indexKeyRange,
-                                             UserTableRowType innerJoinUntilRowType,
-                                             boolean usePVals)
+                                             UserTableRowType innerJoinUntilRowType)
     {
-        Ordering ordering = new Ordering(usePVals);
+        Ordering ordering = new Ordering();
         int fields = indexType.nFields();
-        if (usePVals) {
-            for (int f = 0; f < fields; f++) {
-                ordering.append(null, new TPreparedField(indexType.typeInstanceAt(f), f), !reverse);
-            }
-        }
-        else {
-            for (int f = 0; f < fields; f++) {
-                ordering.append(new FieldExpression(indexType, f), null, !reverse);
-            }
-        }
-        return indexScan_Default(indexType, indexKeyRange, ordering, innerJoinUntilRowType, usePVals);
+        for (int f = 0; f < fields; f++) {
+            ordering.append(new TPreparedField(indexType.typeInstanceAt(f), f), !reverse);
+        }
+        return indexScan_Default(indexType, indexKeyRange, ordering, innerJoinUntilRowType);
+    }
+
+    public static Operator indexScan_Default(IndexRowType indexType,
+                                             IndexKeyRange indexKeyRange,
+                                             Ordering ordering)
+    {
+        return indexScan_Default(indexType, indexKeyRange, ordering, indexType.tableType());
     }
 
     /**
@@ -382,43 +353,20 @@
      * @param indexKeyRange the scan range
      * @param indexScanSelector
      * @return the scan operator
-     * @deprecated use {@link #indexScan_Default(IndexRowType, IndexKeyRange, Ordering, IndexScanSelector, boolean)}
+     * @deprecated use {@link #indexScan_Default(IndexRowType, IndexKeyRange, Ordering, IndexScanSelector)}
      */
     @Deprecated
     public static Operator indexScan_Default(IndexRowType indexType,
                                              boolean reverse,
                                              IndexKeyRange indexKeyRange,
-                                             IndexScanSelector indexScanSelector,
-                                             boolean usePVals)
+                                             IndexScanSelector indexScanSelector)
     {
-        Ordering ordering = new Ordering(usePVals);
+        Ordering ordering = new Ordering();
         int fields = indexType.nFields();
-        if (usePVals) {
-            for (int f = 0; f < fields; f++) {
-                ordering.append(null, new TPreparedField(indexType.typeInstanceAt(f), f), !reverse);
-            }
-        }
-        else {
-            for (int f = 0; f < fields; f++) {
-                ordering.append(new FieldExpression(indexType, f), null, !reverse);
-            }
-        }
-        return indexScan_Default(indexType, indexKeyRange, ordering, indexScanSelector, usePVals);
-    }
-
-    public static Operator indexScan_Default(IndexRowType indexType,
-                                             IndexKeyRange indexKeyRange,
-                                             Ordering ordering)
-    {
-        return indexScan_Default(indexType, indexKeyRange, ordering, Types3Switch.ON);
-    }
-
-    public static Operator indexScan_Default(IndexRowType indexType,
-                                             IndexKeyRange indexKeyRange,
-                                             Ordering ordering,
-                                             boolean usePVals)
-    {
-        return indexScan_Default(indexType, indexKeyRange, ordering, indexType.tableType(), usePVals);
+        for (int f = 0; f < fields; f++) {
+            ordering.append(new TPreparedField(indexType.typeInstanceAt(f), f), !reverse);
+        }
+        return indexScan_Default(indexType, indexKeyRange, ordering, indexScanSelector);
     }
 
     public static Operator indexScan_Default(IndexRowType indexType,
@@ -426,20 +374,11 @@
                                              Ordering ordering,
                                              UserTableRowType innerJoinUntilRowType)
     {
-        return indexScan_Default(indexType, indexKeyRange, ordering, innerJoinUntilRowType, Types3Switch.ON);
-    }
-
-    public static Operator indexScan_Default(IndexRowType indexType,
-                                             IndexKeyRange indexKeyRange,
-                                             Ordering ordering,
-                                             UserTableRowType innerJoinUntilRowType,
-                                             boolean usePVals)
-    {
         return indexScan_Default(indexType,
                                  indexKeyRange,
                                  ordering,
                                  IndexScanSelector.leftJoinAfter(indexType.index(),
-                                                                 innerJoinUntilRowType.userTable()), usePVals);
+                                                                 innerJoinUntilRowType.userTable()));
     }
 
     public static Operator indexScan_Default(IndexRowType indexType,
@@ -447,17 +386,7 @@
                                              Ordering ordering,
                                              IndexScanSelector indexScanSelector)
     {
-        return new IndexScan_Default(indexType, indexKeyRange, ordering, indexScanSelector, Types3Switch.ON);
-    }
-
-
-    public static Operator indexScan_Default(IndexRowType indexType,
-                                             IndexKeyRange indexKeyRange,
-                                             Ordering ordering,
-                                             IndexScanSelector indexScanSelector,
-                                             boolean usePVals)
-    {
-        return new IndexScan_Default(indexType, indexKeyRange, ordering, indexScanSelector, usePVals);
+        return new IndexScan_Default(indexType, indexKeyRange, ordering, indexScanSelector, USE_PVALUES);
     }
 
     // Select
@@ -519,25 +448,12 @@
     public static Operator count_Default(Operator input,
                                          RowType countType)
     {
-        return new Count_Default(input, countType, Types3Switch.ON);
-    }
-
-    public static Operator count_Default(Operator input,
-                                         RowType countType,
-                                         boolean usePValues)
-    {
-        return new Count_Default(input, countType, usePValues);
+        return new Count_Default(input, countType, USE_PVALUES);
     }
 
     public static Operator count_TableStatus(RowType tableType)
     {
-        return count_TableStatus(tableType, Types3Switch.ON);
-    }
-
-
-    public static Operator count_TableStatus(RowType tableType, boolean usePValues)
-    {
-        return new Count_TableStatus(tableType, usePValues);
+        return new Count_TableStatus(tableType, USE_PVALUES);
     }
 
     // Sort
@@ -556,40 +472,25 @@
                                      Ordering ordering,
                                      SortOption sortOption)
     {
-        return new Sort_Tree(inputOperator, sortType, ordering, sortOption, Types3Switch.ON);
-    }
-
-    public static Operator sort_Tree(Operator inputOperator, 
-                                     RowType sortType, 
-                                     Ordering ordering, 
-                                     SortOption sortOption,
-                                     boolean usePVals)
-    {
-        return new Sort_Tree(inputOperator, sortType, ordering, sortOption, usePVals);
+        return new Sort_Tree(inputOperator, sortType, ordering, sortOption, USE_PVALUES);
     }
 
     public static Ordering ordering()
     {
-        return ordering(Types3Switch.ON);
-    }
-    
-    public static Ordering ordering(boolean usePVals)
-    {
-        return new Ordering(usePVals);
+        return new Ordering();
     }
 
     // Distinct
     public static Operator distinct_Partial(Operator input, RowType distinctType)
     {
-        return new Distinct_Partial(input, distinctType, null, Types3Switch.ON);
+        return new Distinct_Partial(input, distinctType, null, USE_PVALUES);
     }
 
     public static Operator distinct_Partial(Operator input,
                                             RowType distinctType,
-                                            List<AkCollator> collators,
-                                            boolean usePValues)
+                                            List<AkCollator> collators)
     {
-        return new Distinct_Partial(input, distinctType, collators, usePValues);
+        return new Distinct_Partial(input, distinctType, collators, USE_PVALUES);
     }
 
     // Map
@@ -622,33 +523,11 @@
 
     public static Operator unionAll(Operator input1, RowType input1RowType, Operator input2, RowType input2RowType)
     {
-        return unionAll(input1, input1RowType, input2, input2RowType, Types3Switch.ON);
-    }
-
-    public static Operator unionAll(Operator input1, RowType input1RowType, Operator input2, RowType input2RowType,
-                                    boolean usePvalues)
-    {
-        return new UnionAll_Default(input1, input1RowType, input2, input2RowType, usePvalues);
+        return new UnionAll_Default(input1, input1RowType, input2, input2RowType, USE_PVALUES);
     }
     
     // Intersect
     
-    /** deprecated */
-
-    public static Operator intersect_Ordered(Operator leftInput, Operator rightInput,
-                                             IndexRowType leftRowType, IndexRowType rightRowType,
-                                             int leftOrderingFields,
-                                             int rightOrderingFields,
-                                             int comparisonFields,
-                                             JoinType joinType,
-                                             IntersectOption intersectOutput,
-                                             List<TComparison> comparisons)
-    {
-        return intersect_Ordered(leftInput, rightInput,  leftRowType, rightRowType,
-                leftOrderingFields, rightOrderingFields, comparisonFields, joinType, intersectOutput,
-                Types3Switch.ON, comparisons);
-    }
-
     public static Operator intersect_Ordered(Operator leftInput, Operator rightInput,
                                             IndexRowType leftRowType, IndexRowType rightRowType,
                                             int leftOrderingFields,
@@ -656,7 +535,6 @@
                                             int comparisonFields,
                                             JoinType joinType,
                                             IntersectOption intersectOutput,
-                                            boolean usePValues,
                                             List<TComparison> comparisons)
     {
         if (comparisonFields < 0) {
@@ -671,38 +549,17 @@
                                      ascending,
                                      joinType,
                                      EnumSet.of(intersectOutput),
-                                     usePValues,
+                                     USE_PVALUES,
                                      comparisons);
     }
 
     public static Operator intersect_Ordered(Operator leftInput, Operator rightInput,
-                                             IndexRowType leftRowType, IndexRowType rightRowType,
-                                             int leftOrderingFields,
-                                             int rightOrderingFields,
-                                             boolean[] ascending,
-                                             JoinType joinType,
-                                             EnumSet<IntersectOption> intersectOptions,
-                                             List<TComparison> comparisons)
-    {
-        return new Intersect_Ordered(leftInput, rightInput,
-                leftRowType, rightRowType,
-                leftOrderingFields,
-                rightOrderingFields,
-                ascending,
-                joinType,
-                intersectOptions,
-                Types3Switch.ON,
-                comparisons);
-    }
-
-    public static Operator intersect_Ordered(Operator leftInput, Operator rightInput,
                                             IndexRowType leftRowType, IndexRowType rightRowType,
                                             int leftOrderingFields,
                                             int rightOrderingFields,
                                             boolean[] ascending,
                                             JoinType joinType,
                                             EnumSet<IntersectOption> intersectOptions,
-                                            boolean usePValues,
                                             List<TComparison> comparisons)
     {
         return new Intersect_Ordered(leftInput, rightInput,
@@ -712,7 +569,7 @@
                                      ascending,
                                      joinType,
                                      intersectOptions,
-                                     usePValues,
+                                     USE_PVALUES,
                                      comparisons);
     }
     
@@ -726,27 +583,11 @@
                                          boolean outputEqual)
     {
         return new Union_Ordered(leftInput, rightInput,
-                leftRowType, rightRowType,
-                leftOrderingFields,
-                rightOrderingFields,
-                ascending, outputEqual,
-                Types3Switch.ON);
-    }
-
-    public static Operator union_Ordered(Operator leftInput, Operator rightInput,
-                                         IndexRowType leftRowType, IndexRowType rightRowType,
-                                         int leftOrderingFields,
-                                         int rightOrderingFields,
-                                         boolean[] ascending,
-                                         boolean outputEqual,
-                                         boolean usePValues)
-    {
-        return new Union_Ordered(leftInput, rightInput,
                                  leftRowType, rightRowType,
                                  leftOrderingFields,
                                  rightOrderingFields,
                                  ascending, outputEqual,
-                                 usePValues);
+                                 USE_PVALUES);
     }
 
     // HKeyUnion
@@ -778,7 +619,7 @@
                                      filterBindingPosition,
                                      streamInput,
                                      null,
-                                     Types3Switch.ON);
+                                     USE_PVALUES);
     }
 
     public static Operator using_BloomFilter(Operator filterInput,
@@ -786,8 +627,7 @@
                                              long estimatedRowCount,
                                              int filterBindingPosition,
                                              Operator streamInput,
-                                             List<AkCollator> collators,
-                                             boolean usePValues)
+                                             List<AkCollator> collators)
     {
         return new Using_BloomFilter(filterInput,
                                      filterRowType,
@@ -795,7 +635,7 @@
                                      filterBindingPosition,
                                      streamInput,
                                      collators,
-                                     usePValues);
+                                     USE_PVALUES);
     }
 
     // Select_BloomFilter
@@ -863,17 +703,12 @@
     // Insert
     public static UpdatePlannable insert_Default(Operator inputOperator)
     {
-        return insert_Default(inputOperator, Types3Switch.ON);
-    }
-
-    public static UpdatePlannable insert_Default(Operator inputOperator, boolean usePVals)
-    {
-        return new Insert_Default(inputOperator, usePVals);
-    }
-
-    public static Operator insert_Returning (Operator inputOperator, boolean usePVals) 
-    {
-        return new Insert_Returning (inputOperator, usePVals);
+        return new Insert_Default(inputOperator, USE_PVALUES);
+    }
+
+    public static Operator insert_Returning (Operator inputOperator)
+    {
+        return new Insert_Returning(inputOperator, USE_PVALUES);
     }
 
     // Update
@@ -885,22 +720,21 @@
     }
     
     public static Operator update_Returning (Operator inputOperator,
-                                            UpdateFunction updateFunction, 
-                                            boolean usePValues)
+                                            UpdateFunction updateFunction)
     {
-        return new Update_Returning (inputOperator, updateFunction, usePValues);
+        return new Update_Returning (inputOperator, updateFunction, USE_PVALUES);
     }
     
     // Delete
 
-    public static UpdatePlannable delete_Default(Operator inputOperator, boolean usePValues)
+    public static UpdatePlannable delete_Default(Operator inputOperator)
     {
-        return new Delete_Default(inputOperator, usePValues);
+        return new Delete_Default(inputOperator, USE_PVALUES);
     }
 
-    public static Operator delete_Returning (Operator inputOperator, boolean usePValues, boolean cascadeDelete)
+    public static Operator delete_Returning (Operator inputOperator, boolean cascadeDelete)
     {
-        return new Delete_Returning(inputOperator, usePValues, cascadeDelete);
+        return new Delete_Returning(inputOperator, USE_PVALUES, cascadeDelete);
     }
 
     // Execution interface
@@ -961,7 +795,7 @@
         {
             StringBuilder buffer = new StringBuilder();
             buffer.append('(');
-            List<?> exprs = usingPVals() ? tExpressions : oExpressions;
+            List<?> exprs = tExpressions;
             for (int i = 0, size = sortColumns(); i < size; i++) {
                 if (i > 0) {
                     buffer.append(", ");
@@ -976,22 +810,13 @@
 
         public int sortColumns()
         {
-            return usingPVals() ? tExpressions.size() : oExpressions.size();
+            return tExpressions.size();
         }
 
-        public Expression expression(int i) {
-            return oExpressions.get(i);
-        }
-        
         public TPreparedExpression tExpression(int i) {
             return tExpressions.get(i);
         }
 
-        public AkType type(int i)
-        {
-            return oExpressions.get(i).valueType();
-        }
-        
         public TInstance tInstance(int i) {
             return tExpressions.get(i).resultType();
         }
@@ -1031,87 +856,43 @@
         public void append(ExpressionGenerator expressionGenerator, boolean ascending)
         {
             TPreparedExpression newExpr;
-            Expression oldExpr;
-            if (Types3Switch.ON) {
-                newExpr = expressionGenerator.getTPreparedExpression();
-                oldExpr = null;
-            }
-            else {
-                newExpr = null;
-                oldExpr = expressionGenerator.getExpression();
-            }
-            append(oldExpr, newExpr, ascending);
-        }
-
-        public void append(Expression expression, boolean ascending)
-        {
-            append(expression, null, ascending);
-        }
-
-        public void append(Expression expression, TPreparedExpression tExpression, boolean ascending)
-        {
-            append(expression, tExpression, ascending, null);
+            newExpr = expressionGenerator.getTPreparedExpression();
+            append(newExpr, ascending);
+        }
+
+        public void append(TPreparedExpression tExpression, boolean ascending)
+        {
+            append(tExpression, ascending, null);
         }
         
         public void append(ExpressionGenerator expression, boolean ascending, AkCollator collator)
         {
-            Expression oldStyle;
             TPreparedExpression newStyle;
-            if (Types3Switch.ON) {
-                newStyle = expression.getTPreparedExpression();
-                oldStyle = null;
-            }
-            else {
-                newStyle = null;
-                oldStyle = expression.getExpression();
-            }
-            append(oldStyle, newStyle, ascending, collator);
+            newStyle = expression.getTPreparedExpression();
+            append(newStyle, ascending, collator);
         }
 
-        public void append(Expression expression, TPreparedExpression tExpression,  boolean ascending,
+        public void append(TPreparedExpression tExpression,  boolean ascending,
                            AkCollator collator)
         {
-            if (oExpressions != null)
-                oExpressions.add(expression);
-            else
-                tExpressions.add(tExpression);
+            tExpressions.add(tExpression);
             directions.add(ascending);
             collators.add(collator);
         }
 
         public Ordering copy()
         {
-            boolean pvals = usingPVals();
-            Ordering copy = new Ordering(pvals);
-            if (pvals)
-                copy.tExpressions.addAll(tExpressions);
-            else
-                copy.oExpressions.addAll(oExpressions);
+            Ordering copy = new Ordering();
+            copy.tExpressions.addAll(tExpressions);
             copy.directions.addAll(directions);
             copy.collators.addAll(collators);
             return copy;
         }
-        
-        public boolean usingPVals() {
-            return tExpressions != null;
-        }
-        
+
         public Ordering() {
-            this(Types3Switch.ON);
-        }
-        
-        private Ordering(boolean usePVals) {
-            if (usePVals) {
-                tExpressions = new ArrayList<>();
-                oExpressions = null; 
-            }
-            else {
-                tExpressions = null;
-                oExpressions = new ArrayList<>();
-            }
+            tExpressions = new ArrayList<>();
         }
 
-        private final List<com.akiban.server.expression.Expression> oExpressions;
         private final List<TPreparedExpression> tExpressions;
         private final List<Boolean> directions = new ArrayList<>(); // true: ascending, false: descending
         private final List<AkCollator> collators = new ArrayList<>();

=== modified file 'src/main/java/com/akiban/qp/operator/Sort_InsertionLimited.java'
--- src/main/java/com/akiban/qp/operator/Sort_InsertionLimited.java	2013-03-22 20:05:57 +0000
+++ src/main/java/com/akiban/qp/operator/Sort_InsertionLimited.java	2013-04-30 23:23:36 +0000
@@ -185,14 +185,8 @@
                 CursorLifecycle.checkIdle(this);
                 input.open();
                 state = State.FILLING;
-                if (usingPValues()) {
-                    for (TEvaluatableExpression eval : tEvaluations)
-                        eval.with(context);
-                }
-                else {
-                    for (ExpressionEvaluation eval : oEvaluations)
-                        eval.of(context);
-                }
+                for (TEvaluatableExpression eval : tEvaluations)
+                    eval.with(context);
                 sorted = new TreeSet<>();
             } finally {
                 TAP_OPEN.out();
@@ -219,10 +213,7 @@
                         while ((row = input.next()) != null) {
                             assert row.rowType() == sortType : row;
                             Holder holder;
-                            if (usingPValues())
-                                holder = new Holder(label, row, tEvaluations, null);
-                            else
-                                holder = new Holder(label, row, oEvaluations);
+                            holder = new Holder(label, row, tEvaluations, null);
                             if (preserveDuplicates) {
                                 label++;
                             }
@@ -312,14 +303,7 @@
         {
             close();
             input.destroy();
-            if (usingPValues()) {
-                // TODO nothing to destroy yet...
-            }
-            else {
-                for (ExpressionEvaluation evaluation : oEvaluations) {
-                    evaluation.destroy();
-                }
-            }
+            // TODO nothing to destroy for expressions yet
             state = State.DESTROYED;
         }
 
@@ -354,21 +338,10 @@
             super(context);
             this.input = input;
             int nsort = ordering.sortColumns();
-            if (ordering.usingPVals()) {
-                tEvaluations = new ArrayList<>(nsort);
-                for (int i = 0; i < nsort; ++i) {
-                    TEvaluatableExpression evaluation = ordering.tExpression(i).build();
-                    tEvaluations.add(evaluation);
-                }
-                oEvaluations = null;
-            }
-            else {
-                tEvaluations = null;
-                oEvaluations = new ArrayList<>(nsort);
-                for (int i = 0; i < nsort; i++) {
-                    ExpressionEvaluation evaluation = ordering.expression(i).evaluation();
-                    oEvaluations.add(evaluation);
-                }
+            tEvaluations = new ArrayList<>(nsort);
+            for (int i = 0; i < nsort; ++i) {
+                TEvaluatableExpression evaluation = ordering.tExpression(i).build();
+                tEvaluations.add(evaluation);
             }
         }
 
@@ -376,7 +349,6 @@
 
         private final Cursor input;
         private final List<TEvaluatableExpression> tEvaluations;
-        private final List<ExpressionEvaluation> oEvaluations;
         private State state = State.CLOSED;
         private SortedSet<Holder> sorted;
         private Iterator<Holder> iterator;
@@ -408,25 +380,6 @@
             }
         }
 
-        public Holder(int index, Row arow, List<ExpressionEvaluation> evaluations) {
-            this.index = index;
-
-            row = new ShareHolder<>();
-            row.hold(arow);
-
-            ToObjectValueTarget target = new ToObjectValueTarget();
-
-            values = new Comparable[ordering.sortColumns()];
-            for (int i = 0; i < values.length; i++) {
-                ExpressionEvaluation evaluation = evaluations.get(i);
-                evaluation.of(arow);
-                ValueSource valueSource = evaluation.eval();
-                target.expectType(ordering.type(i));
-                Converters.convert(valueSource, target);
-                values[i] = (Comparable) target.lastConvertedValue();
-            }
-        }
-
         public Row empty() {
             Row result = row.get();
             row.release();

=== modified file 'src/main/java/com/akiban/qp/persistitadapter/OperatorBasedRowCollector.java'
--- src/main/java/com/akiban/qp/persistitadapter/OperatorBasedRowCollector.java	2013-03-22 20:05:57 +0000
+++ src/main/java/com/akiban/qp/persistitadapter/OperatorBasedRowCollector.java	2013-04-30 23:23:36 +0000
@@ -282,9 +282,9 @@
             plan = groupScan_Default(group);
             if (scanLimit != ScanLimit.NONE) {
                 if (scanLimit instanceof FixedCountLimit) {
-                    plan = limit_Default(plan, ((FixedCountLimit) scanLimit).getLimit(), usePVals);
+                    plan = limit_Default(plan, ((FixedCountLimit) scanLimit).getLimit());
                 } else if (scanLimit instanceof PredicateLimit) {
-                    plan = limit_Default(plan, ((PredicateLimit) scanLimit).getLimit(), usePVals);
+                    plan = limit_Default(plan, ((PredicateLimit) scanLimit).getLimit());
                 }
             }
         }

=== modified file 'src/main/java/com/akiban/qp/persistitadapter/OperatorStore.java'
--- src/main/java/com/akiban/qp/persistitadapter/OperatorStore.java	2013-04-14 00:26:23 +0000
+++ src/main/java/com/akiban/qp/persistitadapter/OperatorStore.java	2013-04-30 23:23:36 +0000
@@ -136,7 +136,7 @@
 
             // MVCC will render this useless, but for now, a limit of 1 ensures we won't see the row we just updated,
             // and therefore scan through two rows -- once to update old -> new, then to update new -> copy of new
-            scanOp = limit_Default(scanOp, 1, Types3Switch.ON);
+            scanOp = limit_Default(scanOp, 1);
 
             UpdatePlannable updateOp = update_Default(scanOp, updateFunction);
 

=== modified file 'src/main/java/com/akiban/qp/persistitadapter/indexcursor/IndexCursorSpatial_InBox.java'
--- src/main/java/com/akiban/qp/persistitadapter/indexcursor/IndexCursorSpatial_InBox.java	2013-03-22 20:05:57 +0000
+++ src/main/java/com/akiban/qp/persistitadapter/indexcursor/IndexCursorSpatial_InBox.java	2013-04-30 23:23:36 +0000
@@ -108,11 +108,7 @@
         API.Ordering zOrdering = new API.Ordering();
         IndexRowType rowType = keyRange.indexRowType().physicalRowType();
         for (int f = 0; f < rowType.nFields(); f++) {
-            if (Types3Switch.ON) {
-                zOrdering.append(null, new TPreparedField(rowType.typeInstanceAt(f), f), true);
-            } else {
-                zOrdering.append(Expressions.field(rowType, f), null, true);
-            }
+            zOrdering.append(new TPreparedField(rowType.typeInstanceAt(f), f), true);
         }
         // The index column selector needs to select all the columns before the z column, and the z column itself.
         this.indexColumnSelector = new IndexRowPrefixSelector(this.latColumn + 1);

=== modified file 'src/main/java/com/akiban/qp/persistitadapter/indexcursor/IndexCursorSpatial_NearPoint.java'
--- src/main/java/com/akiban/qp/persistitadapter/indexcursor/IndexCursorSpatial_NearPoint.java	2013-03-22 20:05:57 +0000
+++ src/main/java/com/akiban/qp/persistitadapter/indexcursor/IndexCursorSpatial_NearPoint.java	2013-04-30 23:23:36 +0000
@@ -39,6 +39,7 @@
 import com.akiban.server.types3.mcompat.mtypes.MNumeric;
 import com.akiban.server.types3.pvalue.PValue;
 import com.akiban.server.types3.pvalue.PValueSource;
+import com.akiban.server.types3.texpressions.TPreparedExpression;
 
 import java.math.BigDecimal;
 
@@ -139,17 +140,10 @@
         IndexBound loBound = keyRange.lo();
         BoundExpressions loExpressions = loBound.boundExpressions(context);
         // Compute z-value at beginning of forward and backward scans
-        BigDecimal lat;
-        BigDecimal lon;
-        if (Types3Switch.ON) {
-            TInstance latInstance = index.getAllColumns().get(latColumn).getColumn().tInstance();
-            TInstance lonInstance = index.getAllColumns().get(lonColumn).getColumn().tInstance();
-            lat = MBigDecimal.getWrapper(loExpressions.pvalue(latColumn), latInstance).asBigDecimal();
-            lon = MBigDecimal.getWrapper(loExpressions.pvalue(lonColumn), lonInstance).asBigDecimal();
-        } else {
-            lat = loExpressions.eval(latColumn).getDecimal();
-            lon = loExpressions.eval(lonColumn).getDecimal();
-        }
+        TInstance latInstance = index.getAllColumns().get(latColumn).getColumn().tInstance();
+        TInstance lonInstance = index.getAllColumns().get(lonColumn).getColumn().tInstance();
+        BigDecimal lat = MBigDecimal.getWrapper(loExpressions.pvalue(latColumn), latInstance).asBigDecimal();
+        BigDecimal lon = MBigDecimal.getWrapper(loExpressions.pvalue(lonColumn), lonInstance).asBigDecimal();
         zStart = space.shuffle(lat, lon);
         // Cursors going forward from starting z value (inclusive), and backward from the same z value (exclusive)
         int indexRowFields = physicalIndexRowType.nFields();
@@ -164,41 +158,23 @@
         // Take care of any equality restrictions before the spatial fields
         zPosition = latColumn;
         for (int f = 0; f < zPosition; f++) {
-            if (Types3Switch.ON) {
-                PValueSource eqValueSource = loExpressions.pvalue(f);
-                zForwardRow.value(f, eqValueSource);
-                zBackwardRow.value(f, eqValueSource);
-                zMaxRow.value(f, eqValueSource);
-                zMinRow.value(f, eqValueSource);
-            } else {
-                ValueSource eqValue = loExpressions.eval(f);
-                zForwardRow.value(f, eqValue);
-                zBackwardRow.value(f, eqValue);
-                zMaxRow.value(f, eqValue);
-                zMinRow.value(f, eqValue);
-            }
+            PValueSource eqValueSource = loExpressions.pvalue(f);
+            zForwardRow.value(f, eqValueSource);
+            zBackwardRow.value(f, eqValueSource);
+            zMaxRow.value(f, eqValueSource);
+            zMinRow.value(f, eqValueSource);
         }
         // Z-value part of bounds
-        if (Types3Switch.ON) {
-            PValue startPValue = new PValue(MNumeric.BIGINT.instance(false));
-            PValue maxPValue = new PValue(MNumeric.BIGINT.instance(false));
-            PValue minPValue = new PValue(MNumeric.BIGINT.instance(false));
-            startPValue.putInt64(zStart);
-            maxPValue.putInt64(Long.MAX_VALUE);
-            minPValue.putInt64(Long.MIN_VALUE);
-            zForwardRow.value(zPosition, startPValue);
-            zBackwardRow.value(zPosition, startPValue);
-            zMaxRow.value(zPosition, maxPValue);
-            zMinRow.value(zPosition, minPValue);
-        } else {
-            ValueSource startValue = new ValueHolder(AkType.LONG, zStart);
-            ValueSource maxValue = new ValueHolder(AkType.LONG, Long.MAX_VALUE);
-            ValueSource minValue = new ValueHolder(AkType.LONG, Long.MIN_VALUE);
-            zForwardRow.value(zPosition, startValue);
-            zBackwardRow.value(zPosition, startValue);
-            zMaxRow.value(zPosition, maxValue);
-            zMinRow.value(zPosition, minValue);
-        }
+        PValue startPValue = new PValue(MNumeric.BIGINT.instance(false));
+        PValue maxPValue = new PValue(MNumeric.BIGINT.instance(false));
+        PValue minPValue = new PValue(MNumeric.BIGINT.instance(false));
+        startPValue.putInt64(zStart);
+        maxPValue.putInt64(Long.MAX_VALUE);
+        minPValue.putInt64(Long.MIN_VALUE);
+        zForwardRow.value(zPosition, startPValue);
+        zBackwardRow.value(zPosition, startPValue);
+        zMaxRow.value(zPosition, maxPValue);
+        zMinRow.value(zPosition, minPValue);
         IndexKeyRange geKeyRange = IndexKeyRange.bounded(physicalIndexRowType, zForward, true, zMax, false);
         IndexKeyRange ltKeyRange = IndexKeyRange.bounded(physicalIndexRowType, zMin, false, zBackward, false);
         IndexScanRowState geRowState = new IndexScanRowState(adapter, keyRange.indexRowType());
@@ -206,33 +182,20 @@
         API.Ordering upOrdering = new API.Ordering();
         API.Ordering downOrdering = new API.Ordering();
         for (int f = 0; f < physicalIndexRowType.nFields(); f++) {
-            upOrdering.append(Expressions.field(physicalIndexRowType, 0), true);
-            downOrdering.append(Expressions.field(physicalIndexRowType, 0), false);
-        }
-        if (Types3Switch.ON) {
-            geCursor = new IndexCursorUnidirectional<>(context,
-                                                                   geRowState,
-                                                                   geKeyRange,
-                                                                   upOrdering,
-                                                                   PValueSortKeyAdapter.INSTANCE);
-            ltCursor = new IndexCursorUnidirectional<>(context,
-                                                                   ltRowState,
-                                                                   ltKeyRange,
-                                                                   downOrdering,
-                                                                   PValueSortKeyAdapter.INSTANCE);
-        }
-        else {
-            geCursor = new IndexCursorUnidirectional<>(context,
-                                                                  geRowState,
-                                                                  geKeyRange,
-                                                                  upOrdering,
-                                                                  OldExpressionsSortKeyAdapter.INSTANCE);
-            ltCursor = new IndexCursorUnidirectional<>(context,
-                                                                  ltRowState,
-                                                                  ltKeyRange,
-                                                                  downOrdering,
-                                                                  OldExpressionsSortKeyAdapter.INSTANCE);
-        }
+            // TODO: This seems like an API hack
+            upOrdering.append((TPreparedExpression)null, true);
+            downOrdering.append((TPreparedExpression)null, false);
+        }
+        geCursor = new IndexCursorUnidirectional<>(context,
+                                                               geRowState,
+                                                               geKeyRange,
+                                                               upOrdering,
+                                                               PValueSortKeyAdapter.INSTANCE);
+        ltCursor = new IndexCursorUnidirectional<>(context,
+                                                               ltRowState,
+                                                               ltKeyRange,
+                                                               downOrdering,
+                                                               PValueSortKeyAdapter.INSTANCE);
     }
 
     // For use by this class

=== modified file 'src/main/java/com/akiban/qp/persistitadapter/indexcursor/OldSorterAdapter.java'
--- src/main/java/com/akiban/qp/persistitadapter/indexcursor/OldSorterAdapter.java	2013-03-22 20:05:57 +0000
+++ src/main/java/com/akiban/qp/persistitadapter/indexcursor/OldSorterAdapter.java	2013-04-30 23:23:36 +0000
@@ -36,7 +36,7 @@
 final class OldSorterAdapter extends SorterAdapter<ValueSource, Expression, ExpressionEvaluation> {
     @Override
     protected void appendDummy(API.Ordering ordering) {
-        ordering.append(DUMMY_EXPRESSION, null, ordering.ascending(0));
+        throw new IllegalStateException("types3 off");
     }
 
     @Override
@@ -56,14 +56,12 @@
 
     @Override
     protected void initTypes(API.Ordering ordering, int i, AkType[] akTypes, TInstance[] tInstances) {
-        akTypes[i] = ordering.type(i);
+        throw new IllegalStateException("types3 off");
     }
 
     @Override
     protected ExpressionEvaluation evaluation(API.Ordering ordering, QueryContext context, int i) {
-        ExpressionEvaluation evaluation = ordering.expression(i).evaluation();
-        evaluation.of(context);
-        return evaluation;
+        throw new IllegalStateException("types3 off");
     }
 
     @Override

=== modified file 'src/main/java/com/akiban/qp/persistitadapter/indexcursor/PValueSorterAdapter.java'
--- src/main/java/com/akiban/qp/persistitadapter/indexcursor/PValueSorterAdapter.java	2013-03-22 20:05:57 +0000
+++ src/main/java/com/akiban/qp/persistitadapter/indexcursor/PValueSorterAdapter.java	2013-04-30 23:23:36 +0000
@@ -36,7 +36,7 @@
 final class PValueSorterAdapter extends SorterAdapter<PValueSource, TPreparedExpression, TEvaluatableExpression> {
     @Override
     protected void appendDummy(API.Ordering ordering) {
-        ordering.append(null, DUMMY_EXPRESSION, ordering.ascending(0));
+        ordering.append(DUMMY_EXPRESSION, ordering.ascending(0));
     }
 
     @Override

=== modified file 'src/main/java/com/akiban/qp/row/ValuesHolderRow.java'
--- src/main/java/com/akiban/qp/row/ValuesHolderRow.java	2013-03-22 20:05:57 +0000
+++ src/main/java/com/akiban/qp/row/ValuesHolderRow.java	2013-04-30 23:23:36 +0000
@@ -43,7 +43,7 @@
 
     @Deprecated
     public ValuesHolderRow(RowType rowType) {
-        this(rowType, false);
+        this(rowType, true);
     }
 
     public ValuesHolderRow(RowType rowType, boolean usePValues) {

=== modified file 'src/main/java/com/akiban/server/explain/std/SortOperatorExplainer.java'
--- src/main/java/com/akiban/server/explain/std/SortOperatorExplainer.java	2013-03-22 20:05:57 +0000
+++ src/main/java/com/akiban/server/explain/std/SortOperatorExplainer.java	2013-04-30 23:23:36 +0000
@@ -40,10 +40,7 @@
         map.put(Label.INPUT_OPERATOR, inputOp.getExplainer(context));
         for (int i = 0; i < ordering.sortColumns(); i++)
         {
-            if (ordering.usingPVals())
-                map.put(Label.EXPRESSIONS, ordering.tExpression(i).getExplainer(context));
-            else
-                map.put(Label.EXPRESSIONS, ordering.expression(i).getExplainer(context));
+            map.put(Label.EXPRESSIONS, ordering.tExpression(i).getExplainer(context));
             map.put(Label.ORDERING, PrimitiveExplainer.getInstance(ordering.ascending(i) ? "ASC" : "DESC"));
         }
         

=== modified file 'src/main/java/com/akiban/server/service/restdml/DeleteGenerator.java'
--- src/main/java/com/akiban/server/service/restdml/DeleteGenerator.java	2013-04-11 15:03:00 +0000
+++ src/main/java/com/akiban/server/service/restdml/DeleteGenerator.java	2013-04-30 23:23:36 +0000
@@ -31,6 +31,6 @@
     protected Operator create(TableName tableName) {
         Operator lookup = indexAncestorLookup(tableName); 
         // build delete operator.
-        return API.delete_Returning(lookup, true, true);
+        return API.delete_Returning(lookup, true);
     }       
 }

=== modified file 'src/main/java/com/akiban/server/service/restdml/InsertGenerator.java'
--- src/main/java/com/akiban/server/service/restdml/InsertGenerator.java	2013-04-11 15:03:00 +0000
+++ src/main/java/com/akiban/server/service/restdml/InsertGenerator.java	2013-04-30 23:23:36 +0000
@@ -62,7 +62,7 @@
 
         RowStream stream = assembleValueScan (table);
         stream = assembleProjectTable (stream, table);
-        stream.operator = API.insert_Returning(stream.operator, true);
+        stream.operator = API.insert_Returning(stream.operator);
         stream = projectTable(stream, table);
         return stream.operator; 
     }

=== modified file 'src/main/java/com/akiban/server/service/restdml/UpdateGenerator.java'
--- src/main/java/com/akiban/server/service/restdml/UpdateGenerator.java	2013-04-12 10:33:28 +0000
+++ src/main/java/com/akiban/server/service/restdml/UpdateGenerator.java	2013-04-30 23:23:36 +0000
@@ -93,7 +93,7 @@
         }
         UpdateFunction updateFunction = 
                 new UpsertRowUpdateFunction(Arrays.asList(updates), stream.rowType);
-        stream.operator = API.update_Returning(stream.operator, updateFunction, true);
+        stream.operator = API.update_Returning(stream.operator, updateFunction);
         
         if (logger.isDebugEnabled()) {
             ExplainContext explain = explainUpdateStatement(stream.operator, table, Arrays.asList(updates));

=== modified file 'src/main/java/com/akiban/server/types3/Types3Switch.java'
--- src/main/java/com/akiban/server/types3/Types3Switch.java	2013-03-22 20:05:57 +0000
+++ src/main/java/com/akiban/server/types3/Types3Switch.java	2013-04-30 23:23:36 +0000
@@ -19,6 +19,11 @@
 
 public class Types3Switch {
     public static final boolean DEFAULT = Boolean.parseBoolean(System.getProperty("newtypes", "true"));
+    static {
+        if(!DEFAULT) {
+            throw new IllegalStateException("Expected newtypes=true");
+        }
+    }
 
     public static volatile boolean ON = DEFAULT;
 }

=== modified file 'src/main/java/com/akiban/sql/optimizer/rule/OperatorAssembler.java'
--- src/main/java/com/akiban/sql/optimizer/rule/OperatorAssembler.java	2013-04-28 04:00:20 +0000
+++ src/main/java/com/akiban/sql/optimizer/rule/OperatorAssembler.java	2013-04-30 23:23:36 +0000
@@ -528,7 +528,7 @@
 
             @Override
             public API.Ordering createOrdering() {
-                return API.ordering(false);
+                throw new IllegalStateException("types3 off");
             }
         }
 
@@ -602,7 +602,7 @@
 
             @Override
             public API.Ordering createOrdering() {
-                return API.ordering(true);
+                return API.ordering();
             }
 
             @Override
@@ -769,7 +769,7 @@
             
             stream = assembleInsertProjectTable (stream, projectFields, insert);
             
-            stream.operator = API.insert_Returning(stream.operator, usePValues);
+            stream.operator = API.insert_Returning(stream.operator);
             
             if (explainContext != null)
                 explainInsertStatement(stream.operator, insert);
@@ -963,7 +963,7 @@
             UpdateFunction updateFunction = 
                 new ExpressionRowUpdateFunction(updates, updatesP, targetRowType);
 
-            stream.operator = API.update_Returning(stream.operator, updateFunction, usePValues);
+            stream.operator = API.update_Returning(stream.operator, updateFunction);
             stream.fieldOffsets = new ColumnSourceFieldOffsets (updateStatement.getTable(), targetRowType);
             if (explainContext != null)
                 explainUpdateStatement(stream.operator, updateStatement, updateColumns, updates, updatesP);            
@@ -992,7 +992,7 @@
             //stream = assembleDeleteProjectTable (stream, projectFields, delete);
             UserTableRowType targetRowType = tableRowType(delete.getTargetTable());
             
-            stream.operator = API.delete_Returning(stream.operator, usePValues, false);
+            stream.operator = API.delete_Returning(stream.operator, false);
             stream.fieldOffsets = new ColumnSourceFieldOffsets(delete.getTable(), targetRowType);
             
             if (explainContext != null)
@@ -1147,7 +1147,6 @@
                                API.IntersectOption.SKIP_SCAN) :
                     EnumSet.of(API.IntersectOption.OUTPUT_LEFT, 
                                API.IntersectOption.SEQUENTIAL_SCAN),
-                    usePValues,
                     comparisons);
             stream.rowType = outputScan.rowType;
             stream.fieldOffsets = new IndexFieldOffsets(index, stream.rowType);
@@ -1184,8 +1183,7 @@
                 stream.operator = API.indexScan_Default(indexRowType,
                                                         assembleSpatialIndexKeyRange(indexScan, null),
                                                         API.ordering(), // TODO: what ordering?
-                                                        selector,
-                                                        usePValues);
+                                                        selector);
                 indexRowType = indexRowType.physicalRowType();
                 stream.rowType = indexRowType;
             }
@@ -1193,8 +1191,7 @@
                 stream.operator = API.indexScan_Default(indexRowType,
                                                         assembleIndexKeyRange(indexScan, null),
                                                         assembleIndexOrdering(indexScan, indexRowType),
-                                                        selector,
-                                                        usePValues);
+                                                        selector);
                 stream.rowType = indexRowType;
             }
             else {
@@ -1225,8 +1222,7 @@
                     Operator scan = API.indexScan_Default(indexRowType,
                                                           assembleIndexKeyRange(indexScan, null, rangeSegment),
                                                           assembleIndexOrdering(indexScan, indexRowType),
-                                                          selector,
-                                                          usePValues);
+                                                          selector);
                     if (stream.operator == null) {
                         stream.operator = scan;
                         stream.rowType = indexRowType;
@@ -1242,11 +1238,10 @@
                         stream.operator = API.union_Ordered(stream.operator, scan,
                                                             (IndexRowType)stream.rowType, indexRowType,
                                                             nordering, nordering, 
-                                                            ascending, unionOrderedAll,
-                                                            usePValues);
+                                                            ascending, unionOrderedAll);
                     }
                     else {
-                        stream.operator = API.unionAll(stream.operator, stream.rowType, scan, indexRowType, usePValues);
+                        stream.operator = API.unionAll(stream.operator, stream.rowType, scan, indexRowType);
                         stream.rowType = stream.operator.rowType();
                     }
                 }
@@ -1603,12 +1598,11 @@
                         stream = assembleStream(aggregateSource.getInput());
                         // TODO: Could be removed, since aggregate_Partial works as well.
                         stream.operator = API.count_Default(stream.operator, 
-                                                            stream.rowType,
-                                                            usePValues);
+                                                            stream.rowType);
                     }
                     else {
                         stream = new RowStream();
-                        stream.operator = API.count_TableStatus(tableRowType(aggregateSource.getTable()), usePValues);
+                        stream.operator = API.count_TableStatus(tableRowType(aggregateSource.getTable()));
                     }
                     stream.rowType = stream.operator.rowType();
                     stream.fieldOffsets = new ColumnSourceFieldOffsets(aggregateSource, 
@@ -1666,7 +1660,7 @@
             case PRESORTED:
                 List<AkCollator> collators = findCollators(distinct.getInput());
                 if (collators != null) {
-                    stream.operator = API.distinct_Partial(stream.operator, stream.rowType, collators, usePValues);
+                    stream.operator = API.distinct_Partial(stream.operator, stream.rowType, collators);
                 } else {
                     throw new UnsupportedOperationException(String.format(
                         "Can't use Distinct_Partial except following a projection. Try again when types3 is in place"));
@@ -1716,11 +1710,9 @@
             RowStream stream = assembleStream(sort.getInput());
             API.Ordering ordering = partialAssembler.createOrdering();
             for (OrderByExpression orderBy : sort.getOrderBy()) {
-                Expression expr = oldPartialAssembler.assembleExpression(orderBy.getExpression(),
-                        stream.fieldOffsets);
                 TPreparedExpression tExpr = newPartialAssembler.assembleExpression(orderBy.getExpression(),
                         stream.fieldOffsets);
-                ordering.append(expr, tExpr, orderBy.isAscending(), orderBy.getCollator());
+                ordering.append(tExpr, orderBy.isAscending(), orderBy.getCollator());
             }
             assembleSort(stream, ordering, sort.getInput(), output, sortOption);
             return stream;
@@ -1747,7 +1739,7 @@
                 stream.operator = API.sort_InsertionLimited(stream.operator, stream.rowType,
                                                             ordering, sortOption, maxrows);
             else
-                stream.operator = API.sort_Tree(stream.operator, stream.rowType, ordering, sortOption, usePValues);
+                stream.operator = API.sort_Tree(stream.operator, stream.rowType, ordering, sortOption);
         }
 
         protected void assembleSort(RowStream stream, int nkeys, PlanNode input,
@@ -1755,9 +1747,8 @@
             List<AkCollator> collators = findCollators(input);
             API.Ordering ordering = partialAssembler.createOrdering();
             for (int i = 0; i < nkeys; i++) {
-                Expression expr = oldPartialAssembler.field(stream.rowType, i);
                 TPreparedExpression tExpr = newPartialAssembler.field(stream.rowType, i);
-                ordering.append(expr, tExpr, true,
+                ordering.append(tExpr, true,
                                 (collators == null) ? null : collators.get(i));
             }
             assembleSort(stream, ordering, input, null, sortOption);
@@ -1770,7 +1761,7 @@
                 nlimit = Integer.MAX_VALUE; // Slight disagreement in saying unlimited.
             stream.operator = API.limit_Default(stream.operator, 
                                                 limit.getOffset(), limit.isOffsetParameter(),
-                                                nlimit, limit.isLimitParameter(), usePValues);
+                                                nlimit, limit.isLimitParameter());
             return stream;
         }
 
@@ -1786,7 +1777,7 @@
 
         protected RowStream assembleOnlyIfEmpty(OnlyIfEmpty onlyIfEmpty) {
             RowStream stream = assembleStream(onlyIfEmpty.getInput());
-            stream.operator = API.limit_Default(stream.operator, 0, false, 1, false, usePValues);
+            stream.operator = API.limit_Default(stream.operator, 0, false, 1, false);
             // Nulls here have no semantic meaning, but they're easier than trying to
             // figure out an interesting non-null value for each
             // AkType in the row. All that really matters is that the
@@ -1813,8 +1804,7 @@
                                                     bloomFilter.getEstimatedSize(),
                                                     pos + loopBindingsOffset,
                                                     stream.operator,
-                                                    collators,
-                                                    usePValues);
+                                                    collators);
             popHashTable(bloomFilter);
             return stream;
         }
@@ -2003,8 +1993,7 @@
             for (int i = 0; i < indexOrdering.size(); i++) {
                 Expression expr = oldPartialAssembler.field(indexRowType, i);
                 TPreparedExpression tExpr = newPartialAssembler.field(indexRowType, i);
-                ordering.append(expr,
-                                tExpr,
+                ordering.append(tExpr,
                                 indexOrdering.get(i).isAscending(),
                                 index.getIndexColumns().get(i).getColumn().getCollator());
             }

=== modified file 'src/main/java/com/akiban/sql/optimizer/rule/PlanGenerator.java'
--- src/main/java/com/akiban/sql/optimizer/rule/PlanGenerator.java	2013-03-22 20:05:57 +0000
+++ src/main/java/com/akiban/sql/optimizer/rule/PlanGenerator.java	2013-04-30 23:23:36 +0000
@@ -180,14 +180,13 @@
                                                          bound, true,
                                                          bound, true);
 
-        Ordering ordering = API.ordering(true);
+        Ordering ordering = API.ordering();
         for (int i = 0; i < nkeys; i++) {
-            ordering.append(null, 
-                            new TPreparedField(indexType.typeInstanceAt(i), i), 
+            ordering.append(new TPreparedField(indexType.typeInstanceAt(i), i),
                             false);
         }
 
-        return API.indexScan_Default(indexType, indexRange, ordering, true);
+        return API.indexScan_Default(indexType, indexRange, ordering);
         
     }
 }

=== modified file 'src/test/java/com/akiban/qp/operator/Distinct_PartialTest.java'
--- src/test/java/com/akiban/qp/operator/Distinct_PartialTest.java	2013-03-22 20:05:57 +0000
+++ src/test/java/com/akiban/qp/operator/Distinct_PartialTest.java	2013-04-30 23:23:36 +0000
@@ -181,8 +181,8 @@
         );
         Ordering ordering = ordering();
         if (Types3Switch.ON) {
-            ordering.append(null, new TPreparedField(input.rowType().typeInstanceAt(0), 0), true);
-            ordering.append(null, new TPreparedField(input.rowType().typeInstanceAt(1), 1), true);
+            ordering.append(new TPreparedField(input.rowType().typeInstanceAt(0), 0), true);
+            ordering.append(new TPreparedField(input.rowType().typeInstanceAt(1), 1), true);
         }
         else {
             ordering.append(field(input.rowType(), 0), true);

=== modified file 'src/test/java/com/akiban/server/test/it/qp/DeleteIT.java'
--- src/test/java/com/akiban/server/test/it/qp/DeleteIT.java	2013-03-22 20:05:57 +0000
+++ src/test/java/com/akiban/server/test/it/qp/DeleteIT.java	2013-04-30 23:23:36 +0000
@@ -102,7 +102,7 @@
         Row[] rows = {
                 row(customerRowType, new Object[]{2, "abc"}, new AkType[]{AkType.INT, AkType.VARCHAR})
         };
-        UpdatePlannable insertPlan = delete_Default(rowsToValueScan(rows), Types3Switch.ON);
+        UpdatePlannable insertPlan = delete_Default(rowsToValueScan(rows));
         UpdateResult result = insertPlan.run(queryContext);
         assertEquals("rows touched", rows.length, result.rowsTouched());
         assertEquals("rows modified", rows.length, result.rowsModified());

=== modified file 'src/test/java/com/akiban/server/test/it/qp/Distinct_Partial_CaseInsensitive_IT.java'
--- src/test/java/com/akiban/server/test/it/qp/Distinct_Partial_CaseInsensitive_IT.java	2013-03-22 20:05:57 +0000
+++ src/test/java/com/akiban/server/test/it/qp/Distinct_Partial_CaseInsensitive_IT.java	2013-04-30 23:23:36 +0000
@@ -349,8 +349,7 @@
                     SortOption.PRESERVE_DUPLICATES,
                     db.length),
                 projectRowType,
-                Arrays.asList(caseSensitiveCollator),
-                Types3Switch.ON);
+                Arrays.asList(caseSensitiveCollator));
         RowBase[] expected = new RowBase[] {
             row(projectRowType, "AA_cs"),
             row(projectRowType, "Aa_cs"),
@@ -387,8 +386,7 @@
                         SortOption.PRESERVE_DUPLICATES,
                         db.length),
                     projectRowType,
-                    Arrays.asList(caseInsensitiveCollator),
-                    Types3Switch.ON),
+                    Arrays.asList(caseInsensitiveCollator)),
                 projectRowType,
                 convertToUpper);
         RowBase[] expected = new RowBase[] {
@@ -418,8 +416,7 @@
                     SortOption.PRESERVE_DUPLICATES,
                     db.length),
                 projectRowType,
-                Arrays.asList((AkCollator)null),
-                Types3Switch.ON);
+                Arrays.asList((AkCollator)null));
         RowBase[] expected = new RowBase[] {
             row(projectRowType, 0L),
         };
@@ -454,8 +451,7 @@
                         SortOption.PRESERVE_DUPLICATES,
                         db.length),
                     projectRowType,
-                    Arrays.asList(caseSensitiveCollator, caseInsensitiveCollator, null),
-                    Types3Switch.ON),
+                    Arrays.asList(caseSensitiveCollator, caseInsensitiveCollator, null)),
                 projectRowType,
                 convertCaseInsensitiveToUpper);
         RowBase[] expected = new RowBase[] {

=== modified file 'src/test/java/com/akiban/server/test/it/qp/IndexScanJumpUnboundedIT.java'
--- src/test/java/com/akiban/server/test/it/qp/IndexScanJumpUnboundedIT.java	2013-03-22 20:05:57 +0000
+++ src/test/java/com/akiban/server/test/it/qp/IndexScanJumpUnboundedIT.java	2013-04-30 23:23:36 +0000
@@ -28,8 +28,6 @@
 import com.akiban.qp.rowtype.Schema;
 import com.akiban.server.api.dml.SetColumnSelector;
 import com.akiban.server.api.dml.scan.NewRow;
-import com.akiban.server.expression.std.FieldExpression;
-import org.junit.Before;
 import org.junit.Test;
 
 import java.util.ArrayList;
@@ -39,7 +37,7 @@
 
 import static com.akiban.qp.operator.API.cursor;
 import static com.akiban.qp.operator.API.indexScan_Default;
-import static com.akiban.server.expression.std.Expressions.field;
+import static com.akiban.server.test.ExpressionGenerators.field;
 import static org.junit.Assert.assertEquals;
 
 public class IndexScanJumpUnboundedIT extends OperatorITBase

=== modified file 'src/test/java/com/akiban/server/test/it/qp/Intersect_OrderedByteArrayComparisonIT.java'
--- src/test/java/com/akiban/server/test/it/qp/Intersect_OrderedByteArrayComparisonIT.java	2013-03-22 20:05:57 +0000
+++ src/test/java/com/akiban/server/test/it/qp/Intersect_OrderedByteArrayComparisonIT.java	2013-04-30 23:23:36 +0000
@@ -20,6 +20,7 @@
 import com.akiban.qp.expression.IndexBound;
 import com.akiban.qp.expression.IndexKeyRange;
 import com.akiban.qp.operator.API;
+import com.akiban.qp.operator.ExpressionGenerator;
 import com.akiban.qp.operator.Operator;
 import com.akiban.qp.row.RowBase;
 import com.akiban.qp.rowtype.IndexRowType;
@@ -333,7 +334,7 @@
         Ordering ordering = API.ordering();
         int i = 0;
         while (i < objects.length) {
-            Expression expression = (Expression) objects[i++];
+            ExpressionGenerator expression = (ExpressionGenerator) objects[i++];
             Boolean ascending = (Boolean) objects[i++];
             ordering.append(expression, ascending);
         }

=== modified file 'src/test/java/com/akiban/server/test/it/qp/NWaySkipScanIT.java'
--- src/test/java/com/akiban/server/test/it/qp/NWaySkipScanIT.java	2013-03-22 20:05:57 +0000
+++ src/test/java/com/akiban/server/test/it/qp/NWaySkipScanIT.java	2013-04-30 23:23:36 +0000
@@ -420,18 +420,6 @@
         return IndexKeyRange.bounded(tZIndexRowType, bound, true, bound, true);
     }
 
-    private Ordering ordering(Object... objects)
-    {
-        Ordering ordering = API.ordering();
-        int i = 0;
-        while (i < objects.length) {
-            Expression expression = (Expression) objects[i++];
-            Boolean ascending = (Boolean) objects[i++];
-            ordering.append(expression, ascending);
-        }
-        return ordering;
-    }
-
     private boolean[] ascending(boolean... ascending)
     {
         return ascending;

=== modified file 'src/test/java/com/akiban/server/test/it/qp/Select_BloomFilter_CaseInsensitive_IT.java'
--- src/test/java/com/akiban/server/test/it/qp/Select_BloomFilter_CaseInsensitive_IT.java	2013-03-22 20:05:57 +0000
+++ src/test/java/com/akiban/server/test/it/qp/Select_BloomFilter_CaseInsensitive_IT.java	2013-04-30 23:23:36 +0000
@@ -323,9 +323,7 @@
                         0,
                         ExpressionGenerator.ErasureMaker.MARK),
                     // collators
-                    collators,
-                    // usePValues
-                    Types3Switch.ON
+                    collators
                     ),
                 dIndexRowType,
                 Arrays.asList(

=== modified file 'src/test/java/com/akiban/server/test/it/qp/SkipScanPerformanceIT.java'
--- src/test/java/com/akiban/server/test/it/qp/SkipScanPerformanceIT.java	2013-03-22 20:05:57 +0000
+++ src/test/java/com/akiban/server/test/it/qp/SkipScanPerformanceIT.java	2013-04-30 23:23:36 +0000
@@ -21,6 +21,7 @@
 import com.akiban.qp.expression.IndexKeyRange;
 import com.akiban.qp.operator.API;
 import com.akiban.qp.operator.Cursor;
+import com.akiban.qp.operator.ExpressionGenerator;
 import com.akiban.qp.operator.Operator;
 import com.akiban.qp.row.Row;
 import com.akiban.qp.rowtype.IndexRowType;
@@ -429,18 +430,6 @@
         return IndexKeyRange.bounded(tZIndexRowType, bound, true, bound, true);
     }
 
-    private Ordering ordering(Object... objects)
-    {
-        Ordering ordering = API.ordering();
-        int i = 0;
-        while (i < objects.length) {
-            Expression expression = (Expression) objects[i++];
-            Boolean ascending = (Boolean) objects[i++];
-            ordering.append(expression, ascending);
-        }
-        return ordering;
-    }
-
     private boolean[] ascending(boolean... ascending)
     {
         return ascending;

=== modified file 'src/test/resources/com/akiban/sql/pg/yaml/functional/test-statement-cache.yaml'
--- src/test/resources/com/akiban/sql/pg/yaml/functional/test-statement-cache.yaml	2012-12-23 22:48:11 +0000
+++ src/test/resources/com/akiban/sql/pg/yaml/functional/test-statement-cache.yaml	2013-04-30 23:23:36 +0000
@@ -4,7 +4,7 @@
 - suppressed: true
 ---
 # A setting that affects cache selection.
-- Statement: SET newtypes TO 'false'
+- Statement: SET newtypes TO 'true'
 ---
 - JMX: com.akiban:type=PostgresServer
 - set: StatementCacheCapacity
@@ -110,7 +110,7 @@
            ['    Select_HKeyOrdered(t.s == $1)'],
            ['      GroupScan_Default(t)']]
 ---
-- Statement: SET newtypes TO 'false'
+- Statement: SET newtypes TO 'true'
 ---
 - Statement: EXPLAIN SELECT id FROM t WHERE s = ?
 - output: [['Project_Default(t.id)'],

=== removed file 'src/test/resources/com/akiban/sql/pg/yaml/functional/test-t2t3-compat-decimal.yaml'
--- src/test/resources/com/akiban/sql/pg/yaml/functional/test-t2t3-compat-decimal.yaml	2012-11-03 20:22:04 +0000
+++ src/test/resources/com/akiban/sql/pg/yaml/functional/test-t2t3-compat-decimal.yaml	1970-01-01 00:00:00 +0000
@@ -1,29 +0,0 @@
----
-# We'll want a more comprehensive test later, but this is good enough for now.
-# See https://www.pivotaltracker.com/story/show/38877031 
-- CreateTable: decimal_table(id INT NOT NULL PRIMARY KEY, value DECIMAL(5,2));
----
-- Statement: CREATE INDEX dec_idx on decimal_table(value);
----
-- Newtypes: false
----
-- Statement: INSERT INTO decimal_table values (1, 543.21);
----
-- Newtypes: true
----
-- Statement: INSERT INTO decimal_table values (2, 123.45)
----
-- Statement: SELECT * FROM decimal_table ORDER BY id;
-- output: [[1, 543.21], [2, 123.45]]
----
-- Statement: SELECT * FROM decimal_table ORDER BY value;
-- output: [[2, 123.45], [1, 543.21]]
----
-- Newtypes: false
----
-- Statement: SELECT * FROM decimal_table ORDER BY id;
-- output: [[1, 543.21], [2, 123.45]]
----
-- Statement: SELECT * FROM decimal_table ORDER BY value;
-- output: [[2, 123.45], [1, 543.21]]
-...

=== modified file 'src/test/resources/com/akiban/sql/pg/yaml/functional/test-type-year.yaml'
--- src/test/resources/com/akiban/sql/pg/yaml/functional/test-type-year.yaml	2012-10-31 17:31:11 +0000
+++ src/test/resources/com/akiban/sql/pg/yaml/functional/test-type-year.yaml	2013-04-30 23:23:36 +0000
@@ -2,8 +2,6 @@
 # Also compare  types2's behaviour with that of types3
 # Note:, types3 is doing the correct thing!
 ---
-- Newtypes: true
----
 - Include: all-types-schema.yaml
 ---
 - Statement: INSERT INTO all_types(year_field)
@@ -20,21 +18,4 @@
 - output: [[0], [2001], [2069], [1970], [1999], [0], [0], [0]]
 ---
 - Statement: DELETE FROM all_types;
----
-- Newtypes: false
----
-- Statement: INSERT INTO all_types(year_field)
-             VALUES (0),
-                    (1),
-                    (69),
-                    (70),
-                    (99),
-                    (100);
----
-- Statement: SELECT year_field from all_types;
-- output: [[0], [1901], [1969], [1970], [1999], [2000]]
----
-- Statement: DELETE FROM all_types;
----
-- Newtypes: null
 ...
\ No newline at end of file