SERVER-6400: MatchExpression version of Matcher code complete.

27 files changed, 1649 insertions, 294 deletions

diff --git a/src/mongo/SConscript b/src/mongo/SConscript
index e3ea7d89dc3..3f867df752d 100644
--- a/src/mongo/SConscript
+++ b/src/mongo/SConscript
@@ -126,6 +126,16 @@ env.StaticLibrary('expressions',
                            '$BUILD_DIR/third_party/pcrecpp'
                            ] )
 
+env.StaticLibrary('expressions_geo',
+                  ['db/matcher/expression_geo.cpp',
+                   'db/matcher/expression_parser_geo.cpp'],
+                  LIBDEPS=['expressions','geoquery','geoparser'] )
+
+env.StaticLibrary('expressions_where',
+                  ['db/matcher/expression_where.cpp'],
+                  LIBDEPS=['expressions'] )
+
+
 env.CppUnitTest('expression_test',
                 ['db/matcher/expression_test.cpp',
                  'db/matcher/expression_leaf_test.cpp',
@@ -133,6 +143,11 @@ env.CppUnitTest('expression_test',
                  'db/matcher/expression_array_test.cpp'],
                 LIBDEPS=['expressions'] )
 
+env.CppUnitTest('expression_geo_test',
+                ['db/matcher/expression_geo_test.cpp',
+                 'db/matcher/expression_parser_geo_test.cpp'],
+                LIBDEPS=['expressions_geo'] )
+
 env.CppUnitTest('expression_parser_test',
                 ['db/matcher/expression_parser_test.cpp',
                  'db/matcher/expression_parser_array_test.cpp',
@@ -316,6 +331,8 @@ env.StaticLibrary("coredb", [
                            'geoparser',
                            'geoquery',
                            'expressions',
+                           'expressions_geo',
+                           'expressions_where',
                            '$BUILD_DIR/mongo/foundation'])
 
 coreServerFiles = [ "db/client_basic.cpp",
diff --git a/src/mongo/db/matcher.h b/src/mongo/db/matcher.h
index a0a383a0004..8c4cf3ab016 100644
--- a/src/mongo/db/matcher.h
+++ b/src/mongo/db/matcher.h
@@ -206,13 +206,14 @@ namespace mongo {
 
         const BSONObj *getQuery() const { return &_jsobj; };
 
-    private:
         /**
          * Generate a matcher for the provided index key format using the
          * provided full doc matcher.
          */
         Matcher( const Matcher &docMatcher, const BSONObj &constrainIndexKey );
 
+    private:
+
         void addBasic(const BSONElement &e, int c, bool isNot) {
             // TODO May want to selectively ignore these element types based on op type.
             if ( e.type() == MinKey || e.type() == MaxKey )
diff --git a/src/mongo/db/matcher/expression.cpp b/src/mongo/db/matcher/expression.cpp
index 4b9b9f020ba..e2372aa14b6 100644
--- a/src/mongo/db/matcher/expression.cpp
+++ b/src/mongo/db/matcher/expression.cpp
@@ -25,6 +25,11 @@
 
 namespace mongo {
 
+    MatchExpression::MatchExpression( MatchCategory category, MatchType type )
+        : _matchCategory( category ), _matchType( type ){
+    }
+
+
     string MatchExpression::toString() const {
         StringBuilder buf;
         debugString( buf, 0 );
@@ -36,6 +41,11 @@ namespace mongo {
             debug << "    ";
     }
 
+    void AtomicMatchExpression::debugString( StringBuilder& debug, int level ) const {
+        _debugAddSpace( debug, level );
+        debug << "$atomic\n";
+    }
+
 }
 
 
diff --git a/src/mongo/db/matcher/expression.h b/src/mongo/db/matcher/expression.h
index c91f44c1a33..ed4a7f5bf5b 100644
--- a/src/mongo/db/matcher/expression.h
+++ b/src/mongo/db/matcher/expression.h
@@ -29,9 +29,29 @@ namespace mongo {
 
     class MatchExpression {
         MONGO_DISALLOW_COPYING( MatchExpression );
-
     public:
-        MatchExpression(){}
+        enum MatchType {
+            // tree types
+            AND, OR, NOR, NOT,
+
+            // array types
+            ALL, ELEM_MATCH_OBJECT, ELEM_MATCH_VALUE, SIZE,
+
+            // leaf types
+            LTE, LT, EQ, GT, GTE, NE, REGEX, MOD, EXISTS, IN, NIN,
+
+            // special types
+            TYPE_OPERATOR, GEO, WHERE,
+
+            // things that maybe shouldn't even be nodes
+            ATOMIC
+        };
+
+        enum MatchCategory {
+            LEAF, ARRAY, TREE, TYPE_CATEGORY, SPECIAL
+        };
+
+        MatchExpression( MatchCategory category, MatchType type );
         virtual ~MatchExpression(){}
 
         /**
@@ -46,10 +66,45 @@ namespace mongo {
          */
         virtual bool matchesSingleElement( const BSONElement& e ) const = 0;
 
+        virtual size_t numChildren() const { return 0; }
+        virtual const MatchExpression* getChild( size_t i ) const { return NULL; }
+
+        MatchType matchType() const { return _matchType; }
+        MatchCategory matchCategory() const { return _matchCategory; }
+
         virtual string toString() const;
         virtual void debugString( StringBuilder& debug, int level = 0 ) const = 0;
+
+        virtual bool equivalent( const MatchExpression* other ) const = 0;
     protected:
         void _debugAddSpace( StringBuilder& debug, int level ) const;
+
+    private:
+        MatchCategory _matchCategory;
+        MatchType _matchType;
     };
 
+    /**
+     * this isn't really an expression, but a hint to other things
+     * not sure where to put it in the end
+     */
+    class AtomicMatchExpression : public MatchExpression {
+    public:
+        AtomicMatchExpression() : MatchExpression( SPECIAL, ATOMIC ){}
+
+        virtual bool matches( const BSONObj& doc, MatchDetails* details = 0 ) const {
+            return true;
+        }
+
+        virtual bool matchesSingleElement( const BSONElement& e ) const {
+            return true;
+        }
+
+        virtual void debugString( StringBuilder& debug, int level = 0 ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const {
+            return other->matchType() == ATOMIC;
+        }
+
+    };
 }
diff --git a/src/mongo/db/matcher/expression_array.cpp b/src/mongo/db/matcher/expression_array.cpp
index 73be4fb4275..f58655044bf 100644
--- a/src/mongo/db/matcher/expression_array.cpp
+++ b/src/mongo/db/matcher/expression_array.cpp
@@ -119,6 +119,14 @@ namespace mongo {
         debug << _path << " $all TODO\n";
     }
 
+    bool AllMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        const AllMatchExpression* realOther = static_cast<const AllMatchExpression*>( other );
+        return _path == realOther->_path && _arrayEntries.equivalent( realOther->_arrayEntries );
+    }
+
     // -------
 
     bool ArrayMatchingMatchExpression::matches( const BSONObj& doc, MatchDetails* details ) const {
@@ -170,6 +178,26 @@ namespace mongo {
     }
 
 
+    bool ArrayMatchingMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        const ArrayMatchingMatchExpression* realOther =
+            static_cast<const ArrayMatchingMatchExpression*>( other );
+
+        if ( _path != realOther->_path )
+            return false;
+
+        if ( numChildren() != realOther->numChildren() )
+            return false;
+
+        for ( unsigned i = 0; i < numChildren(); i++ )
+            if ( !getChild(i)->equivalent( realOther->getChild(i) ) )
+                return false;
+        return true;
+    }
+
+
     // -------
 
     Status ElemMatchObjectMatchExpression::init( const StringData& path, const MatchExpression* sub ) {
@@ -319,6 +347,24 @@ namespace mongo {
         }
     }
 
+    bool AllElemMatchOp::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        const AllElemMatchOp* realOther = static_cast<const AllElemMatchOp*>( other );
+        if ( _path != realOther->_path )
+            return false;
+
+        if ( _list.size() != realOther->_list.size() )
+            return false;
+
+        for ( unsigned i = 0; i < _list.size(); i++ )
+            if ( !_list[i]->equivalent( realOther->_list[i] ) )
+                return false;
+
+        return true;
+    }
+
 
     // ---------
 
@@ -339,6 +385,14 @@ namespace mongo {
         debug << _path << " $size : " << _size << "\n";
     }
 
+    bool SizeMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        const SizeMatchExpression* realOther = static_cast<const SizeMatchExpression*>( other );
+        return _path == realOther->_path && _size == realOther->_size;
+    }
+
 
     // ------------------
 
diff --git a/src/mongo/db/matcher/expression_array.h b/src/mongo/db/matcher/expression_array.h
index 1d467a16ad1..1d7a2f621d5 100644
--- a/src/mongo/db/matcher/expression_array.h
+++ b/src/mongo/db/matcher/expression_array.h
@@ -42,6 +42,7 @@ namespace mongo {
      */
     class AllMatchExpression : public MatchExpression {
     public:
+        AllMatchExpression() : MatchExpression( ARRAY, ALL ){}
         Status init( const StringData& path );
         ArrayFilterEntries* getArrayFilterEntries() { return &_arrayEntries; }
 
@@ -50,6 +51,9 @@ namespace mongo {
         virtual bool matchesSingleElement( const BSONElement& e ) const;
 
         virtual void debugString( StringBuilder& debug, int level ) const;
+
+        bool equivalent( const MatchExpression* other ) const;
+
     private:
         bool _match( const BSONElementSet& all ) const;
 
@@ -60,6 +64,7 @@ namespace mongo {
 
     class ArrayMatchingMatchExpression : public MatchExpression {
     public:
+        ArrayMatchingMatchExpression( MatchType matchType ) : MatchExpression( ARRAY, matchType ){}
         virtual ~ArrayMatchingMatchExpression(){}
 
         virtual bool matches( const BSONObj& doc, MatchDetails* details ) const;
@@ -71,6 +76,8 @@ namespace mongo {
 
         virtual bool matchesArray( const BSONObj& anArray, MatchDetails* details ) const = 0;
 
+        bool equivalent( const MatchExpression* other ) const;
+
     protected:
         StringData _path;
     };
@@ -78,17 +85,23 @@ namespace mongo {
 
     class ElemMatchObjectMatchExpression : public ArrayMatchingMatchExpression {
     public:
+        ElemMatchObjectMatchExpression() : ArrayMatchingMatchExpression( ELEM_MATCH_OBJECT ){}
         Status init( const StringData& path, const MatchExpression* sub );
 
         bool matchesArray( const BSONObj& anArray, MatchDetails* details ) const;
 
         virtual void debugString( StringBuilder& debug, int level ) const;
+
+        virtual size_t numChildren() const { return 1; }
+        virtual const MatchExpression* getChild( size_t i ) const { return _sub.get(); }
+
     private:
         boost::scoped_ptr<const MatchExpression> _sub;
     };
 
     class ElemMatchValueMatchExpression : public ArrayMatchingMatchExpression {
     public:
+        ElemMatchValueMatchExpression() : ArrayMatchingMatchExpression( ELEM_MATCH_VALUE ){}
         virtual ~ElemMatchValueMatchExpression();
 
         Status init( const StringData& path );
@@ -98,6 +111,10 @@ namespace mongo {
         bool matchesArray( const BSONObj& anArray, MatchDetails* details ) const;
 
         virtual void debugString( StringBuilder& debug, int level ) const;
+
+        virtual size_t numChildren() const { return _subs.size(); }
+        virtual const MatchExpression* getChild( size_t i ) const { return _subs[i]; }
+
     private:
         bool _arrayElementMatchesAll( const BSONElement& e ) const;
 
@@ -110,6 +127,7 @@ namespace mongo {
      */
     class AllElemMatchOp : public MatchExpression {
     public:
+        AllElemMatchOp() : MatchExpression( ARRAY, ALL ){}
         virtual ~AllElemMatchOp();
 
         Status init( const StringData& path );
@@ -123,6 +141,9 @@ namespace mongo {
         virtual bool matchesSingleElement( const BSONElement& e ) const;
 
         virtual void debugString( StringBuilder& debug, int level ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const;
+
     private:
         bool _allMatch( const BSONObj& anArray ) const;
 
@@ -132,11 +153,15 @@ namespace mongo {
 
     class SizeMatchExpression : public ArrayMatchingMatchExpression {
     public:
+        SizeMatchExpression() : ArrayMatchingMatchExpression( SIZE ){}
         Status init( const StringData& path, int size );
 
         virtual bool matchesArray( const BSONObj& anArray, MatchDetails* details ) const;
 
         virtual void debugString( StringBuilder& debug, int level ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const;
+
     private:
         int _size; // >= 0 real, < 0, nothing will match
     };
diff --git a/src/mongo/db/matcher/expression_array_test.cpp b/src/mongo/db/matcher/expression_array_test.cpp
index eceac5a4cde..9b2a0018bb7 100644
--- a/src/mongo/db/matcher/expression_array_test.cpp
+++ b/src/mongo/db/matcher/expression_array_test.cpp
@@ -183,6 +183,31 @@ namespace mongo {
         ASSERT( !all.matches( BSON( "a" << 4 ), NULL ) );
     }
 
+    TEST( AllMatchExpression, Equivalent ) {
+        BSONObj operand = BSON_ARRAY( 5 << 2 );
+
+        AllMatchExpression e1;
+        AllMatchExpression e2;
+        AllMatchExpression e3;
+
+        e1.init( "a" );
+        e1.getArrayFilterEntries()->addEquality( operand[0] );
+        e1.getArrayFilterEntries()->addEquality( operand[1] );
+
+        e2.init( "a" );
+        e2.getArrayFilterEntries()->addEquality( operand[0] );
+
+        e3.init( "b" );
+        e3.getArrayFilterEntries()->addEquality( operand[0] );
+        e3.getArrayFilterEntries()->addEquality( operand[1] );
+
+        ASSERT( e1.equivalent( &e1 ) );
+        ASSERT( !e1.equivalent( &e2 ) );
+        ASSERT( !e1.equivalent( &e3 ) );
+
+    }
+
+
     /**
     TEST( AllMatchExpression, MatchesIndexKey ) {
         BSONObj operand = BSON( "$all" << BSON_ARRAY( 5 ) );
@@ -199,8 +224,8 @@ namespace mongo {
         BSONObj baseOperand = BSON( "b" << 5 );
         BSONObj match = BSON( "a" << BSON_ARRAY( BSON( "b" << 5.0 ) ) );
         BSONObj notMatch = BSON( "a" << BSON_ARRAY( BSON( "b" << 6 ) ) );
-        auto_ptr<ComparisonMatchExpression> eq( new ComparisonMatchExpression() );
-        ASSERT( eq->init( "b", ComparisonMatchExpression::EQ, baseOperand[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eq( new EqualityMatchExpression() );
+        ASSERT( eq->init( "b", baseOperand[ "b" ] ).isOK() );
         ElemMatchObjectMatchExpression op;
         ASSERT( op.init( "a", eq.release() ).isOK() );
         ASSERT( op.matchesSingleElement( match[ "a" ] ) );
@@ -211,8 +236,8 @@ namespace mongo {
         BSONObj baseOperand = BSON( "1" << 5 );
         BSONObj match = BSON( "a" << BSON_ARRAY( BSON_ARRAY( 's' << 5.0 ) ) );
         BSONObj notMatch = BSON( "a" << BSON_ARRAY( BSON_ARRAY( 5 << 6 ) ) );
-        auto_ptr<ComparisonMatchExpression> eq( new ComparisonMatchExpression() );
-        ASSERT( eq->init( "1", ComparisonMatchExpression::EQ, baseOperand[ "1" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eq( new EqualityMatchExpression() );
+        ASSERT( eq->init( "1", baseOperand[ "1" ] ).isOK() );
         ElemMatchObjectMatchExpression op;
         ASSERT( op.init( "a", eq.release() ).isOK() );
         ASSERT( op.matchesSingleElement( match[ "a" ] ) );
@@ -228,12 +253,12 @@ namespace mongo {
         BSONObj notMatch3 = BSON( "a" << BSON_ARRAY( BSON( "b" << BSON_ARRAY( 5 << 6 ) ) ) );
         BSONObj match =
             BSON( "a" << BSON_ARRAY( BSON( "b" << BSON_ARRAY( 5 << 6 ) << "c" << 7 ) ) );
-        auto_ptr<ComparisonMatchExpression> eq1( new ComparisonMatchExpression() );
-        ASSERT( eq1->init( "b", ComparisonMatchExpression::EQ, baseOperand1[ "b" ] ).isOK() );
-        auto_ptr<ComparisonMatchExpression> eq2( new ComparisonMatchExpression() );
-        ASSERT( eq2->init( "b", ComparisonMatchExpression::EQ, baseOperand2[ "b" ] ).isOK() );
-        auto_ptr<ComparisonMatchExpression> eq3( new ComparisonMatchExpression() );
-        ASSERT( eq3->init( "c", ComparisonMatchExpression::EQ, baseOperand3[ "c" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eq1( new EqualityMatchExpression() );
+        ASSERT( eq1->init( "b", baseOperand1[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eq2( new EqualityMatchExpression() );
+        ASSERT( eq2->init( "b", baseOperand2[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eq3( new EqualityMatchExpression() );
+        ASSERT( eq3->init( "c", baseOperand3[ "c" ] ).isOK() );
 
         auto_ptr<AndMatchExpression> andOp( new AndMatchExpression() );
         andOp->add( eq1.release() );
@@ -250,8 +275,8 @@ namespace mongo {
 
     TEST( ElemMatchObjectMatchExpression, MatchesNonArray ) {
         BSONObj baseOperand = BSON( "b" << 5 );
-        auto_ptr<ComparisonMatchExpression> eq( new ComparisonMatchExpression() );
-        ASSERT( eq->init( "b", ComparisonMatchExpression::EQ, baseOperand[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eq( new EqualityMatchExpression() );
+        ASSERT( eq->init( "b", baseOperand[ "b" ] ).isOK() );
         ElemMatchObjectMatchExpression op;
         ASSERT( op.init( "a", eq.release() ).isOK() );
         // Directly nested objects are not matched with $elemMatch.  An intervening array is
@@ -263,8 +288,8 @@ namespace mongo {
 
     TEST( ElemMatchObjectMatchExpression, MatchesArrayObject ) {
         BSONObj baseOperand = BSON( "b" << 5 );
-        auto_ptr<ComparisonMatchExpression> eq( new ComparisonMatchExpression() );
-        ASSERT( eq->init( "b", ComparisonMatchExpression::EQ, baseOperand[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eq( new EqualityMatchExpression() );
+        ASSERT( eq->init( "b", baseOperand[ "b" ] ).isOK() );
         ElemMatchObjectMatchExpression op;
         ASSERT( op.init( "a", eq.release() ).isOK() );
         ASSERT( op.matches( BSON( "a" << BSON_ARRAY( BSON( "b" << 5 ) ) ), NULL ) );
@@ -276,8 +301,8 @@ namespace mongo {
 
     TEST( ElemMatchObjectMatchExpression, MatchesMultipleNamedValues ) {
         BSONObj baseOperand = BSON( "c" << 5 );
-        auto_ptr<ComparisonMatchExpression> eq( new ComparisonMatchExpression() );
-        ASSERT( eq->init( "c", ComparisonMatchExpression::EQ, baseOperand[ "c" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eq( new EqualityMatchExpression() );
+        ASSERT( eq->init( "c", baseOperand[ "c" ] ).isOK() );
         ElemMatchObjectMatchExpression op;
         ASSERT( op.init( "a.b", eq.release() ).isOK() );
         ASSERT( op.matches( BSON( "a" <<
@@ -297,8 +322,8 @@ namespace mongo {
 
     TEST( ElemMatchObjectMatchExpression, ElemMatchKey ) {
         BSONObj baseOperand = BSON( "c" << 6 );
-        auto_ptr<ComparisonMatchExpression> eq( new ComparisonMatchExpression() );
-        ASSERT( eq->init( "c", ComparisonMatchExpression::EQ, baseOperand[ "c" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eq( new EqualityMatchExpression() );
+        ASSERT( eq->init( "c", baseOperand[ "c" ] ).isOK() );
         ElemMatchObjectMatchExpression op;
         ASSERT( op.init( "a.b", eq.release() ).isOK() );
         MatchDetails details;
@@ -342,8 +367,8 @@ namespace mongo {
         BSONObj baseOperand = BSON( "$gt" << 5 );
         BSONObj match = BSON( "a" << BSON_ARRAY( 6 ) );
         BSONObj notMatch = BSON( "a" << BSON_ARRAY( 4 ) );
-        auto_ptr<ComparisonMatchExpression> gt( new ComparisonMatchExpression() );
-        ASSERT( gt->init( "", ComparisonMatchExpression::GT, baseOperand[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> gt( new GTMatchExpression() );
+        ASSERT( gt->init( "", baseOperand[ "$gt" ] ).isOK() );
         ElemMatchValueMatchExpression op;
         ASSERT( op.init( "a", gt.release() ).isOK() );
         ASSERT( op.matchesSingleElement( match[ "a" ] ) );
@@ -356,10 +381,10 @@ namespace mongo {
         BSONObj notMatch1 = BSON( "a" << BSON_ARRAY( 0 << 1 ) );
         BSONObj notMatch2 = BSON( "a" << BSON_ARRAY( 10 << 11 ) );
         BSONObj match = BSON( "a" << BSON_ARRAY( 0 << 5 << 11 ) );
-        auto_ptr<ComparisonMatchExpression> gt( new ComparisonMatchExpression() );
-        ASSERT( gt->init( "", ComparisonMatchExpression::GT, baseOperand1[ "$gt" ] ).isOK() );
-        auto_ptr<ComparisonMatchExpression> lt( new ComparisonMatchExpression() );
-        ASSERT( lt->init( "", ComparisonMatchExpression::LT, baseOperand2[ "$lt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> gt( new GTMatchExpression() );
+        ASSERT( gt->init( "", baseOperand1[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> lt( new LTMatchExpression() );
+        ASSERT( lt->init( "", baseOperand2[ "$lt" ] ).isOK() );
 
         ElemMatchValueMatchExpression op;
         ASSERT( op.init( "a" ).isOK() );
@@ -373,8 +398,8 @@ namespace mongo {
 
     TEST( ElemMatchValueMatchExpression, MatchesNonArray ) {
         BSONObj baseOperand = BSON( "$gt" << 5 );
-        auto_ptr<ComparisonMatchExpression> gt( new ComparisonMatchExpression() );
-        ASSERT( gt->init( "", ComparisonMatchExpression::GT, baseOperand[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> gt( new GTMatchExpression() );
+        ASSERT( gt->init( "", baseOperand[ "$gt" ] ).isOK() );
         ElemMatchObjectMatchExpression op;
         ASSERT( op.init( "a", gt.release() ).isOK() );
         // Directly nested objects are not matched with $elemMatch.  An intervening array is
@@ -385,8 +410,8 @@ namespace mongo {
 
     TEST( ElemMatchValueMatchExpression, MatchesArrayScalar ) {
         BSONObj baseOperand = BSON( "$gt" << 5 );
-        auto_ptr<ComparisonMatchExpression> gt( new ComparisonMatchExpression() );
-        ASSERT( gt->init( "", ComparisonMatchExpression::GT, baseOperand[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> gt( new GTMatchExpression() );
+        ASSERT( gt->init( "", baseOperand[ "$gt" ] ).isOK() );
         ElemMatchValueMatchExpression op;
         ASSERT( op.init( "a", gt.release() ).isOK() );
         ASSERT( op.matches( BSON( "a" << BSON_ARRAY( 6 ) ), NULL ) );
@@ -396,8 +421,8 @@ namespace mongo {
 
     TEST( ElemMatchValueMatchExpression, MatchesMultipleNamedValues ) {
         BSONObj baseOperand = BSON( "$gt" << 5 );
-        auto_ptr<ComparisonMatchExpression> gt( new ComparisonMatchExpression() );
-        ASSERT( gt->init( "", ComparisonMatchExpression::GT, baseOperand[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> gt( new GTMatchExpression() );
+        ASSERT( gt->init( "", baseOperand[ "$gt" ] ).isOK() );
         ElemMatchValueMatchExpression op;
         ASSERT( op.init( "a.b", gt.release() ).isOK() );
         ASSERT( op.matches( BSON( "a" << BSON_ARRAY( BSON( "b" << BSON_ARRAY( 6 ) ) ) ), NULL ) );
@@ -409,8 +434,8 @@ namespace mongo {
 
     TEST( ElemMatchValueMatchExpression, ElemMatchKey ) {
         BSONObj baseOperand = BSON( "$gt" << 6 );
-        auto_ptr<ComparisonMatchExpression> gt( new ComparisonMatchExpression() );
-        ASSERT( gt->init( "", ComparisonMatchExpression::GT, baseOperand[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> gt( new GTMatchExpression() );
+        ASSERT( gt->init( "", baseOperand[ "$gt" ] ).isOK() );
         ElemMatchValueMatchExpression op;
         ASSERT( op.init( "a.b", gt.release() ).isOK() );
         MatchDetails details;
@@ -452,12 +477,12 @@ namespace mongo {
 
 
         BSONObj baseOperanda1 = BSON( "a" << 1 );
-        auto_ptr<ComparisonMatchExpression> eqa1( new ComparisonMatchExpression() );
-        ASSERT( eqa1->init( "a", ComparisonMatchExpression::EQ, baseOperanda1[ "a" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eqa1( new EqualityMatchExpression() );
+        ASSERT( eqa1->init( "a", baseOperanda1[ "a" ] ).isOK() );
 
         BSONObj baseOperandb1 = BSON( "b" << 1 );
-        auto_ptr<ComparisonMatchExpression> eqb1( new ComparisonMatchExpression() );
-        ASSERT( eqb1->init( "b", ComparisonMatchExpression::EQ, baseOperandb1[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eqb1( new EqualityMatchExpression() );
+        ASSERT( eqb1->init( "b", baseOperandb1[ "b" ] ).isOK() );
 
         auto_ptr<AndMatchExpression> and1( new AndMatchExpression() );
         and1->add( eqa1.release() );
@@ -469,12 +494,12 @@ namespace mongo {
         // elemMatch1 = { x : { $elemMatch : { a : 1, b : 1 } } }
 
         BSONObj baseOperanda2 = BSON( "a" << 2 );
-        auto_ptr<ComparisonMatchExpression> eqa2( new ComparisonMatchExpression() );
-        ASSERT( eqa2->init( "a", ComparisonMatchExpression::EQ, baseOperanda2[ "a" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eqa2( new EqualityMatchExpression() );
+        ASSERT( eqa2->init( "a", baseOperanda2[ "a" ] ).isOK() );
 
         BSONObj baseOperandb2 = BSON( "b" << 2 );
-        auto_ptr<ComparisonMatchExpression> eqb2( new ComparisonMatchExpression() );
-        ASSERT( eqb2->init( "b", ComparisonMatchExpression::EQ, baseOperandb2[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> eqb2( new EqualityMatchExpression() );
+        ASSERT( eqb2->init( "b", baseOperandb2[ "b" ] ).isOK() );
 
         auto_ptr<AndMatchExpression> and2( new AndMatchExpression() );
         and2->add( eqa2.release() );
@@ -510,12 +535,12 @@ namespace mongo {
 
     TEST( AllElemMatchOp, Matches ) {
         BSONObj baseOperandgt1 = BSON( "$gt" << 1 );
-        auto_ptr<ComparisonMatchExpression> gt1( new ComparisonMatchExpression() );
-        ASSERT( gt1->init( "", ComparisonMatchExpression::GT, baseOperandgt1[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> gt1( new GTMatchExpression() );
+        ASSERT( gt1->init( "", baseOperandgt1[ "$gt" ] ).isOK() );
 
         BSONObj baseOperandlt1 = BSON( "$lt" << 10 );
-        auto_ptr<ComparisonMatchExpression> lt1( new ComparisonMatchExpression() );
-        ASSERT( lt1->init( "", ComparisonMatchExpression::LT, baseOperandlt1[ "$lt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> lt1( new LTMatchExpression() );
+        ASSERT( lt1->init( "", baseOperandlt1[ "$lt" ] ).isOK() );
 
         auto_ptr<ElemMatchValueMatchExpression> elemMatch1( new ElemMatchValueMatchExpression() );
         elemMatch1->init( "x" );
@@ -523,12 +548,12 @@ namespace mongo {
         elemMatch1->add( lt1.release() );
 
         BSONObj baseOperandgt2 = BSON( "$gt" << 101 );
-        auto_ptr<ComparisonMatchExpression> gt2( new ComparisonMatchExpression() );
-        ASSERT( gt2->init( "", ComparisonMatchExpression::GT, baseOperandgt2[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> gt2( new GTMatchExpression() );
+        ASSERT( gt2->init( "", baseOperandgt2[ "$gt" ] ).isOK() );
 
         BSONObj baseOperandlt2 = BSON( "$lt" << 110 );
-        auto_ptr<ComparisonMatchExpression> lt2( new ComparisonMatchExpression() );
-        ASSERT( lt2->init( "", ComparisonMatchExpression::LT, baseOperandlt2[ "$lt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> lt2( new LTMatchExpression() );
+        ASSERT( lt2->init( "", baseOperandlt2[ "$lt" ] ).isOK() );
 
         auto_ptr<ElemMatchValueMatchExpression> elemMatch2( new ElemMatchValueMatchExpression() );
         elemMatch2->init( "x" );
@@ -630,6 +655,20 @@ namespace mongo {
         ASSERT_EQUALS( "1", details.elemMatchKey() );
     }
 
+    TEST( SizeMatchExpression, Equivalent ) {
+        SizeMatchExpression e1;
+        SizeMatchExpression e2;
+        SizeMatchExpression e3;
+
+        e1.init( "a", 5 );
+        e2.init( "a", 6 );
+        e3.init( "v", 5 );
+
+        ASSERT( e1.equivalent( &e1 ) );
+        ASSERT( !e1.equivalent( &e2 ) );
+        ASSERT( !e1.equivalent( &e3 ) );
+    }
+
     /**
        TEST( SizeMatchExpression, MatchesIndexKey ) {
        BSONObj operand = BSON( "$size" << 4 );
diff --git a/src/mongo/db/matcher/expression_geo.cpp b/src/mongo/db/matcher/expression_geo.cpp
new file mode 100644
index 00000000000..d038a9543ed
--- /dev/null
+++ b/src/mongo/db/matcher/expression_geo.cpp
@@ -0,0 +1,66 @@
+// expression_geo.cpp
+
+/**
+ *    Copyright (C) 2013 10gen Inc.
+ *
+ *    This program is free software: you can redistribute it and/or  modify
+ *    it under the terms of the GNU Affero General Public License, version 3,
+ *    as published by the Free Software Foundation.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Affero General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Affero General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "mongo/pch.h"
+#include "mongo/db/matcher/expression_geo.h"
+
+namespace mongo {
+
+    Status GeoMatchExpression::init( const StringData& path, const GeoQuery& query ) {
+        _path = path;
+        _query = query;
+        return Status::OK();
+    }
+
+    bool GeoMatchExpression::matchesSingleElement( const BSONElement& e ) const {
+        if ( !e.isABSONObj())
+            return false;
+
+        GeometryContainer container;
+        if ( !container.parseFrom( e.Obj() ) )
+                return false;
+
+        return _query.satisfiesPredicate( container );
+    }
+
+    void GeoMatchExpression::debugString( StringBuilder& debug, int level ) const {
+        _debugAddSpace( debug, level );
+        debug << "GEO\n";
+    }
+
+    bool GeoMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        const GeoMatchExpression* realOther = static_cast<const GeoMatchExpression*>( other );
+
+        if ( _path != realOther->_path )
+            return false;
+
+        // TODO:
+        // return _query == realOther->_query;
+        return false;
+    }
+
+    LeafMatchExpression* GeoMatchExpression::shallowClone() const {
+        GeoMatchExpression* next = new GeoMatchExpression();
+        next->init( _path, _query );
+        return next;
+    }
+
+}
diff --git a/src/mongo/db/matcher/expression_geo.h b/src/mongo/db/matcher/expression_geo.h
new file mode 100644
index 00000000000..9808519c586
--- /dev/null
+++ b/src/mongo/db/matcher/expression_geo.h
@@ -0,0 +1,47 @@
+// expression_geo.h
+
+/**
+ *    Copyright (C) 2013 10gen Inc.
+ *
+ *    This program is free software: you can redistribute it and/or  modify
+ *    it under the terms of the GNU Affero General Public License, version 3,
+ *    as published by the Free Software Foundation.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Affero General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Affero General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#pragma once
+
+#include "mongo/db/geo/geoquery.h"
+#include "mongo/db/matcher/expression.h"
+#include "mongo/db/matcher/expression_leaf.h"
+
+namespace mongo {
+
+    class GeoMatchExpression : public LeafMatchExpression {
+    public:
+        GeoMatchExpression() : LeafMatchExpression( GEO ){}
+        virtual ~GeoMatchExpression(){}
+
+        Status init( const StringData& path, const GeoQuery& query );
+
+        virtual bool matchesSingleElement( const BSONElement& e ) const;
+
+        virtual void debugString( StringBuilder& debug, int level = 0 ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const;
+
+        virtual LeafMatchExpression* shallowClone() const;
+
+    private:
+        GeoQuery _query;
+    };
+
+}
diff --git a/src/mongo/db/matcher/expression_geo_test.cpp b/src/mongo/db/matcher/expression_geo_test.cpp
new file mode 100644
index 00000000000..66404a9aa77
--- /dev/null
+++ b/src/mongo/db/matcher/expression_geo_test.cpp
@@ -0,0 +1,48 @@
+// expression_geo_test.cpp
+
+/**
+ *    Copyright (C) 2013 10gen Inc.
+ *
+ *    This program is free software: you can redistribute it and/or  modify
+ *    it under the terms of the GNU Affero General Public License, version 3,
+ *    as published by the Free Software Foundation.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Affero General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Affero General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** Unit tests for MatchExpression operator implementations in match_operators.{h,cpp}. */
+
+#include "mongo/unittest/unittest.h"
+
+#include "mongo/db/jsobj.h"
+#include "mongo/db/json.h"
+#include "mongo/db/matcher.h"
+#include "mongo/db/matcher/expression.h"
+#include "mongo/db/matcher/expression_geo.h"
+
+namespace mongo {
+
+    TEST( ExpressionGeoTest, Geo1 ) {
+        BSONObj query = fromjson("{loc:{$within:{$box:[{x: 4, y:4},[6,6]]}}}");
+
+        GeoQuery gq;
+        ASSERT( gq.parseFrom( query["loc"].Obj() ) );
+
+        GeoMatchExpression ge;
+        ASSERT( ge.init( "a", gq ).isOK() );
+
+        ASSERT(!ge.matches(fromjson("{a: [3,4]}")));
+        ASSERT(ge.matches(fromjson("{a: [4,4]}")));
+        ASSERT(ge.matches(fromjson("{a: [5,5]}")));
+        ASSERT(ge.matches(fromjson("{a: [5,5.1]}")));
+        ASSERT(ge.matches(fromjson("{a: {x: 5, y:5.1}}")));
+
+    }
+
+}
diff --git a/src/mongo/db/matcher/expression_leaf.cpp b/src/mongo/db/matcher/expression_leaf.cpp
index cad5cd110f1..db78d4eaa85 100644
--- a/src/mongo/db/matcher/expression_leaf.cpp
+++ b/src/mongo/db/matcher/expression_leaf.cpp
@@ -75,15 +75,39 @@ namespace mongo {
 
     // -------------
 
-    Status ComparisonMatchExpression::init( const StringData& path, Type type, const BSONElement& rhs ) {
+    bool ComparisonMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( other->matchType() != matchType() )
+            return false;
+        const ComparisonMatchExpression* realOther =
+            static_cast<const ComparisonMatchExpression*>( other );
+
+        return
+            _path == realOther->_path &&
+            _rhs.valuesEqual( realOther->_rhs );
+    }
+
+
+    Status ComparisonMatchExpression::init( const StringData& path, const BSONElement& rhs ) {
         _path = path;
-        _type = type;
         _rhs = rhs;
         if ( rhs.eoo() ) {
             return Status( ErrorCodes::BadValue, "need a real operand" );
         }
 
-        _allHaveToMatch = _type == NE;
+        switch ( matchType() ) {
+        case NE:
+            _allHaveToMatch = true;
+            break;
+        case LT:
+        case LTE:
+        case EQ:
+        case GT:
+        case GTE:
+            _allHaveToMatch = false;
+            break;
+        default:
+            return Status( ErrorCodes::BadValue, "bad match type for ComparisonMatchExpression" );
+        }
 
         return Status::OK();
     }
@@ -96,20 +120,20 @@ namespace mongo {
             // some special cases
             //  jstNULL and undefined are treated the same
             if ( e.canonicalType() + _rhs.canonicalType() == 5 ) {
-                return _type == EQ || _type == LTE || _type == GTE;
+                return matchType() == EQ || matchType() == LTE || matchType() == GTE;
             }
             return _invertForNE( false );
         }
 
         if ( _rhs.type() == Array ) {
-            if ( _type != EQ && _type != NE ) {
+            if ( matchType() != EQ && matchType() != NE ) {
                 return false;
             }
         }
 
         int x = compareElementValues( e, _rhs );
 
-        switch ( _type ) {
+        switch ( matchType() ) {
         case LT:
             return x < 0;
         case LTE:
@@ -122,12 +146,14 @@ namespace mongo {
             return x >= 0;
         case NE:
             return x != 0;
+        default:
+            throw 1;
         }
         throw 1;
     }
 
     bool ComparisonMatchExpression::_invertForNE( bool normal ) const {
-        if ( _type == NE )
+        if ( matchType() == NE )
             return !normal;
         return normal;
     }
@@ -135,13 +161,14 @@ namespace mongo {
     void ComparisonMatchExpression::debugString( StringBuilder& debug, int level ) const {
         _debugAddSpace( debug, level );
         debug << _path << " ";
-        switch ( _type ) {
+        switch ( matchType() ) {
         case LT: debug << "$lt"; break;
         case LTE: debug << "$lte"; break;
         case EQ: debug << "=="; break;
         case GT: debug << "$gt"; break;
         case GTE: debug << "$gte"; break;
         case NE: debug << "$ne"; break;
+        default: debug << " UNKNOWN - should be impossible"; break;
         }
         debug << " " << _rhs.toString( false ) << "\n";
     }
@@ -166,6 +193,18 @@ namespace mongo {
         return options;
     }
 
+    bool RegexMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        const RegexMatchExpression* realOther = static_cast<const RegexMatchExpression*>( other );
+        return
+            _path == realOther->_path &&
+            _regex == realOther->_regex
+            && _flags == realOther->_flags;
+    }
+
+
     Status RegexMatchExpression::init( const StringData& path, const BSONElement& e ) {
         if ( e.type() != RegEx )
             return Status( ErrorCodes::BadValue, "regex not a regex" );
@@ -229,6 +268,17 @@ namespace mongo {
         debug << _path << " mod " << _divisor << " % x == "  << _remainder << "\n";
     }
 
+    bool ModMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        const ModMatchExpression* realOther = static_cast<const ModMatchExpression*>( other );
+        return
+            _path == realOther->_path &&
+            _divisor == realOther->_divisor &&
+            _remainder == realOther->_remainder;
+    }
+
 
     // ------------------
 
@@ -250,6 +300,15 @@ namespace mongo {
         debug << _path << " exists: " << _exists << "\n";
     }
 
+    bool ExistsMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        const ExistsMatchExpression* realOther = static_cast<const ExistsMatchExpression*>( other );
+        return _path == realOther->_path && _exists == realOther->_exists;
+    }
+
+
     // ----
 
     Status TypeMatchExpression::init( const StringData& path, int type ) {
@@ -311,6 +370,15 @@ namespace mongo {
     }
 
 
+    bool TypeMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        const TypeMatchExpression* realOther = static_cast<const TypeMatchExpression*>( other );
+        return _path == realOther->_path && _type == realOther->_type;
+    }
+
+
     // --------
 
     ArrayFilterEntries::ArrayFilterEntries(){
@@ -345,6 +413,27 @@ namespace mongo {
         return Status::OK();
     }
 
+    bool ArrayFilterEntries::equivalent( const ArrayFilterEntries& other ) const {
+        if ( _hasNull != other._hasNull )
+            return false;
+
+        if ( _regexes.size() != other._regexes.size() )
+            return false;
+        for ( unsigned i = 0; i < _regexes.size(); i++ )
+            if ( !_regexes[i]->equivalent( other._regexes[i] ) )
+                return false;
+
+        return _equalities == other._equalities;
+    }
+
+    void ArrayFilterEntries::copyTo( ArrayFilterEntries& toFillIn ) const {
+        toFillIn._hasNull = _hasNull;
+        toFillIn._equalities = _equalities;
+        for ( unsigned i = 0; i < _regexes.size(); i++ )
+            toFillIn._regexes.push_back( static_cast<RegexMatchExpression*>(_regexes[i]->shallowClone()) );
+    }
+
+
     // -----------
 
     void InMatchExpression::init( const StringData& path ) {
@@ -373,12 +462,35 @@ namespace mongo {
         debug << _path << " $in: TODO\n";
     }
 
+    bool InMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+        const InMatchExpression* realOther = static_cast<const InMatchExpression*>( other );
+        log() << "yo: " << _path << " " << realOther->_path << std::endl;
+        return
+            _path == realOther->_path &&
+            _arrayEntries.equivalent( realOther->_arrayEntries );
+    }
+
+    LeafMatchExpression* InMatchExpression::shallowClone() const {
+        InMatchExpression* next = new InMatchExpression();
+        copyTo( next );
+        return next;
+    }
+
+    void InMatchExpression::copyTo( InMatchExpression* toFillIn ) const {
+        toFillIn->init( _path );
+        _arrayEntries.copyTo( toFillIn->_arrayEntries );
+    }
+
+
 
     // ----------
 
     void NinMatchExpression::init( const StringData& path ) {
         _path = path;
         _allHaveToMatch = true;
+        _in.init( path );
     }
 
 
@@ -392,6 +504,22 @@ namespace mongo {
         debug << _path << " $nin: TODO\n";
     }
 
+    bool NinMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        return _in.equivalent( &(static_cast<const NinMatchExpression*>(other)->_in) );
+
+    }
+
+    LeafMatchExpression* NinMatchExpression::shallowClone() const {
+        NinMatchExpression* next = new NinMatchExpression();
+        next->init( _path );
+        _in.copyTo( &next->_in );
+        return next;
+    }
+
+
 }
 
 
diff --git a/src/mongo/db/matcher/expression_leaf.h b/src/mongo/db/matcher/expression_leaf.h
index a0aebe7a345..30b3463fcb6 100644
--- a/src/mongo/db/matcher/expression_leaf.h
+++ b/src/mongo/db/matcher/expression_leaf.h
@@ -30,15 +30,20 @@ namespace mongo {
 
     class LeafMatchExpression : public MatchExpression {
     public:
-        LeafMatchExpression() {
+        LeafMatchExpression( MatchType matchType ) : MatchExpression( LEAF, matchType ) {
             _allHaveToMatch = false;
         }
 
         virtual ~LeafMatchExpression(){}
 
+        virtual LeafMatchExpression* shallowClone() const = 0;
+
         virtual bool matches( const BSONObj& doc, MatchDetails* details = 0 ) const;
 
         virtual bool matchesSingleElement( const BSONElement& e ) const = 0;
+
+        virtual const StringData getPath() const { return _path; }
+
     protected:
         StringData _path;
         bool _allHaveToMatch;
@@ -48,25 +53,90 @@ namespace mongo {
 
     class ComparisonMatchExpression : public LeafMatchExpression {
     public:
-        enum Type { LTE, LT, EQ, GT, GTE, NE };
+        ComparisonMatchExpression( MatchType type ) : LeafMatchExpression( type ){}
 
-        Status init( const StringData& path, Type type, const BSONElement& rhs );
+        Status init( const StringData& path, const BSONElement& rhs );
 
         virtual ~ComparisonMatchExpression(){}
 
-        virtual Type getType() const { return _type; }
-
         virtual bool matchesSingleElement( const BSONElement& e ) const;
 
         virtual void debugString( StringBuilder& debug, int level = 0 ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const;
+
     protected:
         bool _invertForNE( bool normal ) const;
 
-    private:
-        Type _type;
         BSONElement _rhs;
     };
 
+    class EqualityMatchExpression : public ComparisonMatchExpression {
+    public:
+        EqualityMatchExpression() : ComparisonMatchExpression( EQ ){}
+        virtual LeafMatchExpression* shallowClone() const {
+            ComparisonMatchExpression* e = new EqualityMatchExpression();
+            e->init( _path, _rhs  );
+            return e;
+        }
+    };
+
+    class LTEMatchExpression : public ComparisonMatchExpression {
+    public:
+        LTEMatchExpression() : ComparisonMatchExpression( LTE ){}
+        virtual LeafMatchExpression* shallowClone() const {
+            ComparisonMatchExpression* e = new LTEMatchExpression();
+            e->init( _path, _rhs  );
+            return e;
+        }
+
+    };
+
+    class LTMatchExpression : public ComparisonMatchExpression {
+    public:
+        LTMatchExpression() : ComparisonMatchExpression( LT ){}
+        virtual LeafMatchExpression* shallowClone() const {
+            ComparisonMatchExpression* e = new LTMatchExpression();
+            e->init( _path, _rhs  );
+            return e;
+        }
+
+    };
+
+    class GTMatchExpression : public ComparisonMatchExpression {
+    public:
+        GTMatchExpression() : ComparisonMatchExpression( GT ){}
+        virtual LeafMatchExpression* shallowClone() const {
+            ComparisonMatchExpression* e = new GTMatchExpression();
+            e->init( _path, _rhs  );
+            return e;
+        }
+
+    };
+
+    class GTEMatchExpression : public ComparisonMatchExpression {
+    public:
+        GTEMatchExpression() : ComparisonMatchExpression( GTE ){}
+        virtual LeafMatchExpression* shallowClone() const {
+            ComparisonMatchExpression* e = new GTEMatchExpression();
+            e->init( _path, _rhs  );
+            return e;
+        }
+
+    };
+
+    class NEMatchExpression : public ComparisonMatchExpression {
+    public:
+        NEMatchExpression() : ComparisonMatchExpression( NE ){}
+        virtual LeafMatchExpression* shallowClone() const {
+            ComparisonMatchExpression* e = new NEMatchExpression();
+            e->init( _path, _rhs  );
+            return e;
+        }
+
+    };
+
+
     class RegexMatchExpression : public LeafMatchExpression {
     public:
         /**
@@ -76,12 +146,23 @@ namespace mongo {
          */
         static const size_t MaxPatternSize = 32764;
 
+        RegexMatchExpression() : LeafMatchExpression( REGEX ){}
+
         Status init( const StringData& path, const StringData& regex, const StringData& options );
         Status init( const StringData& path, const BSONElement& e );
 
+        virtual LeafMatchExpression* shallowClone() const {
+            RegexMatchExpression* e = new RegexMatchExpression();
+            e->init( _path, _regex, _flags );
+            return e;
+        }
+
         virtual bool matchesSingleElement( const BSONElement& e ) const;
 
         virtual void debugString( StringBuilder& debug, int level ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const;
+
     private:
         std::string _regex;
         std::string _flags;
@@ -90,11 +171,22 @@ namespace mongo {
 
     class ModMatchExpression : public LeafMatchExpression {
     public:
+        ModMatchExpression() : LeafMatchExpression( MOD ){}
+
         Status init( const StringData& path, int divisor, int remainder );
 
+        virtual LeafMatchExpression* shallowClone() const {
+            ModMatchExpression* m = new ModMatchExpression();
+            m->init( _path, _divisor, _remainder );
+            return m;
+        }
+
         virtual bool matchesSingleElement( const BSONElement& e ) const;
 
         virtual void debugString( StringBuilder& debug, int level ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const;
+
     private:
         int _divisor;
         int _remainder;
@@ -102,17 +194,30 @@ namespace mongo {
 
     class ExistsMatchExpression : public LeafMatchExpression {
     public:
+        ExistsMatchExpression() : LeafMatchExpression( EXISTS ){}
+
         Status init( const StringData& path, bool exists );
 
+        virtual LeafMatchExpression* shallowClone() const {
+            ExistsMatchExpression* e = new ExistsMatchExpression();
+            e->init( _path, _exists );
+            return e;
+        }
+
         virtual bool matchesSingleElement( const BSONElement& e ) const;
 
         virtual void debugString( StringBuilder& debug, int level ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const;
+
     private:
         bool _exists;
     };
 
     class TypeMatchExpression : public MatchExpression {
     public:
+        TypeMatchExpression() : MatchExpression( TYPE_CATEGORY, TYPE_OPERATOR ){}
+
         Status init( const StringData& path, int type );
 
         virtual bool matchesSingleElement( const BSONElement& e ) const;
@@ -120,6 +225,8 @@ namespace mongo {
         virtual bool matches( const BSONObj& doc, MatchDetails* details = 0 ) const;
 
         virtual void debugString( StringBuilder& debug, int level ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const;
     private:
         bool _matches( const StringData& path, const BSONObj& doc, MatchDetails* details = 0 ) const;
 
@@ -152,36 +259,54 @@ namespace mongo {
         bool singleNull() const { return size() == 1 && _hasNull; }
         int size() const { return _equalities.size() + _regexes.size(); }
 
+        bool equivalent( const ArrayFilterEntries& other ) const;
+
+        void copyTo( ArrayFilterEntries& toFillIn ) const;
     private:
         bool _hasNull; // if _equalities has a jstNULL element in it
         BSONElementSet _equalities;
         std::vector<RegexMatchExpression*> _regexes;
     };
 
-
     /**
      * query operator: $in
      */
     class InMatchExpression : public LeafMatchExpression {
     public:
+        InMatchExpression() : LeafMatchExpression( IN ){}
         void init( const StringData& path );
+
+        virtual LeafMatchExpression* shallowClone() const;
+
         ArrayFilterEntries* getArrayFilterEntries() { return &_arrayEntries; }
 
         virtual bool matchesSingleElement( const BSONElement& e ) const;
 
         virtual void debugString( StringBuilder& debug, int level ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const;
+
+        void copyTo( InMatchExpression* toFillIn ) const;
+
     private:
         ArrayFilterEntries _arrayEntries;
     };
 
     class NinMatchExpression : public LeafMatchExpression {
     public:
+        NinMatchExpression() : LeafMatchExpression( NIN ){}
         void init( const StringData& path );
+
+        virtual LeafMatchExpression* shallowClone() const;
+
         ArrayFilterEntries* getArrayFilterEntries() { return _in.getArrayFilterEntries(); }
 
         virtual bool matchesSingleElement( const BSONElement& e ) const;
 
         virtual void debugString( StringBuilder& debug, int level ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const;
+
     private:
         InMatchExpression _in;
     };
diff --git a/src/mongo/db/matcher/expression_leaf_test.cpp b/src/mongo/db/matcher/expression_leaf_test.cpp
index f6db53166c9..e102f92f8c5 100644
--- a/src/mongo/db/matcher/expression_leaf_test.cpp
+++ b/src/mongo/db/matcher/expression_leaf_test.cpp
@@ -30,39 +30,40 @@ namespace mongo {
         BSONObj match = BSON( "a" << 5.0 );
         BSONObj notMatch = BSON( "a" << 6 );
 
-        ComparisonMatchExpression eq;
-        eq.init( "", ComparisonMatchExpression::EQ, operand["a"] );
+        EqualityMatchExpression eq;
+        eq.init( "", operand["a"] );
         ASSERT( eq.matchesSingleElement( match.firstElement() ) );
         ASSERT( !eq.matchesSingleElement( notMatch.firstElement() ) );
-    }
 
+        ASSERT( eq.equivalent( &eq ) );
+    }
 
     TEST( EqOp, InvalidEooOperand ) {
         BSONObj operand;
-        ComparisonMatchExpression eq;
-        ASSERT( !eq.init( "", ComparisonMatchExpression::EQ, operand.firstElement() ).isOK() );
+        EqualityMatchExpression eq;
+        ASSERT( !eq.init( "", operand.firstElement() ).isOK() );
     }
 
     TEST( EqOp, MatchesScalar ) {
         BSONObj operand = BSON( "a" << 5 );
-        ComparisonMatchExpression eq;
-        eq.init( "a", ComparisonMatchExpression::EQ, operand[ "a" ] );
+        EqualityMatchExpression eq;
+        eq.init( "a", operand[ "a" ] );
         ASSERT( eq.matches( BSON( "a" << 5.0 ), NULL ) );
         ASSERT( !eq.matches( BSON( "a" << 4 ), NULL ) );
     }
 
     TEST( EqOp, MatchesArrayValue ) {
         BSONObj operand = BSON( "a" << 5 );
-        ComparisonMatchExpression eq;
-        eq.init( "a", ComparisonMatchExpression::EQ, operand[ "a" ] );
+        EqualityMatchExpression eq;
+        eq.init( "a", operand[ "a" ] );
         ASSERT( eq.matches( BSON( "a" << BSON_ARRAY( 5.0 << 6 ) ), NULL ) );
         ASSERT( !eq.matches( BSON( "a" << BSON_ARRAY( 6 << 7 ) ), NULL ) );
     }
 
     TEST( EqOp, MatchesReferencedObjectValue ) {
         BSONObj operand = BSON( "a.b" << 5 );
-        ComparisonMatchExpression eq;
-        eq.init( "a.b", ComparisonMatchExpression::EQ, operand[ "a.b" ] );
+        EqualityMatchExpression eq;
+        eq.init( "a.b", operand[ "a.b" ] );
         ASSERT( eq.matches( BSON( "a" << BSON( "b" << 5 ) ), NULL ) );
         ASSERT( eq.matches( BSON( "a" << BSON( "b" << BSON_ARRAY( 5 ) ) ), NULL ) );
         ASSERT( eq.matches( BSON( "a" << BSON_ARRAY( BSON( "b" << 5 ) ) ), NULL ) );
@@ -70,16 +71,16 @@ namespace mongo {
 
     TEST( EqOp, MatchesReferencedArrayValue ) {
         BSONObj operand = BSON( "a.0" << 5 );
-        ComparisonMatchExpression eq;
-        eq.init( "a.0", ComparisonMatchExpression::EQ, operand[ "a.0" ] );
+        EqualityMatchExpression eq;
+        eq.init( "a.0", operand[ "a.0" ] );
         ASSERT( eq.matches( BSON( "a" << BSON_ARRAY( 5 ) ), NULL ) );
         ASSERT( !eq.matches( BSON( "a" << BSON_ARRAY( BSON_ARRAY( 5 ) ) ), NULL ) );
     }
 
     TEST( EqOp, MatchesNull ) {
         BSONObj operand = BSON( "a" << BSONNULL );
-        ComparisonMatchExpression eq;
-        eq.init( "a", ComparisonMatchExpression::EQ, operand[ "a" ] );
+        EqualityMatchExpression eq;
+        eq.init( "a", operand[ "a" ] );
         ASSERT( eq.matches( BSONObj(), NULL ) );
         ASSERT( eq.matches( BSON( "a" << BSONNULL ), NULL ) );
         ASSERT( !eq.matches( BSON( "a" << 4 ), NULL ) );
@@ -87,8 +88,8 @@ namespace mongo {
 
     TEST( EqOp, MatchesMinKey ) {
         BSONObj operand = BSON( "a" << MinKey );
-        ComparisonMatchExpression eq;
-        eq.init( "a", ComparisonMatchExpression::EQ, operand[ "a" ] );
+        EqualityMatchExpression eq;
+        eq.init( "a", operand[ "a" ] );
         ASSERT( eq.matches( BSON( "a" << MinKey ), NULL ) );
         ASSERT( !eq.matches( BSON( "a" << MaxKey ), NULL ) );
         ASSERT( !eq.matches( BSON( "a" << 4 ), NULL ) );
@@ -98,8 +99,8 @@ namespace mongo {
 
     TEST( EqOp, MatchesMaxKey ) {
         BSONObj operand = BSON( "a" << MaxKey );
-        ComparisonMatchExpression eq;
-        ASSERT( eq.init( "a", ComparisonMatchExpression::EQ, operand[ "a" ] ).isOK() );
+        EqualityMatchExpression eq;
+        ASSERT( eq.init( "a", operand[ "a" ] ).isOK() );
         ASSERT( eq.matches( BSON( "a" << MaxKey ), NULL ) );
         ASSERT( !eq.matches( BSON( "a" << MinKey ), NULL ) );
         ASSERT( !eq.matches( BSON( "a" << 4 ), NULL ) );
@@ -107,8 +108,8 @@ namespace mongo {
 
     TEST( EqOp, MatchesFullArray ) {
         BSONObj operand = BSON( "a" << BSON_ARRAY( 1 << 2 ) );
-        ComparisonMatchExpression eq;
-        ASSERT( eq.init( "a", ComparisonMatchExpression::EQ, operand[ "a" ] ).isOK() );
+        EqualityMatchExpression eq;
+        ASSERT( eq.init( "a", operand[ "a" ] ).isOK() );
         ASSERT( eq.matches( BSON( "a" << BSON_ARRAY( 1 << 2 ) ), NULL ) );
         ASSERT( !eq.matches( BSON( "a" << BSON_ARRAY( 1 << 2 << 3 ) ), NULL ) );
         ASSERT( !eq.matches( BSON( "a" << BSON_ARRAY( 1 ) ), NULL ) );
@@ -117,8 +118,8 @@ namespace mongo {
 
     TEST( EqOp, ElemMatchKey ) {
         BSONObj operand = BSON( "a" << 5 );
-        ComparisonMatchExpression eq;
-        ASSERT( eq.init( "a", ComparisonMatchExpression::EQ, operand[ "a" ] ).isOK() );
+        EqualityMatchExpression eq;
+        ASSERT( eq.init( "a", operand[ "a" ] ).isOK() );
         MatchDetails details;
         details.requestElemMatchKey();
         ASSERT( !eq.matches( BSON( "a" << 4 ), &details ) );
@@ -130,11 +131,27 @@ namespace mongo {
         ASSERT_EQUALS( "2", details.elemMatchKey() );
     }
 
+    TEST( EqOp, Equality1 ) {
+        EqualityMatchExpression eq1;
+        EqualityMatchExpression eq2;
+        EqualityMatchExpression eq3;
+
+        BSONObj operand = BSON( "a" << 5 << "b" << 5 << "c" << 4 );
+
+        eq1.init( "a", operand["a"] );
+        eq2.init( "a", operand["b"] );
+        eq3.init( "c", operand["c"] );
+
+        ASSERT( eq1.equivalent( &eq1 ) );
+        ASSERT( eq1.equivalent( &eq2 ) );
+        ASSERT( !eq1.equivalent( &eq3 ) );
+    }
+
     /**
        TEST( EqOp, MatchesIndexKeyScalar ) {
        BSONObj operand = BSON( "a" << 6 );
-       ComparisonMatchExpression eq;
-       ASSERT( eq.init( "a", ComparisonMatchExpression::EQ, operand[ "a" ] ).isOK() );
+       EqualityMatchExpression eq;
+       ASSERT( eq.init( "a", operand[ "a" ] ).isOK() );
        IndexSpec indexSpec( BSON( "a" << 1 ) );
        ASSERT( MatchMatchExpression::PartialMatchResult_True ==
        eq.matchesIndexKey( BSON( "" << 6 ), indexSpec ) );
@@ -146,8 +163,8 @@ namespace mongo {
 
        TEST( EqOp, MatchesIndexKeyMissing ) {
        BSONObj operand = BSON( "a" << 6 );
-       ComparisonMatchExpression eq;
-       ASSERT( eq.init( "a", ComparisonMatchExpression::EQ, operand[ "a" ] ).isOK() );
+       EqualityMatchExpression eq;
+       ASSERT( eq.init( "a", operand[ "a" ] ).isOK() );
        IndexSpec indexSpec( BSON( "b" << 1 ) );
        ASSERT( MatchMatchExpression::PartialMatchResult_Unknown ==
        eq.matchesIndexKey( BSON( "" << 6 ), indexSpec ) );
@@ -186,8 +203,8 @@ namespace mongo {
         BSONObj notMatch = BSON( "a" << 6 );
         BSONObj notMatchEqual = BSON( "a" << 5 );
         BSONObj notMatchWrongType = BSON( "a" << "foo" );
-        ComparisonMatchExpression lt;
-        ASSERT( lt.init( "", ComparisonMatchExpression::LT, operand[ "$lt" ] ).isOK() );
+        LTMatchExpression lt;
+        ASSERT( lt.init( "", operand[ "$lt" ] ).isOK() );
         ASSERT( lt.matchesSingleElement( match.firstElement() ) );
         ASSERT( !lt.matchesSingleElement( notMatch.firstElement() ) );
         ASSERT( !lt.matchesSingleElement( notMatchEqual.firstElement() ) );
@@ -196,38 +213,38 @@ namespace mongo {
 
     TEST( LtOp, InvalidEooOperand ) {
         BSONObj operand;
-        ComparisonMatchExpression lt;
-        ASSERT( !lt.init( "", ComparisonMatchExpression::LT, operand.firstElement() ).isOK() );
+        LTMatchExpression lt;
+        ASSERT( !lt.init( "", operand.firstElement() ).isOK() );
     }
 
     TEST( LtOp, MatchesScalar ) {
         BSONObj operand = BSON( "$lt" << 5 );
-        ComparisonMatchExpression lt;
-        ASSERT( lt.init( "a", ComparisonMatchExpression::LT, operand[ "$lt" ] ).isOK() );
+        LTMatchExpression lt;
+        ASSERT( lt.init( "a", operand[ "$lt" ] ).isOK() );
         ASSERT( lt.matches( BSON( "a" << 4.5 ), NULL ) );
         ASSERT( !lt.matches( BSON( "a" << 6 ), NULL ) );
     }
 
     TEST( LtOp, MatchesArrayValue ) {
         BSONObj operand = BSON( "$lt" << 5 );
-        ComparisonMatchExpression lt;
-        ASSERT( lt.init( "a", ComparisonMatchExpression::LT, operand[ "$lt" ] ).isOK() );
+        LTMatchExpression lt;
+        ASSERT( lt.init( "a", operand[ "$lt" ] ).isOK() );
         ASSERT( lt.matches( BSON( "a" << BSON_ARRAY( 6 << 4.5 ) ), NULL ) );
         ASSERT( !lt.matches( BSON( "a" << BSON_ARRAY( 6 << 7 ) ), NULL ) );
     }
 
     TEST( LtOp, MatchesWholeArray ) {
         BSONObj operand = BSON( "$lt" << BSON_ARRAY( 5 ) );
-        ComparisonMatchExpression lt;
-        ASSERT( lt.init( "a", ComparisonMatchExpression::LT, operand[ "$lt" ] ).isOK() );
+        LTMatchExpression lt;
+        ASSERT( lt.init( "a", operand[ "$lt" ] ).isOK() );
         // Arrays are not comparable as inequalities.
         ASSERT( !lt.matches( BSON( "a" << BSON_ARRAY( 4 ) ), NULL ) );
     }
 
     TEST( LtOp, MatchesNull ) {
         BSONObj operand = BSON( "$lt" << BSONNULL );
-        ComparisonMatchExpression lt;
-        ASSERT( lt.init( "a", ComparisonMatchExpression::LT, operand[ "$lt" ] ).isOK() );
+        LTMatchExpression lt;
+        ASSERT( lt.init( "a", operand[ "$lt" ] ).isOK() );
         ASSERT( !lt.matches( BSONObj(), NULL ) );
         ASSERT( !lt.matches( BSON( "a" << BSONNULL ), NULL ) );
         ASSERT( !lt.matches( BSON( "a" << 4 ), NULL ) );
@@ -235,8 +252,8 @@ namespace mongo {
 
     TEST( LtOp, MatchesMinKey ) {
         BSONObj operand = BSON( "a" << MinKey );
-        ComparisonMatchExpression lt;
-        ASSERT( lt.init( "a", ComparisonMatchExpression::LT, operand[ "a" ] ).isOK() );
+        LTMatchExpression lt;
+        ASSERT( lt.init( "a", operand[ "a" ] ).isOK() );
         ASSERT( !lt.matches( BSON( "a" << MinKey ), NULL ) );
         ASSERT( !lt.matches( BSON( "a" << MaxKey ), NULL ) );
         ASSERT( !lt.matches( BSON( "a" << 4 ), NULL ) );
@@ -244,8 +261,8 @@ namespace mongo {
 
     TEST( LtOp, MatchesMaxKey ) {
         BSONObj operand = BSON( "a" << MaxKey );
-        ComparisonMatchExpression lt;
-        ASSERT( lt.init( "a", ComparisonMatchExpression::LT, operand[ "a" ] ).isOK() );
+        LTMatchExpression lt;
+        ASSERT( lt.init( "a", operand[ "a" ] ).isOK() );
         ASSERT( !lt.matches( BSON( "a" << MaxKey ), NULL ) );
         ASSERT( lt.matches( BSON( "a" << MinKey ), NULL ) );
         ASSERT( lt.matches( BSON( "a" << 4 ), NULL ) );
@@ -253,8 +270,8 @@ namespace mongo {
 
     TEST( LtOp, ElemMatchKey ) {
         BSONObj operand = BSON( "$lt" << 5 );
-        ComparisonMatchExpression lt;
-        ASSERT( lt.init( "a", ComparisonMatchExpression::LT, operand[ "$lt" ] ).isOK() );
+        LTMatchExpression lt;
+        ASSERT( lt.init( "a", operand[ "$lt" ] ).isOK() );
         MatchDetails details;
         details.requestElemMatchKey();
         ASSERT( !lt.matches( BSON( "a" << 6 ), &details ) );
@@ -322,8 +339,8 @@ namespace mongo {
         BSONObj equalMatch = BSON( "a" << 5 );
         BSONObj notMatch = BSON( "a" << 6 );
         BSONObj notMatchWrongType = BSON( "a" << "foo" );
-        ComparisonMatchExpression lte;
-        ASSERT( lte.init( "", ComparisonMatchExpression::LTE, operand[ "$lte" ] ).isOK() );
+        LTEMatchExpression lte;
+        ASSERT( lte.init( "", operand[ "$lte" ] ).isOK() );
         ASSERT( lte.matchesSingleElement( match.firstElement() ) );
         ASSERT( lte.matchesSingleElement( equalMatch.firstElement() ) );
         ASSERT( !lte.matchesSingleElement( notMatch.firstElement() ) );
@@ -332,38 +349,38 @@ namespace mongo {
 
     TEST( LteOp, InvalidEooOperand ) {
         BSONObj operand;
-        ComparisonMatchExpression lte;
-        ASSERT( !lte.init( "", ComparisonMatchExpression::LTE, operand.firstElement() ).isOK() );
+        LTEMatchExpression lte;
+        ASSERT( !lte.init( "", operand.firstElement() ).isOK() );
     }
 
     TEST( LteOp, MatchesScalar ) {
         BSONObj operand = BSON( "$lte" << 5 );
-        ComparisonMatchExpression lte;
-        ASSERT( lte.init( "a", ComparisonMatchExpression::LTE, operand[ "$lte" ] ).isOK() );
+        LTEMatchExpression lte;
+        ASSERT( lte.init( "a", operand[ "$lte" ] ).isOK() );
         ASSERT( lte.matches( BSON( "a" << 4.5 ), NULL ) );
         ASSERT( !lte.matches( BSON( "a" << 6 ), NULL ) );
     }
 
     TEST( LteOp, MatchesArrayValue ) {
         BSONObj operand = BSON( "$lte" << 5 );
-        ComparisonMatchExpression lte;
-        ASSERT( lte.init( "a", ComparisonMatchExpression::LTE, operand[ "$lte" ] ).isOK() );
+        LTEMatchExpression lte;
+        ASSERT( lte.init( "a", operand[ "$lte" ] ).isOK() );
         ASSERT( lte.matches( BSON( "a" << BSON_ARRAY( 6 << 4.5 ) ), NULL ) );
         ASSERT( !lte.matches( BSON( "a" << BSON_ARRAY( 6 << 7 ) ), NULL ) );
     }
 
     TEST( LteOp, MatchesWholeArray ) {
         BSONObj operand = BSON( "$lte" << BSON_ARRAY( 5 ) );
-        ComparisonMatchExpression lte;
-        ASSERT( lte.init( "a", ComparisonMatchExpression::LTE, operand[ "$lte" ] ).isOK() );
+        LTEMatchExpression lte;
+        ASSERT( lte.init( "a", operand[ "$lte" ] ).isOK() );
         // Arrays are not comparable as inequalities.
         ASSERT( !lte.matches( BSON( "a" << BSON_ARRAY( 4 ) ), NULL ) );
     }
 
     TEST( LteOp, MatchesNull ) {
         BSONObj operand = BSON( "$lte" << BSONNULL );
-        ComparisonMatchExpression lte;
-        ASSERT( lte.init( "a", ComparisonMatchExpression::LTE, operand[ "$lte" ] ).isOK() );
+        LTEMatchExpression lte;
+        ASSERT( lte.init( "a", operand[ "$lte" ] ).isOK() );
         ASSERT( lte.matches( BSONObj(), NULL ) );
         ASSERT( lte.matches( BSON( "a" << BSONNULL ), NULL ) );
         ASSERT( !lte.matches( BSON( "a" << 4 ), NULL ) );
@@ -371,8 +388,8 @@ namespace mongo {
 
     TEST( LteOp, MatchesMinKey ) {
         BSONObj operand = BSON( "a" << MinKey );
-        ComparisonMatchExpression lte;
-        ASSERT( lte.init( "a", ComparisonMatchExpression::LTE, operand[ "a" ] ).isOK() );
+        LTEMatchExpression lte;
+        ASSERT( lte.init( "a", operand[ "a" ] ).isOK() );
         ASSERT( lte.matches( BSON( "a" << MinKey ), NULL ) );
         ASSERT( !lte.matches( BSON( "a" << MaxKey ), NULL ) );
         ASSERT( !lte.matches( BSON( "a" << 4 ), NULL ) );
@@ -380,8 +397,8 @@ namespace mongo {
 
     TEST( LteOp, MatchesMaxKey ) {
         BSONObj operand = BSON( "a" << MaxKey );
-        ComparisonMatchExpression lte;
-        ASSERT( lte.init( "a", ComparisonMatchExpression::LTE, operand[ "a" ] ).isOK() );
+        LTEMatchExpression lte;
+        ASSERT( lte.init( "a", operand[ "a" ] ).isOK() );
         ASSERT( lte.matches( BSON( "a" << MaxKey ), NULL ) );
         ASSERT( lte.matches( BSON( "a" << MinKey ), NULL ) );
         ASSERT( lte.matches( BSON( "a" << 4 ), NULL ) );
@@ -390,8 +407,8 @@ namespace mongo {
 
     TEST( LteOp, ElemMatchKey ) {
         BSONObj operand = BSON( "$lte" << 5 );
-        ComparisonMatchExpression lte;
-        ASSERT( lte.init( "a", ComparisonMatchExpression::LTE, operand[ "$lte" ] ).isOK() );
+        LTEMatchExpression lte;
+        ASSERT( lte.init( "a", operand[ "$lte" ] ).isOK() );
         MatchDetails details;
         details.requestElemMatchKey();
         ASSERT( !lte.matches( BSON( "a" << 6 ), &details ) );
@@ -470,38 +487,38 @@ namespace mongo {
 
     TEST( GtOp, InvalidEooOperand ) {
         BSONObj operand;
-        ComparisonMatchExpression gt;
-        ASSERT( !gt.init( "", ComparisonMatchExpression::GT, operand.firstElement() ).isOK() );
+        GTMatchExpression gt;
+        ASSERT( !gt.init( "", operand.firstElement() ).isOK() );
     }
 
     TEST( GtOp, MatchesScalar ) {
         BSONObj operand = BSON( "$gt" << 5 );
-        ComparisonMatchExpression gt;
-        ASSERT( gt.init( "a", ComparisonMatchExpression::GT, operand[ "$gt" ] ).isOK() );
+        GTMatchExpression gt;
+        ASSERT( gt.init( "a", operand[ "$gt" ] ).isOK() );
         ASSERT( gt.matches( BSON( "a" << 5.5 ), NULL ) );
         ASSERT( !gt.matches( BSON( "a" << 4 ), NULL ) );
     }
 
     TEST( GtOp, MatchesArrayValue ) {
         BSONObj operand = BSON( "$gt" << 5 );
-        ComparisonMatchExpression gt;
-        ASSERT( gt.init( "a", ComparisonMatchExpression::GT, operand[ "$gt" ] ).isOK() );
+        GTMatchExpression gt;
+        ASSERT( gt.init( "a", operand[ "$gt" ] ).isOK() );
         ASSERT( gt.matches( BSON( "a" << BSON_ARRAY( 3 << 5.5 ) ), NULL ) );
         ASSERT( !gt.matches( BSON( "a" << BSON_ARRAY( 2 << 4 ) ), NULL ) );
     }
 
     TEST( GtOp, MatchesWholeArray ) {
         BSONObj operand = BSON( "$gt" << BSON_ARRAY( 5 ) );
-        ComparisonMatchExpression gt;
-        ASSERT( gt.init( "a", ComparisonMatchExpression::GT, operand[ "$gt" ] ).isOK() );
+        GTMatchExpression gt;
+        ASSERT( gt.init( "a", operand[ "$gt" ] ).isOK() );
         // Arrays are not comparable as inequalities.
         ASSERT( !gt.matches( BSON( "a" << BSON_ARRAY( 6 ) ), NULL ) );
     }
 
     TEST( GtOp, MatchesNull ) {
         BSONObj operand = BSON( "$gt" << BSONNULL );
-        ComparisonMatchExpression gt;
-        ASSERT( gt.init( "a", ComparisonMatchExpression::GT, operand[ "$gt" ] ).isOK() );
+        GTMatchExpression gt;
+        ASSERT( gt.init( "a", operand[ "$gt" ] ).isOK() );
         ASSERT( !gt.matches( BSONObj(), NULL ) );
         ASSERT( !gt.matches( BSON( "a" << BSONNULL ), NULL ) );
         ASSERT( !gt.matches( BSON( "a" << 4 ), NULL ) );
@@ -509,8 +526,8 @@ namespace mongo {
 
     TEST( GtOp, MatchesMinKey ) {
         BSONObj operand = BSON( "a" << MinKey );
-        ComparisonMatchExpression gt;
-        ASSERT( gt.init( "a", ComparisonMatchExpression::GT, operand[ "a" ] ).isOK() );
+        GTMatchExpression gt;
+        ASSERT( gt.init( "a", operand[ "a" ] ).isOK() );
         ASSERT( !gt.matches( BSON( "a" << MinKey ), NULL ) );
         ASSERT( gt.matches( BSON( "a" << MaxKey ), NULL ) );
         ASSERT( gt.matches( BSON( "a" << 4 ), NULL ) );
@@ -518,8 +535,8 @@ namespace mongo {
 
     TEST( GtOp, MatchesMaxKey ) {
         BSONObj operand = BSON( "a" << MaxKey );
-        ComparisonMatchExpression gt;
-        ASSERT( gt.init( "a", ComparisonMatchExpression::GT, operand[ "a" ] ).isOK() );
+        GTMatchExpression gt;
+        ASSERT( gt.init( "a", operand[ "a" ] ).isOK() );
         ASSERT( !gt.matches( BSON( "a" << MaxKey ), NULL ) );
         ASSERT( !gt.matches( BSON( "a" << MinKey ), NULL ) );
         ASSERT( !gt.matches( BSON( "a" << 4 ), NULL ) );
@@ -527,8 +544,8 @@ namespace mongo {
 
     TEST( GtOp, ElemMatchKey ) {
         BSONObj operand = BSON( "$gt" << 5 );
-        ComparisonMatchExpression gt;
-        ASSERT( gt.init( "a", ComparisonMatchExpression::GT, operand[ "$gt" ] ).isOK() );
+        GTMatchExpression gt;
+        ASSERT( gt.init( "a", operand[ "$gt" ] ).isOK() );
         MatchDetails details;
         details.requestElemMatchKey();
         ASSERT( !gt.matches( BSON( "a" << 4 ), &details ) );
@@ -597,8 +614,8 @@ namespace mongo {
         BSONObj equalMatch = BSON( "a" << 5 );
         BSONObj notMatch = BSON( "a" << 4 );
         BSONObj notMatchWrongType = BSON( "a" << "foo" );
-        ComparisonMatchExpression gte;
-        ASSERT( gte.init( "", ComparisonMatchExpression::GTE, operand[ "$gte" ] ).isOK() );
+        GTEMatchExpression gte;
+        ASSERT( gte.init( "", operand[ "$gte" ] ).isOK() );
         ASSERT( gte.matchesSingleElement( match.firstElement() ) );
         ASSERT( gte.matchesSingleElement( equalMatch.firstElement() ) );
         ASSERT( !gte.matchesSingleElement( notMatch.firstElement() ) );
@@ -607,38 +624,38 @@ namespace mongo {
 
     TEST( ComparisonMatchExpression, InvalidEooOperand ) {
         BSONObj operand;
-        ComparisonMatchExpression gte;
-        ASSERT( !gte.init( "", ComparisonMatchExpression::GTE, operand.firstElement() ).isOK() );
+        GTEMatchExpression gte;
+        ASSERT( !gte.init( "", operand.firstElement() ).isOK() );
     }
 
     TEST( ComparisonMatchExpression, MatchesScalar ) {
         BSONObj operand = BSON( "$gte" << 5 );
-        ComparisonMatchExpression gte;
-        ASSERT( gte.init( "a", ComparisonMatchExpression::GTE, operand[ "$gte" ] ).isOK() );
+        GTEMatchExpression gte;
+        ASSERT( gte.init( "a", operand[ "$gte" ] ).isOK() );
         ASSERT( gte.matches( BSON( "a" << 5.5 ), NULL ) );
         ASSERT( !gte.matches( BSON( "a" << 4 ), NULL ) );
     }
 
     TEST( ComparisonMatchExpression, MatchesArrayValue ) {
         BSONObj operand = BSON( "$gte" << 5 );
-        ComparisonMatchExpression gte;
-        ASSERT( gte.init( "a", ComparisonMatchExpression::GTE, operand[ "$gte" ] ).isOK() );
+        GTEMatchExpression gte;
+        ASSERT( gte.init( "a", operand[ "$gte" ] ).isOK() );
         ASSERT( gte.matches( BSON( "a" << BSON_ARRAY( 4 << 5.5 ) ), NULL ) );
         ASSERT( !gte.matches( BSON( "a" << BSON_ARRAY( 1 << 2 ) ), NULL ) );
     }
 
     TEST( ComparisonMatchExpression, MatchesWholeArray ) {
         BSONObj operand = BSON( "$gte" << BSON_ARRAY( 5 ) );
-        ComparisonMatchExpression gte;
-        ASSERT( gte.init( "a", ComparisonMatchExpression::GTE, operand[ "$gte" ] ).isOK() );
+        GTEMatchExpression gte;
+        ASSERT( gte.init( "a", operand[ "$gte" ] ).isOK() );
         // Arrays are not comparable as inequalities.
         ASSERT( !gte.matches( BSON( "a" << BSON_ARRAY( 6 ) ), NULL ) );
     }
 
     TEST( ComparisonMatchExpression, MatchesNull ) {
         BSONObj operand = BSON( "$gte" << BSONNULL );
-        ComparisonMatchExpression gte;
-        ASSERT( gte.init( "a", ComparisonMatchExpression::GTE, operand[ "$gte" ] ).isOK() );
+        GTEMatchExpression gte;
+        ASSERT( gte.init( "a", operand[ "$gte" ] ).isOK() );
         ASSERT( gte.matches( BSONObj(), NULL ) );
         ASSERT( gte.matches( BSON( "a" << BSONNULL ), NULL ) );
         ASSERT( !gte.matches( BSON( "a" << 4 ), NULL ) );
@@ -646,8 +663,8 @@ namespace mongo {
 
     TEST( ComparisonMatchExpression, MatchesMinKey ) {
         BSONObj operand = BSON( "a" << MinKey );
-        ComparisonMatchExpression gte;
-        ASSERT( gte.init( "a", ComparisonMatchExpression::GTE, operand[ "a" ] ).isOK() );
+        GTEMatchExpression gte;
+        ASSERT( gte.init( "a", operand[ "a" ] ).isOK() );
         ASSERT( gte.matches( BSON( "a" << MinKey ), NULL ) );
         ASSERT( gte.matches( BSON( "a" << MaxKey ), NULL ) );
         ASSERT( gte.matches( BSON( "a" << 4 ), NULL ) );
@@ -655,8 +672,8 @@ namespace mongo {
 
     TEST( ComparisonMatchExpression, MatchesMaxKey ) {
         BSONObj operand = BSON( "a" << MaxKey );
-        ComparisonMatchExpression gte;
-        ASSERT( gte.init( "a", ComparisonMatchExpression::GTE, operand[ "a" ] ).isOK() );
+        GTEMatchExpression gte;
+        ASSERT( gte.init( "a", operand[ "a" ] ).isOK() );
         ASSERT( gte.matches( BSON( "a" << MaxKey ), NULL ) );
         ASSERT( !gte.matches( BSON( "a" << MinKey ), NULL ) );
         ASSERT( !gte.matches( BSON( "a" << 4 ), NULL ) );
@@ -664,8 +681,8 @@ namespace mongo {
 
     TEST( ComparisonMatchExpression, ElemMatchKey ) {
         BSONObj operand = BSON( "$gte" << 5 );
-        ComparisonMatchExpression gte;
-        ASSERT( gte.init( "a", ComparisonMatchExpression::GTE, operand[ "$gte" ] ).isOK() );
+        GTEMatchExpression gte;
+        ASSERT( gte.init( "a", operand[ "$gte" ] ).isOK() );
         MatchDetails details;
         details.requestElemMatchKey();
         ASSERT( !gte.matches( BSON( "a" << 4 ), &details ) );
@@ -732,30 +749,30 @@ namespace mongo {
         BSONObj operand = BSON( "$ne" << 5 );
         BSONObj match = BSON( "a" << 6 );
         BSONObj notMatch = BSON( "a" << 5 );
-        ComparisonMatchExpression ne;
-        ASSERT( ne.init( "", ComparisonMatchExpression::NE, operand[ "$ne" ] ).isOK() );
+        NEMatchExpression ne;
+        ASSERT( ne.init( "", operand[ "$ne" ] ).isOK() );
         ASSERT( ne.matchesSingleElement( match.firstElement() ) );
         ASSERT( !ne.matchesSingleElement( notMatch.firstElement() ) );
     }
 
     TEST( NeOp, InvalidEooOperand ) {
         BSONObj operand;
-        ComparisonMatchExpression ne;
-        ASSERT( !ne.init( "", ComparisonMatchExpression::NE, operand.firstElement() ).isOK() );
+        NEMatchExpression ne;
+        ASSERT( !ne.init( "", operand.firstElement() ).isOK() );
     }
 
     TEST( NeOp, MatchesScalar ) {
         BSONObj operand = BSON( "$ne" << 5 );
-        ComparisonMatchExpression ne;
-        ASSERT( ne.init( "a", ComparisonMatchExpression::NE, operand[ "$ne" ] ).isOK() );
+        NEMatchExpression ne;
+        ASSERT( ne.init( "a", operand[ "$ne" ] ).isOK() );
         ASSERT( ne.matches( BSON( "a" << 4 ), NULL ) );
         ASSERT( !ne.matches( BSON( "a" << 5 ), NULL ) );
     }
 
     TEST( NeOp, MatchesArrayValue ) {
         BSONObj operand = BSON( "$ne" << 5 );
-        ComparisonMatchExpression ne;
-        ASSERT( ne.init( "a", ComparisonMatchExpression::NE, operand[ "$ne" ] ).isOK() );
+        NEMatchExpression ne;
+        ASSERT( ne.init( "a", operand[ "$ne" ] ).isOK() );
         ASSERT( ne.matches( BSON( "a" << BSON_ARRAY( 4 << 6 ) ), NULL ) );
         ASSERT( !ne.matches( BSON( "a" << BSON_ARRAY( 4 << 5 ) ), NULL ) );
         ASSERT( !ne.matches( BSON( "a" << BSON_ARRAY( 5 << 5 ) ), NULL ) );
@@ -763,8 +780,8 @@ namespace mongo {
 
     TEST( NeOp, MatchesNull ) {
         BSONObj operand = BSON( "$ne" << BSONNULL );
-        ComparisonMatchExpression ne;
-        ASSERT( ne.init( "a", ComparisonMatchExpression::NE, operand[ "$ne" ] ).isOK() );
+        NEMatchExpression ne;
+        ASSERT( ne.init( "a", operand[ "$ne" ] ).isOK() );
         ASSERT( ne.matches( BSON( "a" << 4 ), NULL ) );
         ASSERT( !ne.matches( BSONObj(), NULL ) );
         ASSERT( !ne.matches( BSON( "a" << BSONNULL ), NULL ) );
@@ -772,8 +789,8 @@ namespace mongo {
 
     TEST( NeOp, ElemMatchKey ) {
         BSONObj operand = BSON( "$ne" << 5 );
-        ComparisonMatchExpression ne;
-        ASSERT( ne.init( "a", ComparisonMatchExpression::NE, operand[ "$ne" ] ).isOK() );
+        NEMatchExpression ne;
+        ASSERT( ne.init( "a", operand[ "$ne" ] ).isOK() );
         MatchDetails details;
         details.requestElemMatchKey();
         ASSERT( !ne.matches( BSON( "a" << BSON_ARRAY( 2 << 6 << 5 ) ), &details ) );
@@ -975,6 +992,22 @@ namespace mongo {
         ASSERT_EQUALS( "1", details.elemMatchKey() );
     }
 
+    TEST( RegexMatchExpression, Equality1 ) {
+        RegexMatchExpression r1;
+        RegexMatchExpression r2;
+        RegexMatchExpression r3;
+        RegexMatchExpression r4;
+        ASSERT( r1.init( "a" , "b" ,"" ).isOK() );
+        ASSERT( r2.init( "a" , "b" ,"x" ).isOK() );
+        ASSERT( r3.init( "a" , "c" ,"" ).isOK() );
+        ASSERT( r4.init( "b" , "b" ,"" ).isOK() );
+
+        ASSERT( r1.equivalent( &r1 ) );
+        ASSERT( !r1.equivalent( &r2 ) );
+        ASSERT( !r1.equivalent( &r3 ) );
+        ASSERT( !r1.equivalent( &r4 ) );
+    }
+
     /**
        TEST( RegexMatchExpression, MatchesIndexKeyScalar ) {
        RegexMatchExpression regex;
@@ -1068,6 +1101,24 @@ namespace mongo {
         ASSERT( details.hasElemMatchKey() );
         ASSERT_EQUALS( "1", details.elemMatchKey() );
     }
+
+    TEST( ModMatchExpression, Equality1 ) {
+        ModMatchExpression m1;
+        ModMatchExpression m2;
+        ModMatchExpression m3;
+        ModMatchExpression m4;
+
+        m1.init( "a" , 1 , 2 );
+        m2.init( "a" , 2 , 2 );
+        m3.init( "a" , 1 , 1 );
+        m4.init( "b" , 1 , 2 );
+
+        ASSERT( m1.equivalent( &m1 ) );
+        ASSERT( !m1.equivalent( &m2 ) );
+        ASSERT( !m1.equivalent( &m3 ) );
+        ASSERT( !m1.equivalent( &m4 ) );
+    }
+
     /**
        TEST( ModMatchExpression, MatchesIndexKey ) {
        BSONObj operand = BSON( "$mod" << BSON_ARRAY( 2 << 1 ) );
@@ -1150,6 +1201,20 @@ namespace mongo {
         ASSERT( details.hasElemMatchKey() );
         ASSERT_EQUALS( "1", details.elemMatchKey() );
     }
+
+    TEST( ExistsMatchExpression, Equivalent ) {
+        ExistsMatchExpression e1;
+        ExistsMatchExpression e2;
+        ExistsMatchExpression e3;
+        e1.init( "a" , false );
+        e2.init( "a" , true );
+        e3.init( "b" , false );
+
+        ASSERT( e1.equivalent( &e1 ) );
+        ASSERT( !e1.equivalent( &e2 ) );
+        ASSERT( !e1.equivalent( &e3 ) );
+    }
+
     /**
        TEST( ExistsMatchExpression, MatchesIndexKey ) {
        BSONObj operand = BSON( "$exists" << true );
@@ -1247,6 +1312,21 @@ namespace mongo {
         ASSERT( details.hasElemMatchKey() );
         ASSERT_EQUALS( "1", details.elemMatchKey() );
     }
+
+    TEST( TypeMatchExpression, Equivalent ) {
+        TypeMatchExpression e1;
+        TypeMatchExpression e2;
+        TypeMatchExpression e3;
+        e1.init( "a", String );
+        e2.init( "a", NumberDouble );
+        e3.init( "b", String );
+
+        ASSERT( e1.equivalent( &e1 ) );
+        ASSERT( !e1.equivalent( &e2 ) );
+        ASSERT( !e1.equivalent( &e3 ) );
+    }
+
+
     /**
        TEST( TypeMatchExpression, MatchesIndexKey ) {
        BSONObj operand = BSON( "$type" << 2 );
@@ -1551,6 +1631,31 @@ namespace mongo {
         ASSERT( !details.hasElemMatchKey() );
     }
 
+    TEST( NinMatchExpression, Equivalent ) {
+        BSONArray operand = BSON_ARRAY( 5 << 2 );
+
+        NinMatchExpression e1;
+        NinMatchExpression e2;
+        NinMatchExpression e3;
+
+        e1.init( "a" );
+        e2.init( "a" );
+        e3.init( "b" );
+
+        e1.getArrayFilterEntries()->addEquality( operand[0] );
+        e1.getArrayFilterEntries()->addEquality( operand[1] );
+
+        e2.getArrayFilterEntries()->addEquality( operand[0] );
+
+        e3.getArrayFilterEntries()->addEquality( operand[0] );
+        e3.getArrayFilterEntries()->addEquality( operand[1] );
+
+        ASSERT( e1.equivalent( &e1 ) );
+        ASSERT( !e1.equivalent( &e2 ) );
+        ASSERT( !e1.equivalent( &e3 ) );
+    }
+
+
     /**
     TEST( NinMatchExpression, MatchesIndexKey ) {
         BSONObj operand = BSON( "$nin" << BSON_ARRAY( 5 ) );
diff --git a/src/mongo/db/matcher/expression_parser.cpp b/src/mongo/db/matcher/expression_parser.cpp
index e444866d60b..f7de6dd6f5b 100644
--- a/src/mongo/db/matcher/expression_parser.cpp
+++ b/src/mongo/db/matcher/expression_parser.cpp
@@ -32,24 +32,29 @@
 namespace mongo {
 
     StatusWithMatchExpression MatchExpressionParser::_parseComparison( const char* name,
-                                                                ComparisonMatchExpression::Type cmp,
-                                                                const BSONElement& e ) {
-        std::auto_ptr<ComparisonMatchExpression> temp( new ComparisonMatchExpression() );
+                                                                       ComparisonMatchExpression* cmp,
+                                                                       const BSONElement& e ) {
+        std::auto_ptr<ComparisonMatchExpression> temp( cmp );
 
-        Status s = temp->init( name, cmp, e );
+        Status s = temp->init( name, e );
         if ( !s.isOK() )
             return StatusWithMatchExpression(s);
 
         return StatusWithMatchExpression( temp.release() );
     }
 
-    StatusWithMatchExpression MatchExpressionParser::_parseSubField( const char* name,
-                                                           const BSONElement& e ) {
+    StatusWithMatchExpression MatchExpressionParser::_parseSubField( const BSONObj& context,
+                                                                     const char* name,
+                                                                     const BSONElement& e,
+                                                                     int position,
+                                                                     bool* stop ) {
+
+        *stop = false;
 
         // TODO: these should move to getGtLtOp, or its replacement
 
         if ( mongoutils::str::equals( "$eq", e.fieldName() ) )
-            return _parseComparison( name, ComparisonMatchExpression::EQ, e );
+            return _parseComparison( name, new EqualityMatchExpression(), e );
 
         if ( mongoutils::str::equals( "$not", e.fieldName() ) ) {
             return _parseNot( name, e );
@@ -63,17 +68,17 @@ namespace mongo {
                                          mongoutils::str::stream() << "unknown operator: "
                                          << e.fieldName() );
         case BSONObj::LT:
-            return _parseComparison( name, ComparisonMatchExpression::LT, e );
+            return _parseComparison( name, new LTMatchExpression(), e );
         case BSONObj::LTE:
-            return _parseComparison( name, ComparisonMatchExpression::LTE, e );
+            return _parseComparison( name, new LTEMatchExpression(), e );
         case BSONObj::GT:
-            return _parseComparison( name, ComparisonMatchExpression::GT, e );
+            return _parseComparison( name, new GTMatchExpression(), e );
         case BSONObj::GTE:
-            return _parseComparison( name, ComparisonMatchExpression::GTE, e );
+            return _parseComparison( name, new GTEMatchExpression(), e );
         case BSONObj::NE:
-            return _parseComparison( name, ComparisonMatchExpression::NE, e );
+            return _parseComparison( name, new NEMatchExpression(), e );
         case BSONObj::Equality:
-            return _parseComparison( name, ComparisonMatchExpression::EQ, e );
+            return _parseComparison( name, new EqualityMatchExpression(), e );
 
         case BSONObj::opIN: {
             if ( e.type() != Array )
@@ -157,19 +162,30 @@ namespace mongo {
         case BSONObj::opOPTIONS:
             return StatusWithMatchExpression( ErrorCodes::BadValue, "$options has to be after a $regex" );
 
+        case BSONObj::opREGEX: {
+            if ( position != 0 )
+                return StatusWithMatchExpression( ErrorCodes::BadValue, "$regex has to be first" );
+
+            *stop = true;
+            return _parseRegexDocument( name, context );
+        }
+
         case BSONObj::opELEM_MATCH:
             return _parseElemMatch( name, e );
 
         case BSONObj::opALL:
             return _parseAll( name, e );
 
+        case BSONObj::opWITHIN:
+            return expressionParserGeoCallback( name, context );
+
         default:
             return StatusWithMatchExpression( ErrorCodes::BadValue, "not done" );
         }
 
     }
 
-    StatusWithMatchExpression MatchExpressionParser::parse( const BSONObj& obj ) {
+    StatusWithMatchExpression MatchExpressionParser::_parse( const BSONObj& obj, bool topLevel ) {
 
         std::auto_ptr<AndMatchExpression> root( new AndMatchExpression() );
 
@@ -211,10 +227,26 @@ namespace mongo {
                         return StatusWithMatchExpression( s );
                     root->add( temp.release() );
                 }
+                else if ( mongoutils::str::equals( "atomic", rest ) ) {
+                    if ( !topLevel )
+                        return StatusWithMatchExpression( ErrorCodes::BadValue,
+                                                          "$atomic has to be at the top level" );
+                    if ( e.trueValue() )
+                        root->add( new AtomicMatchExpression() );
+                }
+                else if ( mongoutils::str::equals( "where", rest ) ) {
+                    if ( !topLevel )
+                        return StatusWithMatchExpression( ErrorCodes::BadValue,
+                                                          "$within has to be at the top level" );
+                    StatusWithMatchExpression s = expressionParserWhereCallback( e );
+                    if ( !s.isOK() )
+                        return s;
+                    root->add( s.getValue() );
+                }
                 else {
                     return StatusWithMatchExpression( ErrorCodes::BadValue,
                                                  mongoutils::str::stream()
-                                                 << "unkown operator: "
+                                                 << "unknown top level operator: "
                                                  << e.fieldName() );
                 }
 
@@ -236,8 +268,8 @@ namespace mongo {
                 continue;
             }
 
-            std::auto_ptr<ComparisonMatchExpression> eq( new ComparisonMatchExpression() );
-            Status s = eq->init( e.fieldName(), ComparisonMatchExpression::EQ, e );
+            std::auto_ptr<ComparisonMatchExpression> eq( new EqualityMatchExpression() );
+            Status s = eq->init( e.fieldName(), e );
             if ( !s.isOK() )
                 return StatusWithMatchExpression( s );
 
@@ -251,31 +283,24 @@ namespace mongo {
                                         const BSONObj& sub,
                                         AndMatchExpression* root ) {
 
-        bool first = true;
+        int position = 0;
 
         BSONObjIterator j( sub );
         while ( j.more() ) {
             BSONElement deep = j.next();
 
-            int op = deep.getGtLtOp();
-            if ( op == BSONObj::opREGEX ) {
-                if ( !first )
-                    return Status( ErrorCodes::BadValue, "$regex has to be first" );
-
-                StatusWithMatchExpression s = _parseRegexDocument( name, sub );
-                if ( !s.isOK() )
-                    return s.getStatus();
-                root->add( s.getValue() );
-                return Status::OK();
-            }
-
-            StatusWithMatchExpression s = _parseSubField( name, deep );
+            bool stop = false;
+            StatusWithMatchExpression s = _parseSubField( sub, name, deep, position, &stop );
             if ( !s.isOK() )
                 return s.getStatus();
 
             root->add( s.getValue() );
-            first = false;
+
+            if ( stop )
+                break;
+            position++;
         }
+
         return Status::OK();
     }
 
@@ -406,8 +431,8 @@ namespace mongo {
             if ( !s.isOK() )
                 return StatusWithMatchExpression( s );
 
-            for ( size_t i = 0; i < theAnd.size(); i++ ) {
-                temp->add( theAnd.get( i ) );
+            for ( size_t i = 0; i < theAnd.numChildren(); i++ ) {
+                temp->add( theAnd.getChild( i ) );
             }
             theAnd.clearAndRelease();
 
@@ -416,7 +441,7 @@ namespace mongo {
 
         // object case
 
-        StatusWithMatchExpression sub = parse( obj );
+        StatusWithMatchExpression sub = _parse( obj, false );
         if ( !sub.isOK() )
             return sub;
 
@@ -483,5 +508,18 @@ namespace mongo {
         return StatusWithMatchExpression( temp.release() );
     }
 
+    StatusWithMatchExpression expressionParserGeoCallbackDefault( const char* name,
+                                                                  const BSONObj& section ) {
+        return StatusWithMatchExpression( ErrorCodes::BadValue, "geo not linked in" );
+    }
+
+    MatchExpressionParserGeoCallback expressionParserGeoCallback = expressionParserGeoCallbackDefault;
+
+    StatusWithMatchExpression expressionParserWhereCallbackDefault(const BSONElement& where) {
+        return StatusWithMatchExpression( ErrorCodes::BadValue, "$where not linked in" );
+    }
+
+    MatchExpressionParserWhereCallback expressionParserWhereCallback = expressionParserWhereCallbackDefault;
+
 
 }
diff --git a/src/mongo/db/matcher/expression_parser.h b/src/mongo/db/matcher/expression_parser.h
index b062387102e..b387af9f36e 100644
--- a/src/mongo/db/matcher/expression_parser.h
+++ b/src/mongo/db/matcher/expression_parser.h
@@ -18,6 +18,8 @@
 
 #pragma once
 
+#include <boost/function.hpp>
+
 #include "mongo/base/status.h"
 #include "mongo/base/status_with.h"
 #include "mongo/db/matcher/expression.h"
@@ -30,9 +32,12 @@ namespace mongo {
 
     class MatchExpressionParser {
     public:
-        static StatusWithMatchExpression parse( const BSONObj& obj );
+        static StatusWithMatchExpression parse( const BSONObj& obj ) {
+            return _parse( obj, true );
+        }
 
     private:
+        static StatusWithMatchExpression _parse( const BSONObj& obj, bool topLevel );
 
         /**
          * parses a field in a sub expression
@@ -48,12 +53,15 @@ namespace mongo {
          * if the query is { x : { $gt : 5, $lt : 8 } }
          * e is $gt : 5
          */
-        static StatusWithMatchExpression _parseSubField( const char* name,
-                                                    const BSONElement& e );
+        static StatusWithMatchExpression _parseSubField( const BSONObj& context,
+                                                         const char* name,
+                                                         const BSONElement& e,
+                                                         int position,
+                                                         bool* stop );
 
         static StatusWithMatchExpression _parseComparison( const char* name,
-                                                      ComparisonMatchExpression::Type cmp,
-                                                      const BSONElement& e );
+                                                           ComparisonMatchExpression* cmp,
+                                                           const BSONElement& e );
 
         static StatusWithMatchExpression _parseMOD( const char* name,
                                                const BSONElement& e );
@@ -84,4 +92,10 @@ namespace mongo {
 
     };
 
+    typedef boost::function<StatusWithMatchExpression(const char* name, const BSONObj& section)> MatchExpressionParserGeoCallback;
+    extern MatchExpressionParserGeoCallback expressionParserGeoCallback;
+
+    typedef boost::function<StatusWithMatchExpression(const BSONElement& where)> MatchExpressionParserWhereCallback;
+    extern MatchExpressionParserWhereCallback expressionParserWhereCallback;
+
 }
diff --git a/src/mongo/db/matcher/expression_parser_geo.cpp b/src/mongo/db/matcher/expression_parser_geo.cpp
new file mode 100644
index 00000000000..cbb41731deb
--- /dev/null
+++ b/src/mongo/db/matcher/expression_parser_geo.cpp
@@ -0,0 +1,47 @@
+// expression_parser_geo.cpp
+
+/**
+ *    Copyright (C) 2013 10gen Inc.
+ *
+ *    This program is free software: you can redistribute it and/or  modify
+ *    it under the terms of the GNU Affero General Public License, version 3,
+ *    as published by the Free Software Foundation.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Affero General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Affero General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "mongo/db/matcher/expression_parser.h"
+
+#include "mongo/base/init.h"
+#include "mongo/db/jsobj.h"
+#include "mongo/db/matcher/expression_geo.h"
+#include "mongo/util/log.h"
+#include "mongo/util/mongoutils/str.h"
+
+namespace mongo {
+
+    StatusWithMatchExpression expressionParserGeoCallbackReal( const char* name,
+                                                                  const BSONObj& section ) {
+        GeoQuery gq;
+        if ( !gq.parseFrom( section ) )
+            return StatusWithMatchExpression( ErrorCodes::BadValue, "bad geo query" );
+
+        auto_ptr<GeoMatchExpression> e( new GeoMatchExpression() );
+        Status s = e->init( name, gq );
+        if ( !s.isOK() )
+            return StatusWithMatchExpression( s );
+        return StatusWithMatchExpression( e.release() );
+    }
+
+    MONGO_INITIALIZER( MatchExpressionParserGeo )( ::mongo::InitializerContext* context ) {
+        expressionParserGeoCallback = expressionParserGeoCallbackReal;
+        return Status::OK();
+    }
+
+}
diff --git a/src/mongo/db/matcher/expression_parser_geo_test.cpp b/src/mongo/db/matcher/expression_parser_geo_test.cpp
new file mode 100644
index 00000000000..d8cf7734c17
--- /dev/null
+++ b/src/mongo/db/matcher/expression_parser_geo_test.cpp
@@ -0,0 +1,43 @@
+// expression_parser_geo_test.cpp
+
+/**
+ *    Copyright (C) 2013 10gen Inc.
+ *
+ *    This program is free software: you can redistribute it and/or  modify
+ *    it under the terms of the GNU Affero General Public License, version 3,
+ *    as published by the Free Software Foundation.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Affero General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Affero General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "mongo/unittest/unittest.h"
+
+#include "mongo/db/matcher/expression_parser.h"
+
+#include "mongo/db/jsobj.h"
+#include "mongo/db/json.h"
+#include "mongo/db/matcher/expression.h"
+#include "mongo/db/matcher/expression_geo.h"
+
+namespace mongo {
+
+    TEST( MatchExpressionParserGeo, WithinBox ) {
+        BSONObj query = fromjson("{a:{$within:{$box:[{x: 4, y:4},[6,6]]}}}");
+
+        StatusWithMatchExpression result = MatchExpressionParser::parse( query );
+        ASSERT_TRUE( result.isOK() );
+
+        ASSERT(!result.getValue()->matches(fromjson("{a: [3,4]}")));
+        ASSERT(result.getValue()->matches(fromjson("{a: [4,4]}")));
+        ASSERT(result.getValue()->matches(fromjson("{a: [5,5]}")));
+        ASSERT(result.getValue()->matches(fromjson("{a: [5,5.1]}")));
+        ASSERT(result.getValue()->matches(fromjson("{a: {x: 5, y:5.1}}")));
+
+    }
+}
diff --git a/src/mongo/db/matcher/expression_parser_test.cpp b/src/mongo/db/matcher/expression_parser_test.cpp
index f7ee08f3da0..12d9ce553c2 100644
--- a/src/mongo/db/matcher/expression_parser_test.cpp
+++ b/src/mongo/db/matcher/expression_parser_test.cpp
@@ -48,6 +48,12 @@ namespace mongo {
         ASSERT( !result.getValue()->matches( BSON( "x" << 5 << "y" << 4 ) ) );
     }
 
+    TEST( AtomicMatchExpressionTest, Simple1 ) {
+        BSONObj query = BSON( "x" << 5 << "$atomic" << BSON( "$gt" << 5 << "$lt" << 8 ) );
+        StatusWithMatchExpression result = MatchExpressionParser::parse( query );
+        ASSERT_TRUE( result.isOK() );
+    }
+
     StatusWith<int> fib( int n ) {
         if ( n < 0 ) return StatusWith<int>( ErrorCodes::BadValue, "paramter to fib has to be >= 0" );
         if ( n <= 1 ) return StatusWith<int>( 1 );
diff --git a/src/mongo/db/matcher/expression_parser_tree.cpp b/src/mongo/db/matcher/expression_parser_tree.cpp
index d510ecaae1a..e2aa3f1780e 100644
--- a/src/mongo/db/matcher/expression_parser_tree.cpp
+++ b/src/mongo/db/matcher/expression_parser_tree.cpp
@@ -39,7 +39,7 @@ namespace mongo {
                 return Status( ErrorCodes::BadValue,
                                "$or/$and/$nor entries need to be full objects" );
 
-            StatusWithMatchExpression sub = parse( e.Obj() );
+            StatusWithMatchExpression sub = _parse( e.Obj(), false );
             if ( !sub.isOK() )
                 return sub.getStatus();
 
diff --git a/src/mongo/db/matcher/expression_test.cpp b/src/mongo/db/matcher/expression_test.cpp
index 93c1d20af2a..81ab018fbfb 100644
--- a/src/mongo/db/matcher/expression_test.cpp
+++ b/src/mongo/db/matcher/expression_test.cpp
@@ -35,8 +35,8 @@ namespace mongo {
 
     TEST( LeafMatchExpressionTest, Equal1 ) {
         BSONObj temp = BSON( "x" << 5 );
-        ComparisonMatchExpression e;
-        e.init( "x", ComparisonMatchExpression::EQ, temp["x"] );
+        EqualityMatchExpression e;
+        e.init( "x", temp["x"] );
 
         ASSERT_TRUE( e.matches( fromjson( "{ x : 5 }" ) ) );
         ASSERT_TRUE( e.matches( fromjson( "{ x : [5] }" ) ) );
@@ -54,8 +54,8 @@ namespace mongo {
         BSONObj temp = BSON( "x" << 5 );
 
         {
-            ComparisonMatchExpression e;
-            e.init( "x", ComparisonMatchExpression::LTE, temp["x"] );
+            LTEMatchExpression e;
+            e.init( "x", temp["x"] );
             ASSERT_TRUE( e.matches( fromjson( "{ x : 5 }" ) ) );
             ASSERT_TRUE( e.matches( fromjson( "{ x : 4 }" ) ) );
             ASSERT_FALSE( e.matches( fromjson( "{ x : 6 }" ) ) );
@@ -63,8 +63,8 @@ namespace mongo {
         }
 
         {
-            ComparisonMatchExpression e;
-            e.init( "x", ComparisonMatchExpression::LT, temp["x"] );
+            LTMatchExpression e;
+            e.init( "x", temp["x"] );
             ASSERT_FALSE( e.matches( fromjson( "{ x : 5 }" ) ) );
             ASSERT_TRUE( e.matches( fromjson( "{ x : 4 }" ) ) );
             ASSERT_FALSE( e.matches( fromjson( "{ x : 6 }" ) ) );
@@ -72,8 +72,8 @@ namespace mongo {
         }
 
         {
-            ComparisonMatchExpression e;
-            e.init( "x", ComparisonMatchExpression::GTE, temp["x"] );
+            GTEMatchExpression e;
+            e.init( "x", temp["x"] );
             ASSERT_TRUE( e.matches( fromjson( "{ x : 5 }" ) ) );
             ASSERT_FALSE( e.matches( fromjson( "{ x : 4 }" ) ) );
             ASSERT_TRUE( e.matches( fromjson( "{ x : 6 }" ) ) );
@@ -81,8 +81,8 @@ namespace mongo {
         }
 
         {
-            ComparisonMatchExpression e;
-            e.init( "x", ComparisonMatchExpression::GT, temp["x"] );
+            GTMatchExpression e;
+            e.init( "x", temp["x"] );
             ASSERT_FALSE( e.matches( fromjson( "{ x : 5 }" ) ) );
             ASSERT_FALSE( e.matches( fromjson( "{ x : 4 }" ) ) );
             ASSERT_TRUE( e.matches( fromjson( "{ x : 6 }" ) ) );
diff --git a/src/mongo/db/matcher/expression_tree.cpp b/src/mongo/db/matcher/expression_tree.cpp
index 840a4fdd96c..94d54ec07ab 100644
--- a/src/mongo/db/matcher/expression_tree.cpp
+++ b/src/mongo/db/matcher/expression_tree.cpp
@@ -42,11 +42,28 @@ namespace mongo {
             _expressions[i]->debugString( debug, level + 1 );
     }
 
+    bool ListOfMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        const ListOfMatchExpression* realOther = static_cast<const ListOfMatchExpression*>( other );
+
+        if ( _expressions.size() != realOther->_expressions.size() )
+            return false;
+
+        // TOOD: order doesn't matter
+        for ( unsigned i = 0; i < _expressions.size(); i++ )
+            if ( !_expressions[i]->equivalent( realOther->_expressions[i] ) )
+                return false;
+
+        return true;
+    }
+
     // -----
 
     bool AndMatchExpression::matches( const BSONObj& doc, MatchDetails* details ) const {
-        for ( size_t i = 0; i < size(); i++ ) {
-            if ( !get(i)->matches( doc, details ) ) {
+        for ( size_t i = 0; i < numChildren(); i++ ) {
+            if ( !getChild(i)->matches( doc, details ) ) {
                 if ( details )
                     details->resetOutput();
                 return false;
@@ -56,8 +73,8 @@ namespace mongo {
     }
 
     bool AndMatchExpression::matchesSingleElement( const BSONElement& e ) const {
-        for ( size_t i = 0; i < size(); i++ ) {
-            if ( !get(i)->matchesSingleElement( e ) ) {
+        for ( size_t i = 0; i < numChildren(); i++ ) {
+            if ( !getChild(i)->matchesSingleElement( e ) ) {
                 return false;
             }
         }
@@ -74,8 +91,8 @@ namespace mongo {
     // -----
 
     bool OrMatchExpression::matches( const BSONObj& doc, MatchDetails* details ) const {
-        for ( size_t i = 0; i < size(); i++ ) {
-            if ( get(i)->matches( doc, NULL ) ) {
+        for ( size_t i = 0; i < numChildren(); i++ ) {
+            if ( getChild(i)->matches( doc, NULL ) ) {
                 return true;
             }
         }
@@ -83,8 +100,8 @@ namespace mongo {
     }
 
     bool OrMatchExpression::matchesSingleElement( const BSONElement& e ) const {
-        for ( size_t i = 0; i < size(); i++ ) {
-            if ( get(i)->matchesSingleElement( e ) ) {
+        for ( size_t i = 0; i < numChildren(); i++ ) {
+            if ( getChild(i)->matchesSingleElement( e ) ) {
                 return true;
             }
         }
@@ -101,8 +118,8 @@ namespace mongo {
     // ----
 
     bool NorMatchExpression::matches( const BSONObj& doc, MatchDetails* details ) const {
-        for ( size_t i = 0; i < size(); i++ ) {
-            if ( get(i)->matches( doc, NULL ) ) {
+        for ( size_t i = 0; i < numChildren(); i++ ) {
+            if ( getChild(i)->matches( doc, NULL ) ) {
                 return false;
             }
         }
@@ -110,8 +127,8 @@ namespace mongo {
     }
 
     bool NorMatchExpression::matchesSingleElement( const BSONElement& e ) const {
-        for ( size_t i = 0; i < size(); i++ ) {
-            if ( get(i)->matchesSingleElement( e ) ) {
+        for ( size_t i = 0; i < numChildren(); i++ ) {
+            if ( getChild(i)->matchesSingleElement( e ) ) {
                 return false;
             }
         }
@@ -132,4 +149,11 @@ namespace mongo {
         _exp->debugString( debug, level + 1 );
     }
 
+    bool NotMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+
+        return _exp->equivalent( other->getChild(0) );
+    }
+
 }
diff --git a/src/mongo/db/matcher/expression_tree.h b/src/mongo/db/matcher/expression_tree.h
index 8dd6885d26c..8c826f78769 100644
--- a/src/mongo/db/matcher/expression_tree.h
+++ b/src/mongo/db/matcher/expression_tree.h
@@ -30,6 +30,7 @@ namespace mongo {
 
     class ListOfMatchExpression : public MatchExpression {
     public:
+        ListOfMatchExpression( MatchType type ) : MatchExpression( TREE, type ){}
         virtual ~ListOfMatchExpression();
 
         /**
@@ -43,8 +44,10 @@ namespace mongo {
          */
         void clearAndRelease() { _expressions.clear(); }
 
-        size_t size() const { return _expressions.size(); }
-        MatchExpression* get( size_t i ) const { return _expressions[i]; }
+        virtual size_t numChildren() const { return _expressions.size(); }
+        virtual const MatchExpression* getChild( size_t i ) const { return _expressions[i]; }
+
+        bool equivalent( const MatchExpression* other ) const;
 
     protected:
         void _debugList( StringBuilder& debug, int level ) const;
@@ -55,6 +58,7 @@ namespace mongo {
 
     class AndMatchExpression : public ListOfMatchExpression {
     public:
+        AndMatchExpression() : ListOfMatchExpression( AND ){}
         virtual ~AndMatchExpression(){}
 
         virtual bool matches( const BSONObj& doc, MatchDetails* details = 0 ) const;
@@ -65,6 +69,7 @@ namespace mongo {
 
     class OrMatchExpression : public ListOfMatchExpression {
     public:
+        OrMatchExpression() : ListOfMatchExpression( OR ){}
         virtual ~OrMatchExpression(){}
 
         virtual bool matches( const BSONObj& doc, MatchDetails* details = 0 ) const;
@@ -75,6 +80,7 @@ namespace mongo {
 
     class NorMatchExpression : public ListOfMatchExpression {
     public:
+        NorMatchExpression() : ListOfMatchExpression( NOR ){}
         virtual ~NorMatchExpression(){}
 
         virtual bool matches( const BSONObj& doc, MatchDetails* details = 0 ) const;
@@ -85,6 +91,7 @@ namespace mongo {
 
     class NotMatchExpression : public MatchExpression {
     public:
+        NotMatchExpression() : MatchExpression( TREE, NOT ){}
         /**
          * @param exp - I own it, and will delete
          */
@@ -102,6 +109,13 @@ namespace mongo {
         }
 
         virtual void debugString( StringBuilder& debug, int level = 0 ) const;
+
+        bool equivalent( const MatchExpression* other ) const;
+
+        virtual size_t numChildren() const { return 1; }
+        virtual MatchExpression* getChild( size_t i ) const { return _exp.get(); }
+
+
     private:
         boost::scoped_ptr<MatchExpression> _exp;
     };
diff --git a/src/mongo/db/matcher/expression_tree_test.cpp b/src/mongo/db/matcher/expression_tree_test.cpp
index a02d423c621..e2032da14fd 100644
--- a/src/mongo/db/matcher/expression_tree_test.cpp
+++ b/src/mongo/db/matcher/expression_tree_test.cpp
@@ -28,8 +28,8 @@ namespace mongo {
 
     TEST( NotMatchExpression, MatchesScalar ) {
         BSONObj baseOperand = BSON( "$lt" << 5 );
-        auto_ptr<ComparisonMatchExpression> lt( new ComparisonMatchExpression() );
-        ASSERT( lt->init( "a", ComparisonMatchExpression::LT, baseOperand[ "$lt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> lt( new LTMatchExpression() );
+        ASSERT( lt->init( "a", baseOperand[ "$lt" ] ).isOK() );
         NotMatchExpression notOp;
         ASSERT( notOp.init( lt.release() ).isOK() );
         ASSERT( notOp.matches( BSON( "a" << 6 ), NULL ) );
@@ -38,8 +38,8 @@ namespace mongo {
 
     TEST( NotMatchExpression, MatchesArray ) {
         BSONObj baseOperand = BSON( "$lt" << 5 );
-        auto_ptr<ComparisonMatchExpression> lt( new ComparisonMatchExpression() );
-        ASSERT( lt->init( "a", ComparisonMatchExpression::LT, baseOperand[ "$lt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> lt( new LTMatchExpression() );
+        ASSERT( lt->init( "a", baseOperand[ "$lt" ] ).isOK() );
         NotMatchExpression notOp;
         ASSERT( notOp.init( lt.release() ).isOK() );
         ASSERT( notOp.matches( BSON( "a" << BSON_ARRAY( 6 ) ), NULL ) );
@@ -50,8 +50,8 @@ namespace mongo {
 
     TEST( NotMatchExpression, ElemMatchKey ) {
         BSONObj baseOperand = BSON( "$lt" << 5 );
-        auto_ptr<ComparisonMatchExpression> lt( new ComparisonMatchExpression() );
-        ASSERT( lt->init( "a", ComparisonMatchExpression::LT, baseOperand[ "$lt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> lt( new LTMatchExpression() );
+        ASSERT( lt->init( "a", baseOperand[ "$lt" ] ).isOK() );
         NotMatchExpression notOp;
         ASSERT( notOp.init( lt.release() ).isOK() );
         MatchDetails details;
@@ -107,10 +107,10 @@ namespace mongo {
         BSONObj notMatch2 = BSON( "a" << "a1" );
         BSONObj notMatch3 = BSON( "a" << "r" );
 
-        auto_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() );
-        ASSERT( sub1->init( "a", ComparisonMatchExpression::LT, baseOperand1[ "$lt" ] ).isOK() );
-        auto_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() );
-        ASSERT( sub2->init( "a", ComparisonMatchExpression::GT, baseOperand2[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub1( new LTMatchExpression() );
+        ASSERT( sub1->init( "a", baseOperand1[ "$lt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub2( new GTMatchExpression() );
+        ASSERT( sub2->init( "a", baseOperand2[ "$gt" ] ).isOK() );
         auto_ptr<RegexMatchExpression> sub3( new RegexMatchExpression() );
         ASSERT( sub3->init( "a", "1", "" ).isOK() );
 
@@ -127,8 +127,8 @@ namespace mongo {
 
     TEST( AndOp, MatchesSingleClause ) {
         BSONObj baseOperand = BSON( "$ne" << 5 );
-        auto_ptr<ComparisonMatchExpression> ne( new ComparisonMatchExpression() );
-        ASSERT( ne->init( "a", ComparisonMatchExpression::NE, baseOperand[ "$ne" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> ne( new NEMatchExpression() );
+        ASSERT( ne->init( "a", baseOperand[ "$ne" ] ).isOK() );
 
         AndMatchExpression andOp;
         andOp.add( ne.release() );
@@ -144,14 +144,14 @@ namespace mongo {
         BSONObj baseOperand2 = BSON( "$lt" << 10 );
         BSONObj baseOperand3 = BSON( "$lt" << 100 );
 
-        auto_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() );
-        ASSERT( sub1->init( "a", ComparisonMatchExpression::GT, baseOperand1[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub1( new GTMatchExpression() );
+        ASSERT( sub1->init( "a", baseOperand1[ "$gt" ] ).isOK() );
 
-        auto_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() );
-        ASSERT( sub2->init( "a", ComparisonMatchExpression::LT, baseOperand2[ "$lt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub2( new LTMatchExpression() );
+        ASSERT( sub2->init( "a", baseOperand2[ "$lt" ] ).isOK() );
 
-        auto_ptr<ComparisonMatchExpression> sub3( new ComparisonMatchExpression() );
-        ASSERT( sub3->init( "b", ComparisonMatchExpression::LT, baseOperand3[ "$lt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub3( new LTMatchExpression() );
+        ASSERT( sub3->init( "b", baseOperand3[ "$lt" ] ).isOK() );
 
         AndMatchExpression andOp;
         andOp.add( sub1.release() );
@@ -169,11 +169,11 @@ namespace mongo {
         BSONObj baseOperand1 = BSON( "a" << 1 );
         BSONObj baseOperand2 = BSON( "b" << 2 );
 
-        auto_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() );
-        ASSERT( sub1->init( "a", ComparisonMatchExpression::EQ, baseOperand1[ "a" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub1( new EqualityMatchExpression() );
+        ASSERT( sub1->init( "a", baseOperand1[ "a" ] ).isOK() );
 
-        auto_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() );
-        ASSERT( sub2->init( "b", ComparisonMatchExpression::EQ, baseOperand2[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub2( new EqualityMatchExpression() );
+        ASSERT( sub2->init( "b", baseOperand2[ "b" ] ).isOK() );
 
         AndMatchExpression andOp;
         andOp.add( sub1.release() );
@@ -290,8 +290,8 @@ namespace mongo {
     */
     TEST( OrOp, MatchesSingleClause ) {
         BSONObj baseOperand = BSON( "$ne" << 5 );
-        auto_ptr<ComparisonMatchExpression> ne( new ComparisonMatchExpression() );
-        ASSERT( ne->init( "a", ComparisonMatchExpression::NE, baseOperand[ "$ne" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> ne( new NEMatchExpression() );
+        ASSERT( ne->init( "a", baseOperand[ "$ne" ] ).isOK() );
 
         OrMatchExpression orOp;
         orOp.add( ne.release() );
@@ -306,12 +306,12 @@ namespace mongo {
         BSONObj baseOperand1 = BSON( "$gt" << 10 );
         BSONObj baseOperand2 = BSON( "$lt" << 0 );
         BSONObj baseOperand3 = BSON( "b" << 100 );
-        auto_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() );
-        ASSERT( sub1->init( "a", ComparisonMatchExpression::GT, baseOperand1[ "$gt" ] ).isOK() );
-        auto_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() );
-        ASSERT( sub2->init( "a", ComparisonMatchExpression::LT, baseOperand2[ "$lt" ] ).isOK() );
-        auto_ptr<ComparisonMatchExpression> sub3( new ComparisonMatchExpression() );
-        ASSERT( sub3->init( "b", ComparisonMatchExpression::EQ, baseOperand3[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub1( new GTMatchExpression() );
+        ASSERT( sub1->init( "a", baseOperand1[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub2( new LTMatchExpression() );
+        ASSERT( sub2->init( "a", baseOperand2[ "$lt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub3( new EqualityMatchExpression() );
+        ASSERT( sub3->init( "b", baseOperand3[ "b" ] ).isOK() );
 
         OrMatchExpression orOp;
         orOp.add( sub1.release() );
@@ -330,10 +330,10 @@ namespace mongo {
     TEST( OrOp, ElemMatchKey ) {
         BSONObj baseOperand1 = BSON( "a" << 1 );
         BSONObj baseOperand2 = BSON( "b" << 2 );
-        auto_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() );
-        ASSERT( sub1->init( "a", ComparisonMatchExpression::EQ, baseOperand1[ "a" ] ).isOK() );
-        auto_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() );
-        ASSERT( sub2->init( "b", ComparisonMatchExpression::EQ, baseOperand2[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub1( new EqualityMatchExpression() );
+        ASSERT( sub1->init( "a", baseOperand1[ "a" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub2( new EqualityMatchExpression() );
+        ASSERT( sub2->init( "b", baseOperand2[ "b" ] ).isOK() );
 
         OrMatchExpression orOp;
         orOp.add( sub1.release() );
@@ -451,8 +451,8 @@ namespace mongo {
 
     TEST( NorOp, MatchesSingleClause ) {
         BSONObj baseOperand = BSON( "$ne" << 5 );
-        auto_ptr<ComparisonMatchExpression> ne( new ComparisonMatchExpression() );
-        ASSERT( ne->init( "a", ComparisonMatchExpression::NE, baseOperand[ "$ne" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> ne( new NEMatchExpression() );
+        ASSERT( ne->init( "a", baseOperand[ "$ne" ] ).isOK() );
 
         NorMatchExpression norOp;
         norOp.add( ne.release() );
@@ -468,12 +468,12 @@ namespace mongo {
         BSONObj baseOperand2 = BSON( "$lt" << 0 );
         BSONObj baseOperand3 = BSON( "b" << 100 );
 
-        auto_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() );
-        ASSERT( sub1->init( "a", ComparisonMatchExpression::GT, baseOperand1[ "$gt" ] ).isOK() );
-        auto_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() );
-        ASSERT( sub2->init( "a", ComparisonMatchExpression::LT, baseOperand2[ "$lt" ] ).isOK() );
-        auto_ptr<ComparisonMatchExpression> sub3( new ComparisonMatchExpression() );
-        ASSERT( sub3->init( "b", ComparisonMatchExpression::EQ, baseOperand3[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub1( new GTMatchExpression() );
+        ASSERT( sub1->init( "a", baseOperand1[ "$gt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub2( new LTMatchExpression() );
+        ASSERT( sub2->init( "a", baseOperand2[ "$lt" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub3( new EqualityMatchExpression() );
+        ASSERT( sub3->init( "b", baseOperand3[ "b" ] ).isOK() );
 
         NorMatchExpression norOp;
         norOp.add( sub1.release() );
@@ -492,10 +492,10 @@ namespace mongo {
     TEST( NorOp, ElemMatchKey ) {
         BSONObj baseOperand1 = BSON( "a" << 1 );
         BSONObj baseOperand2 = BSON( "b" << 2 );
-        auto_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() );
-        ASSERT( sub1->init( "a", ComparisonMatchExpression::EQ, baseOperand1[ "a" ] ).isOK() );
-        auto_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() );
-        ASSERT( sub2->init( "b", ComparisonMatchExpression::EQ, baseOperand2[ "b" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub1( new EqualityMatchExpression() );
+        ASSERT( sub1->init( "a", baseOperand1[ "a" ] ).isOK() );
+        auto_ptr<ComparisonMatchExpression> sub2( new EqualityMatchExpression() );
+        ASSERT( sub2->init( "b", baseOperand2[ "b" ] ).isOK() );
 
         NorMatchExpression norOp;
         norOp.add( sub1.release() );
@@ -514,6 +514,26 @@ namespace mongo {
         ASSERT( !details.hasElemMatchKey() );
     }
 
+
+    TEST( NorOp, Equivalent ) {
+        BSONObj baseOperand1 = BSON( "a" << 1 );
+        BSONObj baseOperand2 = BSON( "b" << 2 );
+        EqualityMatchExpression sub1;
+        ASSERT( sub1.init( "a", baseOperand1[ "a" ] ).isOK() );
+        EqualityMatchExpression sub2;
+        ASSERT( sub2.init( "b", baseOperand2[ "b" ] ).isOK() );
+
+        NorMatchExpression e1;
+        e1.add( sub1.shallowClone() );
+        e1.add( sub2.shallowClone() );
+
+        NorMatchExpression e2;
+        e2.add( sub1.shallowClone() );
+
+        ASSERT( e1.equivalent( &e1 ) );
+        ASSERT( !e1.equivalent( &e2 ) );
+    }
+
     /**
     TEST( NorOp, MatchesIndexKey ) {
         BSONObj baseOperand = BSON( "a" << 5 );
diff --git a/src/mongo/db/matcher/expression_where.cpp b/src/mongo/db/matcher/expression_where.cpp
new file mode 100644
index 00000000000..1bfc74107af
--- /dev/null
+++ b/src/mongo/db/matcher/expression_where.cpp
@@ -0,0 +1,172 @@
+// expression_where.cpp
+
+/**
+ *    Copyright (C) 2013 10gen Inc.
+ *
+ *    This program is free software: you can redistribute it and/or  modify
+ *    it under the terms of the GNU Affero General Public License, version 3,
+ *    as published by the Free Software Foundation.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Affero General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Affero General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "mongo/pch.h"
+#include "mongo/base/init.h"
+#include "mongo/db/namespacestring.h"
+#include "mongo/db/client.h"
+#include "mongo/db/jsobj.h"
+#include "mongo/db/matcher/expression.h"
+#include "mongo/db/matcher/expression_parser.h"
+#include "mongo/scripting/engine.h"
+
+namespace mongo {
+
+    class WhereMatchExpression : public MatchExpression {
+    public:
+        WhereMatchExpression() : MatchExpression( SPECIAL, WHERE ){ _func = 0; }
+        virtual ~WhereMatchExpression(){}
+
+        Status init( const StringData& ns, const StringData& theCode, const BSONObj& scope );
+
+        virtual bool matches( const BSONObj& doc, MatchDetails* details = 0 ) const;
+
+        virtual bool matchesSingleElement( const BSONElement& e ) const {
+            return false;
+        }
+
+        virtual void debugString( StringBuilder& debug, int level = 0 ) const;
+
+        virtual bool equivalent( const MatchExpression* other ) const ;
+    private:
+        string _ns;
+        string _code;
+        BSONObj _userScope;
+
+        auto_ptr<Scope> _scope;
+        ScriptingFunction _func;
+    };
+
+    Status WhereMatchExpression::init( const StringData& ns,
+                                       const StringData& theCode,
+                                       const BSONObj& scope ) {
+
+        if ( ns.size() == 0 )
+            return Status( ErrorCodes::BadValue, "ns for $where cannot be empty" );
+
+        if ( theCode.size() == 0 )
+            return Status( ErrorCodes::BadValue, "code for $where cannot be empty" );
+
+        _ns = ns.toString();
+        _code = theCode.toString();
+        _userScope = scope.getOwned();
+
+        NamespaceString nswrapper( _ns );
+        _scope = globalScriptEngine->getPooledScope( nswrapper.db.c_str(), "where" );
+        _func = _scope->createFunction( _code.c_str() );
+
+        if ( !_func )
+            return Status( ErrorCodes::BadValue, "$where compile error" );
+
+        return Status::OK();
+    }
+
+    bool WhereMatchExpression::matches( const BSONObj& obj, MatchDetails* details ) const {
+        verify( _func );
+
+        if ( ! _userScope.isEmpty() ) {
+            _scope->init( &_userScope );
+        }
+        _scope->setObject( "obj", const_cast< BSONObj & >( obj ) );
+        _scope->setBoolean( "fullObject" , true ); // this is a hack b/c fullObject used to be relevant
+
+        int err = _scope->invoke( _func, 0, &obj, 1000 * 60, false );
+        if ( err == -3 ) { // INVOKE_ERROR
+            stringstream ss;
+            ss << "error on invocation of $where function:\n"
+               << _scope->getError();
+            uassert( 16812, ss.str(), false);
+        }
+        else if ( err != 0 ) {   // ! INVOKE_SUCCESS
+            uassert( 16813, "unknown error in invocation of $where function", false);
+        }
+
+        return _scope->getBoolean( "__returnValue" ) != 0;
+    }
+
+    void WhereMatchExpression::debugString( StringBuilder& debug, int level ) const {
+        _debugAddSpace( debug, level );
+        debug << "$where\n";
+
+        _debugAddSpace( debug, level + 1 );
+        debug << "ns: " << _ns << "\n";
+
+        _debugAddSpace( debug, level + 1 );
+        debug << "code: " << _code << "\n";
+
+        _debugAddSpace( debug, level + 1 );
+        debug << "scope: " << _userScope << "\n";
+    }
+
+    bool WhereMatchExpression::equivalent( const MatchExpression* other ) const {
+        if ( matchType() != other->matchType() )
+            return false;
+        const WhereMatchExpression* realOther = static_cast<const WhereMatchExpression*>(other);
+        return
+            _ns == realOther->_ns &&
+            _code == realOther->_code &&
+            _userScope == realOther->_userScope;
+    }
+
+
+    // -----------------
+
+    StatusWithMatchExpression expressionParserWhereCallbackReal(const BSONElement& where) {
+        if ( !haveClient() )
+            return StatusWithMatchExpression( ErrorCodes::BadValue, "no current client needed for $where" );
+
+        Client::Context* context = cc().getContext();
+        if ( !context )
+            return StatusWithMatchExpression( ErrorCodes::BadValue, "no context in $where parsing" );
+
+        const char* ns = context->ns();
+        if ( !ns )
+            return StatusWithMatchExpression( ErrorCodes::BadValue, "no ns in $where parsing" );
+
+        if ( !globalScriptEngine )
+            return StatusWithMatchExpression( ErrorCodes::BadValue, "no globalScriptEngine in $where parsing" );
+
+        auto_ptr<WhereMatchExpression> exp( new WhereMatchExpression() );
+        if ( where.type() == String || where.type() == Code ) {
+            Status s = exp->init( ns, where.valuestr(), BSONObj() );
+            if ( !s.isOK() )
+                return StatusWithMatchExpression( s );
+            return StatusWithMatchExpression( exp.release() );
+        }
+
+        if ( where.type() == CodeWScope ) {
+            Status s = exp->init( ns,
+                                  where.codeWScopeCode(),
+                                  BSONObj( where.codeWScopeScopeDataUnsafe() ) );
+            if ( !s.isOK() )
+                return StatusWithMatchExpression( s );
+            return StatusWithMatchExpression( exp.release() );
+        }
+
+        return StatusWithMatchExpression( ErrorCodes::BadValue, "$where got bad type" );
+    }
+
+    MONGO_INITIALIZER( MatchExpressionWhere )( ::mongo::InitializerContext* context ) {
+        expressionParserWhereCallback = expressionParserWhereCallbackReal;
+        return Status::OK();
+    }
+
+
+
+
+}
diff --git a/src/mongo/db/matcher/matcher.cpp b/src/mongo/db/matcher/matcher.cpp
index 0db46c3fba2..a427128bf98 100644
--- a/src/mongo/db/matcher/matcher.cpp
+++ b/src/mongo/db/matcher/matcher.cpp
@@ -18,6 +18,7 @@
 
 #include "mongo/pch.h"
 
+#include "mongo/db/jsobj.h"
 #include "mongo/db/matcher/expression_parser.h"
 #include "mongo/db/matcher/matcher.h"
 #include "mongo/util/mongoutils/str.h"
@@ -35,9 +36,138 @@ namespace mongo {
         _expression.reset( result.getValue() );
     }
 
+    Matcher2::Matcher2( const Matcher2 &docMatcher, const BSONObj &constrainIndexKey ) {
+
+        MatchExpression* indexExpression = spliceForIndex( constrainIndexKey,
+                                                          docMatcher._expression.get() );
+        if ( indexExpression )
+            _expression.reset( indexExpression );
+    }
+
     bool Matcher2::matches(const BSONObj& doc, MatchDetails* details ) const {
+        if ( !_expression )
+            return true;
         return _expression->matches( doc, details );
     }
 
 
+    bool Matcher2::atomic() const {
+        if ( !_expression )
+            return false;
+
+        if ( _expression->matchType() == MatchExpression::ATOMIC )
+            return true;
+
+        // we only go down one level
+        for ( unsigned i = 0; i < _expression->numChildren(); i++ ) {
+            if ( _expression->getChild( i )->matchType() == MatchExpression::ATOMIC )
+                return true;
+        }
+
+        return false;
+    }
+
+    bool Matcher2::singleSimpleCriterion() const {
+        if ( !_expression )
+            return false;
+
+        if ( _expression->matchType() == MatchExpression::EQ )
+            return true;
+
+        if ( _expression->matchType() == MatchExpression::AND &&
+             _expression->numChildren() == 1 &&
+             _expression->getChild(0)->matchType() == MatchExpression::EQ )
+            return true;
+
+        return false;
+    }
+
+    bool Matcher2::keyMatch( const Matcher2 &docMatcher ) const {
+        if ( !_expression )
+            return docMatcher._expression.get() == NULL;
+        if ( !docMatcher._expression )
+            return false;
+
+        return _expression->equivalent( docMatcher._expression.get() );
+    }
+
+    MatchExpression* Matcher2::spliceForIndex( const BSONObj& key,
+                                               const MatchExpression* full ) {
+        set<string> keys;
+        for ( BSONObjIterator i(key); i.more(); ) {
+            BSONElement e = i.next();
+            keys.insert( e.fieldName() );
+        }
+        return _spliceForIndex( keys, full );
+    }
+
+    MatchExpression* Matcher2::_spliceForIndex( const set<string>& keys,
+                                                const MatchExpression* full ) {
+
+        switch ( full->matchType() ) {
+        case MatchExpression::NOT:
+        case MatchExpression::NOR:
+            // maybe?
+            return NULL;
+
+        case MatchExpression::AND:
+        case MatchExpression::OR: {
+            auto_ptr<ListOfMatchExpression> dup;
+            for ( unsigned i = 0; i < full->numChildren(); i++ ) {
+                MatchExpression* sub = _spliceForIndex( keys, full->getChild( i ) );
+                if ( !sub )
+                    continue;
+                if ( !dup.get() ) {
+                    if ( full->matchType() == MatchExpression::AND )
+                        dup.reset( new AndMatchExpression() );
+                    else
+                        dup.reset( new OrMatchExpression() );
+                }
+                dup->add( sub );
+            }
+            if ( dup.get() )
+                return dup.release();
+            return NULL;
+        }
+
+        case MatchExpression::LTE:
+        case MatchExpression::LT:
+        case MatchExpression::EQ:
+        case MatchExpression::GT:
+        case MatchExpression::GTE:
+        case MatchExpression::NE:
+        case MatchExpression::REGEX:
+        case MatchExpression::MOD:
+        case MatchExpression::IN: {
+            const LeafMatchExpression* lme = static_cast<const LeafMatchExpression*>( full );
+            if ( !keys.count( lme->getPath().toString() ) )
+                return NULL;
+            return lme->shallowClone();
+        }
+
+        case MatchExpression::ALL:
+            // TODO: conver to $in
+            return NULL;
+
+        case MatchExpression::ELEM_MATCH_OBJECT:
+        case MatchExpression::ELEM_MATCH_VALUE:
+            // future
+            return NULL;
+
+        case MatchExpression::GEO:
+        case MatchExpression::SIZE:
+        case MatchExpression::EXISTS:
+        case MatchExpression::NIN:
+        case MatchExpression::TYPE_OPERATOR:
+        case MatchExpression::ATOMIC:
+        case MatchExpression::WHERE:
+            // no go
+            return NULL;
+
+
+        }
+
+        return NULL;
+    }
+
 }
diff --git a/src/mongo/db/matcher/matcher.h b/src/mongo/db/matcher/matcher.h
index 64201bd5dad..215cb99e592 100644
--- a/src/mongo/db/matcher/matcher.h
+++ b/src/mongo/db/matcher/matcher.h
@@ -21,6 +21,7 @@
 #include <boost/scoped_ptr.hpp>
 
 #include "mongo/base/disallow_copying.h"
+#include "mongo/base/status.h"
 #include "mongo/bson/bsonobj.h"
 #include "mongo/db/matcher/expression.h"
 #include "mongo/db/matcher/match_details.h"
@@ -33,11 +34,43 @@ namespace mongo {
     public:
         explicit Matcher2( const BSONObj& pattern );
 
+        /**
+         * Generate a matcher for the provided index key format using the
+         * provided full doc matcher.
+         * THIS API WILL GO AWAY EVENTUALLY
+         */
+        explicit Matcher2( const Matcher2 &docMatcher, const BSONObj &constrainIndexKey );
+
+
         bool matches(const BSONObj& doc, MatchDetails* details = NULL ) const;
 
+        bool atomic() const;
+
+        /*
+         * this is from old mature
+         * criteria is 1 equality expression, nothing else
+         */
+        bool singleSimpleCriterion() const;
+
+        const BSONObj* getQuery() const { return &_pattern; };
+        std::string toString() const { return _pattern.toString(); }
+
+        /**
+         * @return true if this key matcher will return the same true/false
+         * value as the provided doc matcher.
+         */
+        bool keyMatch( const Matcher2 &docMatcher ) const;
+
+        static MatchExpression* spliceForIndex( const BSONObj& key,
+                                                const MatchExpression* full );
+
     private:
         const BSONObj _pattern; // this is owned by who created us
         boost::scoped_ptr<MatchExpression> _expression;
+
+        static MatchExpression* _spliceForIndex( const set<std::string>& keys,
+                                                 const MatchExpression* full );
+
     };
 
 }
diff --git a/src/mongo/dbtests/matchertests.cpp b/src/mongo/dbtests/matchertests.cpp
index 1183fd7c53c..26c19d41db6 100644
--- a/src/mongo/dbtests/matchertests.cpp
+++ b/src/mongo/dbtests/matchertests.cpp
@@ -144,10 +144,11 @@ namespace MatcherTests {
         }
     };
 
+    template <typename M>
     class WithinBox {
     public:
         void run() {
-            Matcher m(fromjson("{loc:{$within:{$box:[{x: 4, y:4},[6,6]]}}}"));
+            M m(fromjson("{loc:{$within:{$box:[{x: 4, y:4},[6,6]]}}}"));
             ASSERT(!m.matches(fromjson("{loc: [3,4]}")));
             ASSERT(m.matches(fromjson("{loc: [4,4]}")));
             ASSERT(m.matches(fromjson("{loc: [5,5]}")));
@@ -156,10 +157,11 @@ namespace MatcherTests {
         }
     };
 
+    template <typename M>
     class WithinPolygon {
     public:
         void run() {
-            Matcher m(fromjson("{loc:{$within:{$polygon:[{x:0,y:0},[0,5],[5,5],[5,0]]}}}"));
+            M m(fromjson("{loc:{$within:{$polygon:[{x:0,y:0},[0,5],[5,5],[5,0]]}}}"));
             ASSERT(m.matches(fromjson("{loc: [3,4]}")));
             ASSERT(m.matches(fromjson("{loc: [4,4]}")));
             ASSERT(m.matches(fromjson("{loc: {x:5,y:5}}")));
@@ -168,10 +170,11 @@ namespace MatcherTests {
         }
     };
 
+    template <typename M>
     class WithinCenter {
     public:
         void run() {
-            Matcher m(fromjson("{loc:{$within:{$center:[{x:30,y:30},10]}}}"));
+            M m(fromjson("{loc:{$within:{$center:[{x:30,y:30},10]}}}"));
             ASSERT(!m.matches(fromjson("{loc: [3,4]}")));
             ASSERT(m.matches(fromjson("{loc: {x:30,y:30}}")));
             ASSERT(m.matches(fromjson("{loc: [20,30]}")));
@@ -198,6 +201,17 @@ namespace MatcherTests {
         }
     };
 
+    template <typename M>
+    class WhereSimple1 {
+    public:
+        void run() {
+            Client::ReadContext ctx( "unittests.matchertests" );
+            M m( BSON( "$where" << "function(){ return this.a == 1; }" ) );
+            ASSERT( m.matches( BSON( "a" << 1 ) ) );
+            ASSERT( !m.matches( BSON( "a" << 2 ) ) );
+        }
+    };
+
     namespace Covered { // Tests for CoveredIndexMatcher.
     
         /**
@@ -409,7 +423,83 @@ namespace MatcherTests {
             BSONObjBuilder _traversal;
         };
     };
-    
+
+    template <typename M>
+    class AtomicMatchTest {
+    public:
+        void run() {
+
+            {
+                M m( BSON( "x" << 5 ) );
+                ASSERT( !m.atomic() );
+            }
+
+            {
+                M m( BSON( "x" << 5 << "$atomic" << false ) );
+                ASSERT( !m.atomic() );
+            }
+
+            {
+                M m( BSON( "x" << 5 << "$atomic" << true ) );
+                ASSERT( m.atomic() );
+            }
+
+            {
+                bool threwError = false;
+                try {
+                    M m( BSON( "x" << 5 <<
+                               "$or" << BSON_ARRAY( BSON( "$atomic" << true << "y" << 6 ) ) ) );
+                }
+                catch ( ... ) {
+                    threwError = true;
+                }
+                ASSERT( threwError );
+            }
+        }
+    };
+
+    template <typename M>
+    class SingleSimpleCriterion {
+    public:
+        void run() {
+
+            {
+                M m( BSON( "x" << 5 ) );
+                ASSERT( m.singleSimpleCriterion() );
+            }
+
+            {
+                M m( BSON( "x" << 5 << "y" << 5 ) );
+                ASSERT( !m.singleSimpleCriterion() );
+            }
+
+            {
+                M m( BSON( "x" << BSON( "$gt" << 5 ) ) );
+                ASSERT( !m.singleSimpleCriterion() );
+            }
+
+        }
+    };
+
+    template <typename M>
+    class IndexPortion1 {
+    public:
+        void run() {
+            M full( BSON( "x" << 5 << "y" << 7 ) );
+            M partial( full, BSON( "x" << 1) );
+
+            ASSERT( full.matches( BSON( "x" << 5 << "y" << 7 ) ) );
+            ASSERT( partial.matches( BSON( "x" << 5 << "y" << 7 ) ) );
+
+            ASSERT( !full.matches( BSON( "x" << 5 << "y" << 8 ) ) );
+            ASSERT( partial.matches( BSON( "x" << 5 << "y" << 8 ) ) );
+
+            ASSERT( !full.keyMatch( partial ) );
+            ASSERT( full.keyMatch( full ) );
+            ASSERT( partial.keyMatch( partial ) );
+        }
+    };
+
     class All : public Suite {
     public:
         All() : Suite( "matcher" ) {
@@ -428,14 +518,18 @@ namespace MatcherTests {
             ADD_BOTH(Size);
             ADD_BOTH(MixedNumericEmbedded);
             ADD_BOTH(ElemMatchKey);
+            ADD_BOTH(WhereSimple1);
             add<Covered::ElemMatchKeyUnindexed>();
             add<Covered::ElemMatchKeyIndexed>();
             add<Covered::ElemMatchKeyIndexedSingleKey>();
             ADD_BOTH(AllTiming);
             add<Visit>();
-            add<WithinBox>();
-            add<WithinCenter>();
-            add<WithinPolygon>();
+            ADD_BOTH(WithinBox);
+            ADD_BOTH(WithinCenter);
+            ADD_BOTH(WithinPolygon);
+            ADD_BOTH(AtomicMatchTest);
+            ADD_BOTH(SingleSimpleCriterion);
+            ADD_BOTH(IndexPortion1);
         }
     } dball;