OrderingScore supports automatic ordering direction when unspecified.

2 files changed, 35 insertions, 23 deletions

diff --git a/src/main/java/com/amazon/carbonado/info/OrderedProperty.java b/src/main/java/com/amazon/carbonado/info/OrderedProperty.java
index 7de07c0..fe53c60 100644
--- a/src/main/java/com/amazon/carbonado/info/OrderedProperty.java
+++ b/src/main/java/com/amazon/carbonado/info/OrderedProperty.java
@@ -56,8 +56,8 @@ public class OrderedProperty<S extends Storable> implements Appender {
 

     /**

      * Parses an ordering property, which may start with a '+' or '-' to

-     * indicate direction. If ordering prefix not specified, default direction

-     * is ascending.

+     * indicate direction. Prefix of '~' indicates unspecified direction. If

+     * ordering prefix not specified, default direction is ascending.

      *

      * @param info Info for Storable type containing property

      * @param str string to parse

@@ -73,7 +73,7 @@ public class OrderedProperty<S extends Storable> implements Appender {
 

     /**

      * Parses an ordering property, which may start with a '+' or '-' to

-     * indicate direction.

+     * indicate direction. Prefix of '~' indicates unspecified direction.

      *

      * @param info Info for Storable type containing property

      * @param str string to parse

@@ -98,6 +98,9 @@ public class OrderedProperty<S extends Storable> implements Appender {
             } else if (str.charAt(0) == '-') {

                 direction = Direction.DESCENDING;

                 str = str.substring(1);

+            } else if (str.charAt(0) == '~') {

+                direction = Direction.UNSPECIFIED;

+                str = str.substring(1);

             }

         }

         if (direction == null) {

@@ -158,9 +161,6 @@ public class OrderedProperty<S extends Storable> implements Appender {
      */

     @Override

     public String toString() {

-        if (mDirection == Direction.UNSPECIFIED) {

-            return mProperty.toString();

-        }

         StringBuilder buf = new StringBuilder();

         buf.append(mDirection.toCharacter());

         try {

@@ -172,11 +172,7 @@ public class OrderedProperty<S extends Storable> implements Appender {
     }

 

     public void appendTo(Appendable app) throws IOException {

-        if (mDirection == Direction.UNSPECIFIED) {

-            mProperty.appendTo(app);

-        } else {

-            app.append(mDirection.toCharacter());

-            mProperty.appendTo(app);

-        }

+        app.append(mDirection.toCharacter());

+        mProperty.appendTo(app);

     }

 }

diff --git a/src/main/java/com/amazon/carbonado/qe/OrderingScore.java b/src/main/java/com/amazon/carbonado/qe/OrderingScore.java
index ed52cfc..ce85cb6 100644
--- a/src/main/java/com/amazon/carbonado/qe/OrderingScore.java
+++ b/src/main/java/com/amazon/carbonado/qe/OrderingScore.java
@@ -177,18 +177,32 @@ public class OrderingScore<S extends Storable> {
                 ChainedProperty<S> indexChained = indexProp.getChainedProperty();

 

                 if (chained.equals(indexChained)) {

-                    if (property.getDirection() != UNSPECIFIED) {

-                        Direction indexDir = indexProp.getDirection();

-                        if (indexDir == UNSPECIFIED) {

-                            indexDir = ASCENDING;

-                        }

+                    Direction indexDir = indexProp.getDirection();

+                    if (indexDir == UNSPECIFIED) {

+                        // Assume index natural order is ascending.

+                        indexDir = ASCENDING;

+                    }

+

+                    if (shouldReverseOrder != null && shouldReverseOrder) {

+                        indexDir = indexDir.reverse();

+                    }

 

-                        if (shouldReverseOrder == null) {

-                            shouldReverseOrder = indexDir != property.getDirection();

-                        } else if ((indexDir != property.getDirection()) ^ shouldReverseOrder) {

-                            // Direction mismatch, so cannot be handled.

-                            break indexPosMatch;

+                    if (property.getDirection() == UNSPECIFIED) {

+                        // Set handled property direction to match index.

+                        property = property.direction(indexDir);

+                    } else if (shouldReverseOrder == null) {

+                        shouldReverseOrder = indexDir != property.getDirection();

+                        // Any properies already in the list had been

+                        // originally unspecified. They might need to be

+                        // reversed now.

+                        if (shouldReverseOrder) {

+                            for (int hpi = 0; hpi < handledProperties.size(); hpi++) {

+                                handledProperties.set(hpi, handledProperties.get(hpi).reverse());

+                            }

                         }

+                    } else if (indexDir != property.getDirection()) {

+                        // Direction mismatch, so cannot be handled.

+                        break indexPosMatch;

                     }

 

                     handledProperties.add(property);

@@ -281,7 +295,9 @@ public class OrderingScore<S extends Storable> {
 

     /**

      * Returns the ordering properties that the evaluated index supports. The

-     * list of orderings is reduced to eliminate redundancies.

+     * list of orderings is reduced to eliminate redundancies. If any handled

+     * ordering properties originally had an unspecified direction, the correct

+     * direction is specified in this list.

      *

      * @return handled orderings, never null

      */