Exact match queries

res = index.search(Query("@price:[270 270]"))
print(res.total)
# >>> 1

try:
    res = index.search(Query("@price:[270]")) # not yet supported in redis-py
    print(res.total)
    # >>> 1
    assert res.total == 1
except Exception:
    print("'@price:[270]' syntax not yet supported.")

try:
    res = index.search(Query("@price==270")) # not yet supported in redis-py
    print(res.total)
    # >>> 1
    assert res.total == 1
except Exception:
    print("'@price==270' syntax not yet supported.")

query = Query("*").add_filter(NumericFilter("price", 270, 270))
res = index.search(query)
print(res.total)
# >>> 1

const res1 = await client.ft.search('idx:bicycle', '@price:[270 270]');
console.log(res1.total); // >>> 1

try {
    const res2 = await client.ft.search('idx:bicycle', '@price:[270]');
    console.log(res2.total); // >>> 1
    assert.strictEqual(res2.total, 1);
} catch (err) {
    console.log("'@price:[270]' syntax not yet supported.");
}

try {
    const res3 = await client.ft.search('idx:bicycle', '@price==270');
    console.log(res3.total); // >>> 1
    assert.strictEqual(res3.total, 1);
} catch (err) {
    console.log("'@price==270' syntax not yet supported.");
}

// FILTER is not supported
// const res4 = await client.ft.search('idx:bicycle', '*', {
//   FILTER: {
//       field: 'price',
//       min: 270,
//       max: 270,
//   }
// });
// console.log(res4.total); // >>> 1

        SearchResult res1 = jedis.ftSearch("idx:bicycle", "@price:[270 270]");
        System.out.println(res1.getTotalResults()); // >>> 1

        List<Document> docs1 = res1.getDocuments();

        for (int i = 0; i < docs1.size(); i++) {
            System.out.println(docs1.get(i).getId());
        }
        // >>> bicycle:0

        SearchResult res2 = jedis.ftSearch("idx:bicycle",
            "*",
            FTSearchParams.searchParams()
                    .filter("price", 270, 270)
        );
        System.out.println(res2.getTotalResults()); // >>> 1

        List<Document> docs2 = res2.getDocuments();

        for (int i = 0; i < docs2.size(); i++) {
            System.out.println(docs2.get(i).getId());
        }
        // >>> bicycle:0

            CompletableFuture<SearchReply<String, String>> priceResults = asyncCommands.ftSearch("idx:bicycle", "@price:[270]")

                    .thenApply(res -> {

                        res.getResults().forEach(doc -> {
                            System.out.printf("ID: %s\n", doc.getId());
                        });
                        // >>> ID: bicycle:0

                        return res;
                    }).toCompletableFuture();

            Mono<SearchReply<String, String>> priceResults = reactiveCommands.ftSearch("idx:bicycle", "@price:[270]")
                    .doOnNext(res -> {
                        res.getResults().forEach(doc -> {
                            System.out.printf("ID: %s\n", doc.getId());
                        });
                        // >>> ID: bicycle:0
                    });

	res1, err := rdb.FTSearch(ctx,
		"idx:bicycle", "@price:[270 270]",
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res1.Total) // >>> 1

	for _, doc := range res1.Docs {
		fmt.Println(doc.ID)
	}
	// >>> bicycle:0

	res2, err := rdb.FTSearchWithArgs(ctx,
		"idx:bicycle",
		"*",
		&redis.FTSearchOptions{
			Filters: []redis.FTSearchFilter{
				{
					FieldName: "price",
					Min:       270,
					Max:       270,
				},
			},
		},
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res2.Total) // >>> 1

	for _, doc := range res2.Docs {
		fmt.Println(doc.ID)
	}
	// >>> bicycle:0

        SearchResult res1 = db.FT().Search(
            "idx:bicycle",
            new("@price:[270 270]")
        );
        Console.WriteLine(res1.TotalResults); //    >>> 1

        SearchResult res2 = db.FT().Search(
            "idx:bicycle",
            new Query().AddFilter(
                new Query.NumericFilter("price", 270, 270)
            )
        );
        Console.WriteLine(res2.TotalResults); //    >>> 1

res = index.search(Query("@condition:{new}"))
print(res.total)
# >>> 5

const res5 = await client.ft.search('idx:bicycle', '@condition:{new}');
console.log(res5.total); // >>> 5

        SearchResult res3 = jedis.ftSearch("idx:bicycle", "@condition:{new}");
        System.out.println(res3.getTotalResults()); // >>> 5

        List<Document> docs3 = res3.getDocuments();

        for (int i = 0; i < docs3.size(); i++) {
            System.out.println(docs3.get(i).getId());
        }
        // >>> bicycle:5
        // >>> bicycle:0
        // >>> bicycle:6
        // >>> bicycle:7
        // >>> bicycle:8

            CompletableFuture<SearchReply<String, String>> conditionResults = asyncCommands
                    .ftSearch("idx:bicycle", "@condition:{new}").thenApply(res -> {
                        res.getResults().stream().sorted((doc1, doc2) -> doc1.getId().compareTo(doc2.getId())).forEach(doc -> {
                            System.out.printf("ID: %s\n", doc.getId());
                        });
                        // >>> ID: bicycle:0
                        // >>> ID: bicycle:5
                        // >>> ID: bicycle:6
                        // >>> ID: bicycle:7
                        // >>> ID: bicycle:8

                        return res;
                    }).toCompletableFuture();

            Mono<SearchReply<String, String>> conditionResults = reactiveCommands.ftSearch("idx:bicycle", "@condition:{new}")
                    .doOnNext(res -> {
                        res.getResults().stream().sorted((doc1, doc2) -> doc1.getId().compareTo(doc2.getId())).forEach(doc -> {
                            System.out.printf("ID: %s\n", doc.getId());
                        });
                        // >>> ID: bicycle:0
                        // >>> ID: bicycle:5
                        // >>> ID: bicycle:6
                        // >>> ID: bicycle:7
                        // >>> ID: bicycle:8
                    });

	res3, err := rdb.FTSearch(ctx,
		"idx:bicycle", "@condition:{new}",
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res3.Total) // >>> 5

	docs := res3.Docs
	slices.SortFunc(docs, func(a, b redis.Document) int {
		return strings.Compare(a.ID, b.ID)
	})

	for _, doc := range docs {
		fmt.Println(doc.ID)
	}
	// >>> bicycle:0
	// >>> bicycle:5
	// >>> bicycle:6
	// >>> bicycle:7
	// >>> bicycle:8

        SearchResult res3 = db.FT().Search(
            "idx:bicycle",
            new("@condition:{new}")
        );
        Console.WriteLine(res3.TotalResults);   // >>> 4

schema = (
    TagField("$.email", as_name="email")
)

idx_email = r.ft("idx:email")
idx_email.create_index(
    schema,
    definition=IndexDefinition(prefix=["key:"], index_type=IndexType.JSON),
)
r.json().set('key:1', Path.root_path(), '{"email": "[email protected]"}')

try:
    res = idx_email.search(Query("[email protected]").dialect(2))
    print(res)
except Exception:
    print("'[email protected]' syntax not yet supported.")

await client.ft.create('idx:email', {
  '$.email': {
    type: SCHEMA_FIELD_TYPE.TAG,
    AS: 'email'
  }
}, {
  ON: 'JSON',
  PREFIX: 'key:'
})

await client.json.set('key:1', '$', { email: '[email protected]' });

try {
    const res6 = await client.ft.search('idx:email', '[email protected]', { DIALECT: 2 });
    console.log(res6);
} catch (err) {
    console.log("'[email protected]' syntax not yet supported.");
}

        SchemaField[] emailSchema = {
            TextField.of("$.email").as("email")
        };

        jedis.ftCreate("idx:email", 
            new FTCreateParams()
                    .addPrefix("key:")
                    .on(IndexDataType.JSON),
            emailSchema
        );

        jedis.jsonSet("key:1", Path2.ROOT_PATH, "{\"email\": \"[email protected]\"}");
        
        SearchResult res4 = jedis.ftSearch("idx:email",
            RediSearchUtil.escapeQuery("@email{[email protected]}"),
            new FTSearchParams().dialect(2)
        );
        System.out.println(res4.getTotalResults());

            List<FieldArgs<String>> emailSchema = Arrays
                    .asList(TagFieldArgs.<String> builder().name("$.email").as("email").build());
            CreateArgs<String, String> emailCreateArgs = CreateArgs.<String, String> builder().on(CreateArgs.TargetType.JSON)
                    .withPrefix("key:").build();

            CompletableFuture<SearchReply<String, String>> emailResults = asyncCommands
                    .ftCreate("idx:email", emailCreateArgs, emailSchema).thenCompose(res -> {
                        System.out.println(res); // >>> OK
                        return asyncCommands.jsonSet("key:1", JsonPath.ROOT_PATH,
                                parser.createJsonObject().put("email", parser.createJsonValue("\"[email protected]\"")));
                    }).thenCompose(res2 -> {
                        System.out.println(res2); // >>> OK
                        return asyncCommands.ftSearch("idx:email", "@email:{test\\@redis\\.com}");
                    }).thenApply(res3 -> {
                        System.out.println(res3.getResults().size()); // >>> 1
                        System.out.println(res3.getResults().get(0).getId());
                        // >>> key:1
                        return res3;
                    }).toCompletableFuture();

            List<FieldArgs<String>> emailSchema = Arrays
                    .asList(TagFieldArgs.<String> builder().name("$.email").as("email").build());

            CreateArgs<String, String> emailCreateArgs = CreateArgs.<String, String> builder().on(CreateArgs.TargetType.JSON)
                    .withPrefix("key:").build();

            Mono<Void> emailResults = reactiveCommands.ftCreate("idx:email", emailCreateArgs, emailSchema).doOnNext(res -> {
                System.out.println(res); // >>> OK
            }).flatMap(res -> reactiveCommands.jsonSet("key:1", JsonPath.ROOT_PATH,
                    parser.createJsonObject().put("email", parser.createJsonValue("\"[email protected]\"")))).doOnNext(res -> {
                        System.out.println(res); // >>> OK
                    }).flatMap(res -> reactiveCommands.ftSearch("idx:email", "@email:{test\\@redis\\.com}")).doOnNext(res -> {
                        System.out.println(res.getResults().size()); // >>> 1
                        System.out.println(res.getResults().get(0).getId());
                        // >>> key:1
                    }).then();

	res4, err := rdb.FTCreate(ctx,
		"idx:email",
		&redis.FTCreateOptions{
			OnJSON: true,
			Prefix: []interface{}{"key:"},
		},
		&redis.FieldSchema{
			FieldName: "$.email",
			As:        "email",
			FieldType: redis.SearchFieldTypeTag,
		},
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res4) // >>> OK

	res5, err := rdb.JSONSet(ctx, "key:1", "$",
		map[string]interface{}{
			"email": "[email protected]",
		},
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res5) // >>> OK

	res6, err := rdb.FTSearch(ctx, "idx:email",
		"@email:{test\\@redis\\.com}",
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res6.Total) // >>> 1

        Schema emailSchema = new Schema()
            .AddTagField(new FieldName("$.email", "email"));

        FTCreateParams emailParams = new FTCreateParams()
            .AddPrefix("key:")
            .On(IndexDataType.JSON);

        db.FT().Create("idx:email", emailParams, emailSchema);

        db.JSON().Set("key:1", "$", "{\"email\": \"[email protected]\"}");


        SearchResult res4 = db.FT().Search(
            "idx:email",
            new Query("@email:{test\\@redis\\.com}").Dialect(2)
        );
        Console.WriteLine(res4.TotalResults);   // >>> 1

res = index.search(Query("@description:\"rough terrain\""))
print(res.total)
# >>> 1 (Result{1 total, docs: [Document {'id': 'bicycle:8'...)

const res7 = await client.ft.search('idx:bicycle', '@description:"rough terrain"');
console.log(res7.total); // >>> 1 (Result{1 total, docs: [Document {'id': 'bicycle:8'...)

        SearchResult res5 = jedis.ftSearch("idx:bicycle",
            "@description:\"rough terrain\""
        );
        System.out.println(res5.getTotalResults()); // >>> 1

        List<Document> docs5 = res5.getDocuments();

        for (int i = 0; i < docs5.size(); i++) {
            System.out.println(docs5.get(i).getId());
        }
        // >>> bicycle:8

            CompletableFuture<SearchReply<String, String>> textMatchResults = asyncCommands
                    .ftSearch("idx:bicycle", "@description:\"rough terrain\"").thenApply(res -> {
                        res.getResults().forEach(doc -> {
                            System.out.printf("ID: %s\n", doc.getId());
                        });
                        // >>> ID: bicycle:8

                        return res;
                    }).toCompletableFuture();

            Mono<SearchReply<String, String>> textMatchResults = reactiveCommands
                    .ftSearch("idx:bicycle", "@description:\"rough terrain\"").doOnNext(res -> {
                        res.getResults().forEach(doc -> {
                            System.out.printf("ID: %s\n", doc.getId());
                        });
                        // >>> ID: bicycle:8
                    });

	res7, err := rdb.FTSearch(ctx,
		"idx:bicycle", "@description:\"rough terrain\"",
	).Result()

	if err != nil {
		panic(err)
	}

	fmt.Println(res7.Total) // >>> 1

	for _, doc := range res7.Docs {
		fmt.Println(doc.ID)
	}
	// >>> bicycle:8

        SearchResult res5 = db.FT().Search(
            "idx:bicycle",
            new("@description:\"rough terrain\"")
        );
        Console.WriteLine(res5.TotalResults);   // >>> 1