Index: drools-core/src/main/java/org/drools/base/evaluators/ComparableEvaluatorsDefinition.java
===================================================================
--- drools-core/src/main/java/org/drools/base/evaluators/ComparableEvaluatorsDefinition.java	(revision 34805)
+++ drools-core/src/main/java/org/drools/base/evaluators/ComparableEvaluatorsDefinition.java	(working copy)
@@ -115,6 +115,10 @@
             addEvaluator( ValueType.OBJECT_TYPE,        Operator.LESS_OR_EQUAL,       ObjectLessOrEqualEvaluator.INSTANCE );
             addEvaluator( ValueType.OBJECT_TYPE,        Operator.GREATER,             ObjectGreaterEvaluator.INSTANCE );
             addEvaluator( ValueType.OBJECT_TYPE,        Operator.GREATER_OR_EQUAL,    ObjectGreaterOrEqualEvaluator.INSTANCE );
+            addEvaluator( ValueType.STRING_TYPE,        Operator.LESS,                StringLessEvaluator.INSTANCE );
+            addEvaluator( ValueType.STRING_TYPE,        Operator.LESS_OR_EQUAL,       StringLessOrEqualEvaluator.INSTANCE );
+            addEvaluator( ValueType.STRING_TYPE,        Operator.GREATER,             StringGreaterEvaluator.INSTANCE );
+            addEvaluator( ValueType.STRING_TYPE,        Operator.GREATER_OR_EQUAL,    StringGreaterOrEqualEvaluator.INSTANCE );
             addEvaluator( ValueType.SHORT_TYPE,         Operator.LESS,                ShortLessEvaluator.INSTANCE );
             addEvaluator( ValueType.SHORT_TYPE,         Operator.LESS_OR_EQUAL,       ShortLessOrEqualEvaluator.INSTANCE );
             addEvaluator( ValueType.SHORT_TYPE,         Operator.GREATER,             ShortGreaterEvaluator.INSTANCE );
@@ -2399,6 +2403,232 @@
         }
     }
 
+    public static class StringLessEvaluator extends BaseEvaluator {
+        private static final long     serialVersionUID = 400L;
+        public final static Evaluator INSTANCE         = new StringLessEvaluator();
+        private static final ObjectComparator comparator = new ObjectComparator();
+
+
+        public StringLessEvaluator() {
+            super( ValueType.STRING_TYPE,
+                   Operator.LESS );
+        }
+
+        public boolean evaluate(InternalWorkingMemory workingMemory,
+                                final InternalReadAccessor extractor,
+                                final Object object1, final FieldValue object2) {
+            if( extractor.isNullValue( workingMemory, object1 ) || object2.getValue() == null ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) extractor.getValue( workingMemory, object1 );
+            return comparator.compare( comp, object2.getValue() ) < 0;
+        }
+
+        public boolean evaluateCachedRight(InternalWorkingMemory workingMemory,
+                                           final VariableContextEntry context, final Object left) {
+            if( context.rightNull || context.declaration.getExtractor().isNullValue( workingMemory, left ) ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) ((ObjectVariableContextEntry) context).right;
+            return comparator.compare( comp,  context.declaration.getExtractor().getValue( workingMemory, left ) ) < 0;
+        }
+
+        public boolean evaluateCachedLeft(InternalWorkingMemory workingMemory,
+                                          final VariableContextEntry context, final Object right) {
+            if( context.extractor.isNullValue( workingMemory, right ) || ((ObjectVariableContextEntry) context).left == null ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) context.extractor.getValue( workingMemory, right );
+            return comparator.compare( comp, ((ObjectVariableContextEntry) context).left ) < 0;
+        }
+
+        public boolean evaluate(InternalWorkingMemory workingMemory,
+                                final InternalReadAccessor extractor1,
+                                final Object object1,
+                                final InternalReadAccessor extractor2, final Object object2) {
+            if( extractor1.isNullValue( workingMemory, object1 ) || extractor2.isNullValue( workingMemory, object2 ) ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) extractor1.getValue( workingMemory, object1 );
+            return comparator.compare( comp, extractor2.getValue( workingMemory, object2 ) ) < 0;
+        }
+
+        public String toString() {
+            return "String <";
+        }
+    }
+
+    public static class StringLessOrEqualEvaluator extends BaseEvaluator {
+        /**
+         *
+         */
+        private static final long     serialVersionUID = 400L;
+        public final static Evaluator INSTANCE         = new StringLessOrEqualEvaluator();
+        private static final ObjectComparator comparator = new ObjectComparator();
+
+        public StringLessOrEqualEvaluator() {
+            super( ValueType.STRING_TYPE,
+                   Operator.LESS_OR_EQUAL );
+        }
+
+        public boolean evaluate(InternalWorkingMemory workingMemory,
+                                final InternalReadAccessor extractor,
+                                final Object object1, final FieldValue object2) {
+            if( extractor.isNullValue( workingMemory, object1 ) || object2.getValue() == null ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) extractor.getValue( workingMemory, object1 );
+            return comparator.compare( comp, object2.getValue() ) <= 0;
+        }
+
+        public boolean evaluateCachedRight(InternalWorkingMemory workingMemory,
+                                           final VariableContextEntry context, final Object left) {
+            if( context.rightNull || context.declaration.getExtractor().isNullValue( workingMemory, left ) ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) ((ObjectVariableContextEntry) context).right;
+            return comparator.compare( comp, context.declaration.getExtractor().getValue( workingMemory, left ) ) <= 0;
+        }
+
+        public boolean evaluateCachedLeft(InternalWorkingMemory workingMemory,
+                                          final VariableContextEntry context, final Object right) {
+            if( context.extractor.isNullValue( workingMemory, right ) || ((ObjectVariableContextEntry) context).left == null ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) context.extractor.getValue( workingMemory, right );
+            return comparator.compare( comp, ((ObjectVariableContextEntry) context).left ) <= 0;
+        }
+
+        public boolean evaluate(InternalWorkingMemory workingMemory,
+                                final InternalReadAccessor extractor1,
+                                final Object object1,
+                                final InternalReadAccessor extractor2, final Object object2) {
+            if( extractor1.isNullValue( workingMemory, object1 ) || extractor2.isNullValue( workingMemory, object2 ) ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) extractor1.getValue( workingMemory, object1 );
+            return comparator.compare( comp, extractor2.getValue( workingMemory, object2 ) ) <= 0;
+        }
+
+        public String toString() {
+            return "String <=";
+        }
+    }
+
+    public static class StringGreaterEvaluator extends BaseEvaluator {
+        /**
+         *
+         */
+        private static final long     serialVersionUID = 400L;
+        public final static Evaluator INSTANCE         = new StringGreaterEvaluator();
+        private static final ObjectComparator comparator = new ObjectComparator();
+
+        public StringGreaterEvaluator() {
+            super( ValueType.STRING_TYPE,
+                   Operator.GREATER );
+        }
+
+        public boolean evaluate(InternalWorkingMemory workingMemory,
+                                final InternalReadAccessor extractor,
+                                final Object object1, final FieldValue object2) {
+            if( extractor.isNullValue( workingMemory, object1 ) || object2.getValue() == null ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) extractor.getValue( workingMemory, object1 );
+            return comparator.compare( comp, object2.getValue() ) > 0;
+        }
+
+        public boolean evaluateCachedRight(InternalWorkingMemory workingMemory,
+                                           final VariableContextEntry context, final Object left) {
+            if( context.rightNull || context.declaration.getExtractor().isNullValue( workingMemory, left ) ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) ((ObjectVariableContextEntry) context).right;
+            return comparator.compare( comp, context.declaration.getExtractor().getValue( workingMemory, left ) ) > 0;
+        }
+
+        public boolean evaluateCachedLeft(InternalWorkingMemory workingMemory,
+                                          final VariableContextEntry context, final Object right) {
+            if( context.extractor.isNullValue( workingMemory, right ) || ((ObjectVariableContextEntry) context).left == null ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) context.extractor.getValue( workingMemory, right );
+            return comparator.compare( comp, ((ObjectVariableContextEntry) context).left ) > 0;
+        }
+
+        public boolean evaluate(InternalWorkingMemory workingMemory,
+                                final InternalReadAccessor extractor1,
+                                final Object object1,
+                                final InternalReadAccessor extractor2, final Object object2) {
+            if( extractor1.isNullValue( workingMemory, object1 ) || extractor2.isNullValue( workingMemory, object2 ) ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) extractor1.getValue( workingMemory, object1 );
+            return comparator.compare( comp, extractor2.getValue( workingMemory, object2 ) ) > 0;
+        }
+
+        public String toString() {
+            return "String >";
+        }
+    }
+
+    public static class StringGreaterOrEqualEvaluator extends BaseEvaluator {
+        /**
+         *
+         */
+        private static final long     serialVersionUID = 400L;
+        public final static Evaluator INSTANCE         = new StringGreaterOrEqualEvaluator();
+        private static final ObjectComparator comparator = new ObjectComparator();
+
+        public StringGreaterOrEqualEvaluator() {
+            super( ValueType.STRING_TYPE,
+                   Operator.GREATER_OR_EQUAL );
+        }
+
+        public boolean evaluate(InternalWorkingMemory workingMemory,
+                                final InternalReadAccessor extractor,
+                                final Object object1, final FieldValue object2) {
+            if( extractor.isNullValue( workingMemory, object1 ) || object2.getValue() == null ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) extractor.getValue( workingMemory, object1 );
+            return comparator.compare( comp, object2.getValue() ) >= 0;
+        }
+
+        public boolean evaluateCachedRight(InternalWorkingMemory workingMemory,
+                                           final VariableContextEntry context, final Object left) {
+            if( context.rightNull || context.declaration.getExtractor().isNullValue( workingMemory, left ) ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) ((ObjectVariableContextEntry) context).right;
+            return comparator.compare( comp, context.declaration.getExtractor().getValue( workingMemory, left ) ) >= 0;
+        }
+
+        public boolean evaluateCachedLeft(InternalWorkingMemory workingMemory,
+                                          final VariableContextEntry context, final Object right) {
+            if( context.extractor.isNullValue( workingMemory, right ) || ((ObjectVariableContextEntry) context).left == null ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) context.extractor.getValue( workingMemory, right );
+            return comparator.compare( comp, ((ObjectVariableContextEntry) context).left ) >= 0;
+        }
+
+        public boolean evaluate(InternalWorkingMemory workingMemory,
+                                final InternalReadAccessor extractor1,
+                                final Object object1,
+                                final InternalReadAccessor extractor2, final Object object2) {
+            if( extractor1.isNullValue( workingMemory, object1 ) || extractor2.isNullValue( workingMemory, object2 ) ) {
+                return false;
+            }
+            final Comparable comp = (Comparable) extractor1.getValue( workingMemory, object1 );
+            return comparator.compare( comp, extractor2.getValue( workingMemory, object2 ) ) >= 0;
+        }
+
+        public String toString() {
+            return "String >=";
+        }
+    }
+
     public static class ShortLessEvaluator extends BaseEvaluator {
         /**
          *