func (gt Gt) NegationBuild(builder Builder) {
	Lte(gt).Build(builder)
}

// Gte greater than or equal to for where
type Gte Eq

func (gte Gte) Build(builder Builder) {
	builder.WriteQuoted(gte.Column)
	builder.WriteString(" >= ")
	builder.AddVar(builder, gte.Value)
}

func (gte Gte) NegationBuild(builder Builder) {
	Lt(gte).Build(builder)
}

// Lt less than for where
type Lt Eq

        searchRenderData.setAllRecordCountRelation("eq");
        assertEquals("eq", searchRenderData.getAllRecordCountRelation());

        searchRenderData.setAllRecordCountRelation("gte");
        assertEquals("gte", searchRenderData.getAllRecordCountRelation());
    }

    @Test
    public void test_setAndGetAllPageCount() {
        // Test with zero
        searchRenderData.setAllPageCount(0);

        FacetResponse facetResponse = null;

        QueryResponseList qrList = new QueryResponseList(documentList, 100L, "gte", 500L, true, facetResponse, 0, 10, 0);

        assertEquals(documentList, qrList.parent);
        assertEquals(100L, qrList.getAllRecordCount());
        assertEquals("gte", qrList.getAllRecordCountRelation());
        assertEquals(500L, qrList.getQueryTime());
        assertTrue(qrList.isPartialResults());

                        Map.of("range", Map.of("expiredTime", Map.of("gte", 1000L)))))));

        final String json = coordinatorHelper.toJson(map);
        assertNotNull(json);
        assertTrue(json.contains("\"must\""));
        assertTrue(json.contains("\"heartbeat\""));
        assertTrue(json.contains("\"gte\""));
    }

    @Test
    public void test_parseJson_nestedStructure() {

        // Add boolean query
        queryContext.addQuery(boolQuery -> {
            boolQuery.filter(QueryBuilders.termQuery("type", "document"));
            boolQuery.must(QueryBuilders.rangeQuery("date").gte("2024-01-01"));
        });

        // Add function score
        queryContext.addFunctionScore(list -> {

            final String from = LocalDateTime.now().minusDays(fessConfig.getPurgeSuggestSearchLogDay()).format(DateTimeFormatter.ISO_DATE);
            cb.query().addQuery(QueryBuilders.rangeQuery("requestedAt").gte(from));
            cb.query().addOrderBy_RequestedAt_Asc();
            cb.specify().columnAccessType();
            cb.specify().columnUserSessionId();
            cb.specify().columnHitCount();

        /**
         * The total number of records found.
         */
        protected long recordCount;
        /**
         * The relation of the record count (e.g., "eq" for exact, "gte" for greater than or equal to).
         */
        protected String recordCountRelation;
        /**
         * The total number of pages in the search results.
         */
        protected int pageCount;

                "query", Map.of("bool", Map.of("must", List.of( //
                        Map.of("term", Map.of("type", TYPE_HEARTBEAT)), //
                        Map.of("range", Map.of("expiredTime", Map.of("gte", now)))))), //
                "size", 100));

        try (CurlResponse response = ComponentUtil.getCurlHelper() //
                .post("/" + getIndexName() + "/_search") //
                .body(query)

        final BytesRef min = termRangeQuery.getLowerTerm();
        if (min != null) {
            if (termRangeQuery.includesLower()) {
                rangeQuery.gte(min.utf8ToString());
            } else {
                rangeQuery.gt(min.utf8ToString());
            }
        }
        final BytesRef max = termRangeQuery.getUpperTerm();
        if (max != null) {

		},
		ExpectedVars: []interface{}{100},
		Result:       "SUM(`id`) = ?",
	}, {
		Expressions: []clause.Expression{
			clause.Gte{Column: clause.Expr{SQL: "SUM(?)", Vars: []interface{}{clause.Column{Table: "users", Name: "id"}}}, Value: 100},
		},
		ExpectedVars: []interface{}{100},
		Result:       "SUM(`users`.`id`) >= ?",
	}}