src/riemann/Query.g:61:1: greater_equal : field ( WS )* GREATER_EQUAL ( WS )* value ;
547968
public final QueryParser.greater_equal_return greater_equal() throws RecognitionException {
        QueryParser.greater_equal_return retval = new QueryParser.greater_equal_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token WS61=null;
        Token GREATER_EQUAL62=null;
        Token WS63=null;
        QueryParser.field_return field60 = null;

        QueryParser.value_return value64 = null;


        CommonTree WS61_tree=null;
        CommonTree GREATER_EQUAL62_tree=null;
        CommonTree WS63_tree=null;

        try {
            // src/riemann/Query.g:62:2: ( field ( WS )* GREATER_EQUAL ( WS )* value )
            // src/riemann/Query.g:62:4: field ( WS )* GREATER_EQUAL ( WS )* value
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_field_in_greater_equal450);
            field60=field();

            state._fsp--;

            adaptor.addChild(root_0, field60.getTree());
            // src/riemann/Query.g:62:10: ( WS )*
            loop23:
            do {
                int alt23=2;
                int LA23_0 = input.LA(1);

                if ( (LA23_0==WS) ) {
                    alt23=1;
                }


                switch (alt23) {
            	case 1 :
            	    // src/riemann/Query.g:62:10: WS
            	    {
            	    WS61=(Token)match(input,WS,FOLLOW_WS_in_greater_equal452); 
            	    WS61_tree = (CommonTree)adaptor.create(WS61);
            	    adaptor.addChild(root_0, WS61_tree);


            	    }
            	    break;

            	default :
            	    break loop23;
                }
            } while (true);

            GREATER_EQUAL62=(Token)match(input,GREATER_EQUAL,FOLLOW_GREATER_EQUAL_in_greater_equal455); 
            GREATER_EQUAL62_tree = (CommonTree)adaptor.create(GREATER_EQUAL62);
            root_0 = (CommonTree)adaptor.becomeRoot(GREATER_EQUAL62_tree, root_0);

            // src/riemann/Query.g:62:29: ( WS )*
            loop24:
            do {
                int alt24=2;
                int LA24_0 = input.LA(1);

                if ( (LA24_0==WS) ) {
                    alt24=1;
                }


                switch (alt24) {
            	case 1 :
            	    // src/riemann/Query.g:62:29: WS
            	    {
            	    WS63=(Token)match(input,WS,FOLLOW_WS_in_greater_equal458); 
            	    WS63_tree = (CommonTree)adaptor.create(WS63);
            	    adaptor.addChild(root_0, WS63_tree);


            	    }
            	    break;

            	default :
            	    break loop24;
                }
            } while (true);

            pushFollow(FOLLOW_value_in_greater_equal461);
            value64=value();

            state._fsp--;

            adaptor.addChild(root_0, value64.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
1110004
public static Query lessThanEquals(String field, Object value) {
        return new Query().lessThanEquals(field, value);
    }
167804
public final void synpred47_DRL6Expressions_fragment() throws RecognitionException {
		// src/main/resources/org/drools/compiler/lang/DRL6Expressions.g:740:7: ( GREATER GREATER GREATER )
		// src/main/resources/org/drools/compiler/lang/DRL6Expressions.g:740:8: GREATER GREATER GREATER
		{
		match(input,GREATER,FOLLOW_GREATER_in_synpred47_DRL6Expressions4674); if (state.failed) return;
		match(input,GREATER,FOLLOW_GREATER_in_synpred47_DRL6Expressions4676); if (state.failed) return;
		match(input,GREATER,FOLLOW_GREATER_in_synpred47_DRL6Expressions4678); if (state.failed) return;
		}

	}
205806
public final QueryParser.not_equal_return not_equal() throws RecognitionException {
        QueryParser.not_equal_return retval = new QueryParser.not_equal_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token WS66=null;
        Token NOT_EQUAL67=null;
        Token WS68=null;
        QueryParser.field_return field65 = null;

        QueryParser.value_return value69 = null;


        CommonTree WS66_tree=null;
        CommonTree NOT_EQUAL67_tree=null;
        CommonTree WS68_tree=null;

        try {
            // src/riemann/Query.g:64:2: ( field ( WS )* NOT_EQUAL ( WS )* value )
            // src/riemann/Query.g:64:4: field ( WS )* NOT_EQUAL ( WS )* value
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_field_in_not_equal469);
            field65=field();

            state._fsp--;

            adaptor.addChild(root_0, field65.getTree());
            // src/riemann/Query.g:64:10: ( WS )*
            loop25:
            do {
                int alt25=2;
                int LA25_0 = input.LA(1);

                if ( (LA25_0==WS) ) {
                    alt25=1;
                }


                switch (alt25) {
            	case 1 :
            	    // src/riemann/Query.g:64:10: WS
            	    {
            	    WS66=(Token)match(input,WS,FOLLOW_WS_in_not_equal471); 
            	    WS66_tree = (CommonTree)adaptor.create(WS66);
            	    adaptor.addChild(root_0, WS66_tree);


            	    }
            	    break;

            	default :
            	    break loop25;
                }
            } while (true);

            NOT_EQUAL67=(Token)match(input,NOT_EQUAL,FOLLOW_NOT_EQUAL_in_not_equal474); 
            NOT_EQUAL67_tree = (CommonTree)adaptor.create(NOT_EQUAL67);
            root_0 = (CommonTree)adaptor.becomeRoot(NOT_EQUAL67_tree, root_0);

            // src/riemann/Query.g:64:25: ( WS )*
            loop26:
            do {
                int alt26=2;
                int LA26_0 = input.LA(1);

                if ( (LA26_0==WS) ) {
                    alt26=1;
                }


                switch (alt26) {
            	case 1 :
            	    // src/riemann/Query.g:64:25: WS
            	    {
            	    WS68=(Token)match(input,WS,FOLLOW_WS_in_not_equal477); 
            	    WS68_tree = (CommonTree)adaptor.create(WS68);
            	    adaptor.addChild(root_0, WS68_tree);


            	    }
            	    break;

            	default :
            	    break loop26;
                }
            } while (true);

            pushFollow(FOLLOW_value_in_not_equal480);
            value69=value();

            state._fsp--;

            adaptor.addChild(root_0, value69.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
304179
function queryError(text, d, op, value) {
        var miss, err;
        miss = '(?)';
        err = this._getConstrName() + '._analyzeQuery: ' + text +
            '. Malformed query: ' + d || miss + ' ' + op || miss +
            ' ' + value || miss + '.';
        throw new Error(err);
    }
325605
def p_expression_greaterthan(self, p):
        ''
        p[0] = GreaterThan(p[1], p[3], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
864887
public ZealotKhala orLessThan(String field, Object value) {
        return this.doNormal(ZealotConst.OR_PREFIX, field, value, ZealotConst.LT_SUFFIX, true);
    }
763743
public ZealotKhala orNotEqual(String field, Object value) {
        return this.doNormal(ZealotConst.OR_PREFIX, field, value, ZealotConst.NOT_EQUAL_SUFFIX, true);
    }
914524
@Override
    public <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> lhs,
            Expression<? extends Y> rhs)
    {

        return new ComparisonPredicate(lhs, rhs, ConditionalOperator.GT);
    }
757773
def equal(mol, query, largest_only=True, ignore_hydrogen=True):
    
    m = molutil.clone(mol)
    q = molutil.clone(query)
    if largest_only:
        m = molutil.largest_graph(m)
        q = molutil.largest_graph(q)
    if ignore_hydrogen:
        m = molutil.make_Hs_implicit(m)
        q = molutil.make_Hs_implicit(q)
    if molutil.mw(m) == molutil.mw(q):
        gm = GraphMatcher(q.graph, m.graph, node_match=atom_match)
        return gm.is_isomorphic()
    return False
298219
public static Query notEquals(String field, Object value) {
        return new Query().notEquals(field, value);
    }
1170023
public final void mNOT_EQUAL() throws RecognitionException {
        try {
            int _type = NOT_EQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src/riemann/Query.g:10:11: ( '!=' )
            // src/riemann/Query.g:10:13: '!='
            {
            match("!="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
353361
public ZealotKhala moreThan(String field, Object value) {
        return this.doNormal(ZealotConst.ONE_SPACE, field, value, ZealotConst.GT_SUFFIX, true);
    }
123379
public final QueryParser.lesser_equal_return lesser_equal() throws RecognitionException {
        QueryParser.lesser_equal_return retval = new QueryParser.lesser_equal_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token WS51=null;
        Token LESSER_EQUAL52=null;
        Token WS53=null;
        QueryParser.field_return field50 = null;

        QueryParser.value_return value54 = null;


        CommonTree WS51_tree=null;
        CommonTree LESSER_EQUAL52_tree=null;
        CommonTree WS53_tree=null;

        try {
            // src/riemann/Query.g:59:2: ( field ( WS )* LESSER_EQUAL ( WS )* value )
            // src/riemann/Query.g:59:4: field ( WS )* LESSER_EQUAL ( WS )* value
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_field_in_lesser_equal413);
            field50=field();

            state._fsp--;

            adaptor.addChild(root_0, field50.getTree());
            // src/riemann/Query.g:59:10: ( WS )*
            loop19:
            do {
                int alt19=2;
                int LA19_0 = input.LA(1);

                if ( (LA19_0==WS) ) {
                    alt19=1;
                }


                switch (alt19) {
            	case 1 :
            	    // src/riemann/Query.g:59:10: WS
            	    {
            	    WS51=(Token)match(input,WS,FOLLOW_WS_in_lesser_equal415); 
            	    WS51_tree = (CommonTree)adaptor.create(WS51);
            	    adaptor.addChild(root_0, WS51_tree);


            	    }
            	    break;

            	default :
            	    break loop19;
                }
            } while (true);

            LESSER_EQUAL52=(Token)match(input,LESSER_EQUAL,FOLLOW_LESSER_EQUAL_in_lesser_equal418); 
            LESSER_EQUAL52_tree = (CommonTree)adaptor.create(LESSER_EQUAL52);
            root_0 = (CommonTree)adaptor.becomeRoot(LESSER_EQUAL52_tree, root_0);

            // src/riemann/Query.g:59:28: ( WS )*
            loop20:
            do {
                int alt20=2;
                int LA20_0 = input.LA(1);

                if ( (LA20_0==WS) ) {
                    alt20=1;
                }


                switch (alt20) {
            	case 1 :
            	    // src/riemann/Query.g:59:28: WS
            	    {
            	    WS53=(Token)match(input,WS,FOLLOW_WS_in_lesser_equal421); 
            	    WS53_tree = (CommonTree)adaptor.create(WS53);
            	    adaptor.addChild(root_0, WS53_tree);


            	    }
            	    break;

            	default :
            	    break loop20;
                }
            } while (true);

            pushFollow(FOLLOW_value_in_lesser_equal424);
            value54=value();

            state._fsp--;

            adaptor.addChild(root_0, value54.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
219400
def validate_equal(value):
    
    def equal_validator(field, data):
        if field.value is None:
            return
        if not (field.value == value):
            raise ValidationError('equal', other=value)
    return equal_validator
544064
public static Query greaterThan(String field, Object value) {
        return new Query().greaterThan(field, value);
    }
380188
public ZealotKhala lessThan(String field, Object value) {
        return this.doNormal(ZealotConst.ONE_SPACE, field, value, ZealotConst.LT_SUFFIX, true);
    }