db-derby-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From d..@apache.org
Subject svn commit: r990292 [1/3] - in /db/derby/code/trunk/java: engine/org/apache/derby/impl/sql/compile/ testing/org/apache/derbyTesting/functionTests/master/ testing/org/apache/derbyTesting/functionTests/suites/ testing/org/apache/derbyTesting/functionTest...
Date Fri, 27 Aug 2010 22:35:40 GMT
Author: dag
Date: Fri Aug 27 22:35:39 2010
New Revision: 990292

URL: http://svn.apache.org/viewvc?rev=990292&view=rev
Log:
DERBY-4471 Left outer join reassociation rewrite gives wrong result

Patch derby-4471-1d. This patch changes logic for determining if right
deep nested (left) outer join can reassiciated to left deep, i.e.

   OJ1                        OJ1
  /  \                        / \
 /    \                      /   t3
t1    OJ2          =>       /
      /  \                 OJ2
     /    \               /   \
    t2    t3           t1     t2 

The old behavior was both too liberal (this issue showed a query being
reordered erroneously), and too restrictive. The patch removes the
"too liberal" hole, and also opens up for some new valid cases.

For further details, refer to the JIRA issue and the code comments
especially the javadoc for the methods HalfOuterJoinNode#LOJ_reorderable and
HalfOuterJoinNode#isNullRejecting.

As a part of the patch, the old harness based test lojreorder.sql has been converted
into the JUnit based LojReorderTest equivalent.

For further details, refer to the JIRA issue and the code comments.


Added:
    db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/LojReorderTest.java
Removed:
    db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/lojreorder.out
    db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/lojreorder.sql
Modified:
    db/derby/code/trunk/java/engine/org/apache/derby/impl/sql/compile/HalfOuterJoinNode.java
    db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall
    db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/OuterJoinTest.java
    db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/_Suite.java
    db/derby/code/trunk/java/testing/org/apache/derbyTesting/junit/JDBC.java

Modified: db/derby/code/trunk/java/engine/org/apache/derby/impl/sql/compile/HalfOuterJoinNode.java
URL: http://svn.apache.org/viewvc/db/derby/code/trunk/java/engine/org/apache/derby/impl/sql/compile/HalfOuterJoinNode.java?rev=990292&r1=990291&r2=990292&view=diff
==============================================================================
--- db/derby/code/trunk/java/engine/org/apache/derby/impl/sql/compile/HalfOuterJoinNode.java
(original)
+++ db/derby/code/trunk/java/engine/org/apache/derby/impl/sql/compile/HalfOuterJoinNode.java
Fri Aug 27 22:35:39 2010
@@ -257,12 +257,48 @@ public class HalfOuterJoinNode extends J
 		rightFromTable.pushExpressions(noPredicates);
 	}
 
-	/**
-	 * This method determines if (1) the query is a LOJ, and (2) if the LOJ is a candidate for
-	 * reordering (i.e., linearization).  The condition for LOJ linearization is:
-	 * 1. only LOJ in the fromList, i.e., no INNER, no FULL JOINs, no ROJs
-	 * 2. ON clause must be equality join between left and right operands and in CNF (i.e.,
AND is allowed)
-	 */
+    /**
+     * This method recursively:
+     * <ul>
+     *    <li>determines if this part of the query tree is a compound OJ of
+     *            the shape required for reordering and if so,</li>
+     *    <li>does a reordering.</li>
+     * </ul>
+     * <pre>
+     *
+     *    OJ1  pT1T2                      OJ1  pT2T3
+     *   /  \                             / \
+     *  /    \                 can       /   t3
+     * t1    OJ2 pT2T3       reorder    /
+     *       /  \              to      OJ2  pT1T2
+     *      /    \                    /   \
+     *     t2    t3                  /     \
+     *                             t1     t2
+     *
+     * where pR1R2 is a null-rejecting predicate which references the schema
+     * of joinee R1 and R2, cf. terminology explanation in #isNullRejecting.
+     * <p/>
+     * OJ1 represents <em>this</em> before and after the reordering.
+     * </pre>
+     * <p/>
+     * The join predicates are assumed to be in CNF form.
+     * <p/>
+     * <em>Note:</em> Present implementation limitations
+     * <ul>
+     *   <li>Only left outer joins are considered, i.e. both OJs in diagram
+     *       above must be LOJ.</li>
+     *   <li>Top left side must be a base table (t1 above). The bottow right
+     *       side
+*       (t3 above) may be another OJ, so reordering can happen
+     *       recursively.</li>
+     * </ul>
+     *
+     * @param numTables number of tables involved (needed to right size the
+     *                  bitmaps)
+     * @return boolean true if any reordering took place at this level or deeper
+     *                 so caller can know whether rebinding may be necessary
+     * @throws StandardException standard error policy
+     */
 	public boolean LOJ_reorderable(int numTables)
 		throws StandardException
 	{
@@ -287,12 +323,12 @@ public class HalfOuterJoinNode extends J
 		// Redundantly normalize the ON predicate (it will also be called in preprocess()).
 		super.normExpressions();
 
-		// This is a very simple LOJ of base tables. Do nothing.
+        // This is a very simple OJ of base tables. Do nothing.
 		if (logicalLeftResultSet instanceof FromBaseTable &&
 			logicalRightResultSet instanceof FromBaseTable)
 			return anyChange;
 
-		// Recursively check if we can reordering LOJ, and build the table
+        // Recursively check if we can reordering OJ, and build the table
 		// references. Note that joins may have been reordered and therefore the
 		// table references need to be recomputed.
 		if (logicalLeftResultSet instanceof HalfOuterJoinNode)
@@ -300,7 +336,7 @@ public class HalfOuterJoinNode extends J
 			anyChange =	((HalfOuterJoinNode)logicalLeftResultSet).LOJ_reorderable(numTables) || anyChange;
 		}
 		else if (!(logicalLeftResultSet instanceof FromBaseTable))
-		{// left operand must be either a base table or another LOJ
+        {// left operand must be either a base table or another OJ
 			// In principle, we don't care about the left operand.  However, we
 			// need to re-bind the resultColumns.  If the left operand is a
 			// view, we may have to re-bind the where clause etc...
@@ -315,11 +351,11 @@ public class HalfOuterJoinNode extends J
 			anyChange = ((HalfOuterJoinNode)logicalRightResultSet).LOJ_reorderable(numTables) || anyChange;
 		}
 		else if (!(logicalRightResultSet instanceof FromBaseTable))
-		{// right operand must be either a base table or another LOJ
+        {// right operand must be either a base table or another OJ
 			return anyChange;
 		}
 
-		// It is much easier to do LOJ reordering if there is no ROJ.
+        // It is much easier to do OJ reordering if there is no ROJ.
 		// However, we ran into some problem downstream when we transform an ROJ
 		// into LOJ -- transformOuterJoin() didn't expect ROJ to be transformed
 		// into LOJ alread.  So, we skip optimizing ROJ at the moment.
@@ -329,11 +365,12 @@ public class HalfOuterJoinNode extends J
 			return LOJ_bindResultColumns(anyChange);
 		}
 
-		// Build the data structure for testing/doing LOJ reordering.
-		// Fill in the table references on row-preserving and null-producing sides.
-		// It may be possible that either operand is a complex view.
-		JBitSet				NPReferencedTableMap; // Null-producing
-		JBitSet				RPReferencedTableMap; // Row-preserving
+        // Build the data structure for testing/doing OJ reordering.  Fill in
+        // the table references on row-preserving and null-producing sides.  It
+        // may be possible that either operand is a complex view.
+
+        JBitSet RPReferencedTableMap; // Row-preserving
+        JBitSet NPReferencedTableMap; // Null-producing
 
 		RPReferencedTableMap = logicalLeftResultSet.LOJgetReferencedTables(numTables);
 		NPReferencedTableMap = logicalRightResultSet.LOJgetReferencedTables(numTables);
@@ -343,183 +380,256 @@ public class HalfOuterJoinNode extends J
 		{
 			return LOJ_bindResultColumns(anyChange);
 		}
-			
-		// Check if the predicate is equality predicate in CNF (i.e., AND only)
-		// and left/right column references must come from either operand.
-		// That is, we don't allow:
-		// 1. A=A
-		// 2. 1=1
-		// 3. B=C where both B and C are either from left or right operand.
-
-		// we probably need to make the joinClause "left-deep" so that we can
-		// walk it easier.
-		BinaryRelationalOperatorNode equals;
-		ValueNode leftCol;
-		ValueNode rightCol;
-		AndNode   and;
-		ValueNode left;
-		ValueNode vn = joinClause;
-		while (vn instanceof AndNode)
-		{
-			and = (AndNode) vn;
-			left = and.getLeftOperand();
-
-			// Make sure that this is an equijoin of the form "C = D" where C
-			// and D references tables from both left and right operands.
-			if (left instanceof RelationalOperator &&
-				((ValueNode)left).isBinaryEqualsOperatorNode())
-			{
-				equals = (BinaryRelationalOperatorNode) left;
-				leftCol = equals.getLeftOperand();
-				rightCol = equals.getRightOperand();
-
-				if (!( leftCol instanceof ColumnReference && rightCol instanceof ColumnReference))
-					return LOJ_bindResultColumns(anyChange);
-
-				boolean refCheck = false;
-				boolean leftOperandCheck = false;
-
-				if (RPReferencedTableMap.get(((ColumnReference)leftCol).getTableNumber()))
-				{
-					refCheck = true;
-					leftOperandCheck = true;
-				}
-				else if (NPReferencedTableMap.get(((ColumnReference)leftCol).getTableNumber()))
-				{
-					refCheck = true;
-				}
-
-				if (refCheck == false)
-					return LOJ_bindResultColumns(anyChange);
-
-				refCheck = false;
-				if (leftOperandCheck == false && RPReferencedTableMap.get(((ColumnReference)rightCol).getTableNumber()))
-				{
-					refCheck = true;
-				}
-				else if (leftOperandCheck == true && NPReferencedTableMap.get(((ColumnReference)rightCol).getTableNumber()))
-				{
-					refCheck = true;
-				}
-
-				if (refCheck == false)
-					return LOJ_bindResultColumns(anyChange);
-			}
-			else return LOJ_bindResultColumns(anyChange); //  get out of here
-
-			vn = and.getRightOperand();
-		}
 
-		// Check if the logical right resultset is a composite inner and as such
-		// that this current LOJ can be pushed through it.
-		boolean       push = false;
-		// logical right operand is another LOJ... so we may be able to push the
-		// join
-		if (logicalRightResultSet instanceof HalfOuterJoinNode)
-		{
-			// get the Null-producing operand of the child
-			JBitSet  logicalNPRefTableMap = ((HalfOuterJoinNode)logicalRightResultSet).LOJgetNPReferencedTables(numTables);
 
-			// does the current LOJ join predicate reference
-			// logicalNPRefTableMap?  If not, we can push the current
-			// join.
-			vn = joinClause;
-			push = true;
-			while (vn instanceof AndNode)
-			{
-				and = (AndNode) vn;
-				left = and.getLeftOperand();
-				equals = (BinaryRelationalOperatorNode) left;
-				leftCol = equals.getLeftOperand();
-				rightCol = equals.getRightOperand();
+        // Check if logical right operand is another OJ... so we may be able
+        // to push the join.
+        if (logicalRightResultSet instanceof HalfOuterJoinNode)
+		{
+            // Get the row-preserving map of the  child OJ
+            JBitSet  nestedChildOJRPRefTableMap =
+                ((HalfOuterJoinNode)logicalRightResultSet).
+                LOJgetRPReferencedTables(numTables);
+
+            // Checks that top has p(t1,t2)
+            if ( ! isNullRejecting(
+                         joinClause,
+                         RPReferencedTableMap,
+                         nestedChildOJRPRefTableMap)) {
+                // No, give up.
+                return LOJ_bindResultColumns(anyChange);
+            }
+
+            // Get the null-producing map of the child OJ
+            JBitSet  nestedChildOJNPRefTableMap =
+                ((HalfOuterJoinNode)logicalRightResultSet).
+                LOJgetNPReferencedTables(numTables);
+
+            // Checks that right child has p(t2,t3)
+            if ( isNullRejecting(
+                         ((HalfOuterJoinNode)logicalRightResultSet).joinClause,
+                         nestedChildOJRPRefTableMap,
+                         nestedChildOJNPRefTableMap)) {
+                // Push the current OJ into the next level For safety, check
+                // the JoinNode data members: they should null or empty list
+                // before we proceed.
+                if (super.subqueryList.size() != 0 ||
+                    ((JoinNode)logicalRightResultSet).
+                        subqueryList.size() != 0 ||
+                    super.joinPredicates.size() != 0 ||
+                    ((JoinNode)logicalRightResultSet).
+                        joinPredicates.size() != 0 ||
+                    super.usingClause != null ||
+                    ((JoinNode)logicalRightResultSet).
+                        usingClause != null) {
+
+                    return LOJ_bindResultColumns(anyChange); //  get out of here
+                }
+                anyChange = true; // we are reordering the OJs.
+
+                ResultSetNode tmp = logicalLeftResultSet;
+                ResultSetNode LChild, RChild;
+
+                //            this OJ
+                //            /      \
+                //  logicalLeftRS   LogicalRightRS
+                //                   /     \
+                //                LChild  RChild
+                // becomes
+                //
+                //               this OJ
+                //               /      \
+                //     LogicalRightRS   RChild
+                //           /     \
+                // logicalLeftRS LChild <<< we need to be careful about this
+                //                          order as the "LogicalRightRS
+                //                          may be a ROJ
+                //
+
+                // handle the lower level OJ node
+                LChild = ((HalfOuterJoinNode)logicalRightResultSet).
+                    leftResultSet;
+                RChild = ((HalfOuterJoinNode)logicalRightResultSet).
+                    rightResultSet;
+
+                ((HalfOuterJoinNode)logicalRightResultSet).
+                    rightResultSet = LChild;
+                ((HalfOuterJoinNode)logicalRightResultSet).
+                    leftResultSet  = tmp;
+
+                // switch the ON clause
+                {
+                    ValueNode vn = joinClause;
+                    joinClause =
+                        ((HalfOuterJoinNode)logicalRightResultSet).joinClause;
+                    ((HalfOuterJoinNode)logicalRightResultSet).joinClause = vn;
+                }
+
+                // No need to switch HalfOuterJoinNode data members for now
+                // because we are handling only OJ.
+                // boolean local_rightOuterJoin = rightOuterJoin;
+                // boolean local_transformed    = transformed;
+                // rightOuterJoin = ((HalfOuterJoinNode)logicalRightResultSet).
+                //     rightOuterJoin;
+                // transformed = ((HalfOuterJoinNode)logicalRightResultSet).
+                //     transformed;
+                // ((HalfOuterJoinNode)logicalRightResultSet).rightOuterJoin =
+                //     local_rightOuterJoin;
+                // ((HalfOuterJoinNode)logicalRightResultSet).transformed =
+                //     local_transformed;
+
+                FromList localFromList = (FromList) getNodeFactory().getNode(
+                    C_NodeTypes.FROM_LIST,
+                    getNodeFactory().doJoinOrderOptimization(),
+                    getContextManager());
+
+                // switch OJ nodes: by handling the current OJ node
+                leftResultSet  = logicalRightResultSet;
+                rightResultSet = RChild;
+
+                // rebuild the result columns and re-bind column references
+                ((HalfOuterJoinNode)leftResultSet).resultColumns = null;
+                 // localFromList is empty:
+                ((JoinNode)leftResultSet).bindResultColumns(localFromList);
+
+                // left operand must be another OJ, so recurse.
+                boolean localChange = ((HalfOuterJoinNode)leftResultSet).
+                    LOJ_reorderable(numTables);
+            }
+        }
 
-				if (logicalNPRefTableMap.get(((ColumnReference)leftCol).getTableNumber()) ||
-					logicalNPRefTableMap.get(((ColumnReference)rightCol).getTableNumber()))
-				{
-					push = false;
-					break;
-				}
+        return LOJ_bindResultColumns(anyChange);
+    }
 
-				vn = and.getRightOperand();
-			}
-		}
 
-		// Push the current LOJ into the next level
-		if (push)
-		{
-			// For safety, check the JoinNode data members: they should null or
-			// empty list before we proceed.
-			if (super.subqueryList.size() != 0 ||
-				((JoinNode)logicalRightResultSet).subqueryList.size() != 0 ||
-				super.joinPredicates.size() != 0 ||
-				((JoinNode)logicalRightResultSet).joinPredicates.size() != 0 ||
-				super.usingClause != null ||
-				((JoinNode)logicalRightResultSet).usingClause != null)
-				return LOJ_bindResultColumns(anyChange); //  get out of here
-
-			anyChange = true; // we are reordering the LOJs.
-
-			ResultSetNode tmp = logicalLeftResultSet;
-			ResultSetNode LChild, RChild;
-
-			//            this LOJ
-			//            /      \
-			//  logicalLeftRS   LogicalRightRS
-			//                   /     \
-			//                LChild  RChild
-			// becomes
-			//
-			//               this LOJ
-			//               /      \
-			//     LogicalRightRS   RChild
-			//           /     \
-			// logicalLeftRS   LChild  <<<  we need to be careful about this order
-			//                              as the "LogicalRightRS may be a ROJ
-			//
-
-			// handle the lower level LOJ node
-			LChild = ((HalfOuterJoinNode)logicalRightResultSet).leftResultSet;
-			RChild = ((HalfOuterJoinNode)logicalRightResultSet).rightResultSet;
-
-			((HalfOuterJoinNode)logicalRightResultSet).rightResultSet = LChild;
-			((HalfOuterJoinNode)logicalRightResultSet).leftResultSet  = tmp;
-
-			// switch the ON clause
-			vn = joinClause;
-			joinClause   = ((HalfOuterJoinNode)logicalRightResultSet).joinClause;
-			((HalfOuterJoinNode)logicalRightResultSet).joinClause = vn;
-
-			// No need to switch HalfOuterJoinNode data members for now because
-			// we are handling only LOJ.
-			// boolean local_rightOuterJoin = rightOuterJoin;
-			// boolean local_transformed    = transformed;
-			// rightOuterJoin = ((HalfOuterJoinNode)logicalRightResultSet).rightOuterJoin;
-			// transformed    = ((HalfOuterJoinNode)logicalRightResultSet).transformed;
-			// ((HalfOuterJoinNode)logicalRightResultSet).rightOuterJoin = local_rightOuterJoin;
-			// ((HalfOuterJoinNode)logicalRightResultSet).transformed    = local_transformed;
 
-			FromList localFromList = (FromList) getNodeFactory().getNode(
-																		 C_NodeTypes.FROM_LIST,
-																		 getNodeFactory().doJoinOrderOptimization(),
-																		 getContextManager());
+    /**
+     * Tests pRiRj in the sense of Galindo-Legaria et al: <em>Outerjoin
+     * Simplification and Reordering for Query Optimization</em>, ACM
+     * Transactions on Database Systems, Vol. 22, No. 1, March 1997, Pages
+     * 43-74:
+     * <quote>
+     *  "The set of attributes referenced by a predicate p is called the schema
+     *  of p, and denoted sch(p). As a notational convention, we annotate
+     *  predicates to reflect their schema. If sch(p) includes attributes of
+     *  both Ri, Rj and only those relations, we can write the predicate as
+     *  pRiRj.
+     * </quote>
+     *
+     * If a null-valued column is compared in a predicate that
+     * contains no OR connectives, the predicate evaluates to undefined, and
+     * the tuple is rejected. The relops satisfy this criterion.
+     * <p/>
+     * To simplify analysis, we only accept predicates of the form:
+     * <pre>
+     * X relop Y [and .. and X-n relop Y-n]
+     * </pre>
+     *
+     * At least one of the relops should reference both {@code leftTableMap}
+     * and {@code rightTableMap}, so that we know that sch(p) includes
+     * attributes of both Ri, Rj. I.e.
+     *
+     * <p/>
+     * {@code X} should be a table in {@code leftTableMap}, and
+     * {@code Y} should be a table in {@code rightTableMap}.
+     * <p/>
+     * <b>or</b>
+     * {@code X} should be a table in {@code rightTableMap}, and
+     * {@code Y} should be a table in {@code leftTableMap}.
+     *
+     * @param joinClause The join clause (i.e. predicate) we want to check
+     * @param leftTableMap a bit map representing the tables expected for the
+     *                     predicate (logical left)
+     * @param rightTableMap a bit map representing the tables expected for the
+     *                      predicate (logical right)
+     * @return true if the {@code joinClause} has at least one relop that
+     *              references both {@code leftTableMap} and {@code
+     *              rightTableMap}
+     * @throws StandardException standard exception policy
+     */
 
-			// switch LOJ nodes: by handling the current LOJ node
-			leftResultSet  = logicalRightResultSet;
-			rightResultSet = RChild;
-
-			// rebuild the result columns and re-bind column references
-			((HalfOuterJoinNode)leftResultSet).resultColumns = null;
-			((JoinNode)leftResultSet).bindResultColumns(localFromList); // localFromList is empty
+private boolean isNullRejecting (
+        ValueNode joinClause,
+        JBitSet leftTableMap,
+        JBitSet rightTableMap)
+        throws StandardException {
+
+        ValueNode vn = joinClause;
+        boolean foundPred = false;
+
+        while (vn != null) {
+            AndNode andNode = null;
+
+            if (vn instanceof AndNode) {
+                andNode = (AndNode)vn;
+                vn = andNode.getLeftOperand();
+            }
+
+            if (vn instanceof BinaryRelationalOperatorNode) {
+
+                BinaryRelationalOperatorNode relop =
+                    (BinaryRelationalOperatorNode)vn;
+                ValueNode leftCol = relop.getLeftOperand();
+                ValueNode rightCol = relop.getRightOperand();
+
+                boolean leftFound = false;
+                boolean rightFound = false;
+
+                if (leftCol instanceof ColumnReference) {
+                    if (leftTableMap.get(
+                                ((ColumnReference)leftCol).getTableNumber())) {
+
+                        leftFound = true;
+
+                    } else if (
+                        rightTableMap.get(
+                            ((ColumnReference)leftCol).getTableNumber())) {
+
+                        rightFound = true;
+                    } else {
+                        // references unexpected table
+                        return false;
+                    }
+
+                }
+
+                if (rightCol instanceof ColumnReference) {
+                    if (leftTableMap.get(
+                                ((ColumnReference)rightCol).getTableNumber())) {
+                        leftFound = true;
+
+                    } else if (rightTableMap.get(
+                                       ((ColumnReference)rightCol).
+                                       getTableNumber())) {
+                        rightFound = true;
+                    } else {
+                        // references unexpected table, sch(p) is wrong
+                        return false;
+                    }
+                }
+
+
+                if (leftFound && rightFound) {
+                    foundPred = true; // sch(p) covers both R1 and R2
+                }
+            } else if ((vn instanceof BooleanConstantNode) && foundPred) {
+                // OK, simple predicate which covers both R1 and R2 found
+            } else {
+                // reject other operators, e.g. OR
+                return false;
+            }
+
+            if (andNode != null) {
+                vn = andNode.getRightOperand();
+            } else {
+                vn = null;
+            }
+        }
 
-			// left operand must be another LOJ, try again until a fixpoint
-			boolean localChange = ((HalfOuterJoinNode)leftResultSet).LOJ_reorderable(numTables);
+        return foundPred;
+    }
 
-			// rebuild the result columns and re-bind column references for 'this'
-			return LOJ_bindResultColumns(anyChange);
-		}
 
-		return LOJ_bindResultColumns(anyChange);
-	}
 
 	// This method re-binds the result columns which may be referenced in the ON
 	// clause in this node.
@@ -792,4 +902,14 @@ public class HalfOuterJoinNode extends J
 		else
 			return (JBitSet) rightResultSet.LOJgetReferencedTables(numTables);
 	}
+
+    // return the row-preserving table references
+    public JBitSet LOJgetRPReferencedTables(int numTables)
+                throws StandardException
+    {
+        if (rightOuterJoin && !transformed)
+            return (JBitSet) rightResultSet.LOJgetReferencedTables(numTables);
+        else
+            return (JBitSet) leftResultSet.LOJgetReferencedTables(numTables);
+    }
 }

Modified: db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall
URL: http://svn.apache.org/viewvc/db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall?rev=990292&r1=990291&r2=990292&view=diff
==============================================================================
--- db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall
(original)
+++ db/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall
Fri Aug 27 22:35:39 2010
@@ -16,7 +16,6 @@ lang/isolationLevels.sql
 lang/joinDeadlock.sql
 lang/langUnitTests.sql
 lang/lockTable.sql
-lang/lojreorder.sql
 lang/maxMemPerTab.java
 lang/nestedCommit.sql
 lang/openScans.sql



Mime
View raw message