Kotlin के लिए Elasticsearch क्लाइंट: एकीकरण, उदाहरण और सुविधाएँ

Kotlin के लिए Elasticsearch क्लाइंट: पूरी गाइड

Elasticsearch एक शक्तिशाली वितरित सर्च इंजन है, जो Lucene पर आधारित है। Kotlin एप्लिकेशन से इसका उपयोग करने के लिए आधिकारिक Elasticsearch Java क्लाइंट का उपयोग किया जाता है, जो JVM से निकटता के कारण Kotlin के साथ पूरी तरह से संगत है। इस लेख में, हम क्लाइंट को सेट करना, बुनियादी ऑपरेशन (इंडेक्सिंग, सर्च, डिलीट) करना और एग्रीगेशन और फ़िल्टरिंग जैसी उन्नत सुविधाओं का उपयोग करना सीखेंगे।

कनेक्शन और सेटअप

सबसे पहले, build.gradle.kts (या build.gradle) में डिपेंडेंसी जोड़ें:

// build.gradle.kts
dependencies {
    implementation("co.elastic.clients:elasticsearch-java:8.15.0")
    implementation("com.fasterxml.jackson.core:jackson-databind:2.17.0")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.17.0")
}

फिर क्लाइंट बनाएं:

import co.elastic.clients.elasticsearch.ElasticsearchClient
import co.elastic.clients.json.jackson.JacksonJsonpMapper
import co.elastic.clients.transport.rest_client.RestClientTransport
import org.apache.http.HttpHost
import org.elasticsearch.client.RestClient

fun createClient(): ElasticsearchClient {
    val restClient = RestClient.builder(
        HttpHost("localhost", 9200, "http")
    ).build()

    val transport = RestClientTransport(restClient, JacksonJsonpMapper())
    return ElasticsearchClient(transport)
}

val client = createClient()

बुनियादी ऑपरेशन

डॉक्यूमेंट इंडेक्स करना

डेटा दर्शाने के लिए एक data class बनाएं:

data class Product(
    val id: String,
    val name: String,
    val price: Double,
    val category: String
)

इंडेक्सिंग इस प्रकार की जाती है:

suspend fun indexProduct(product: Product) {
    client.index { i ->
        i.index("products")
            .id(product.id)
            .document(product)
    }
}

// उपयोग का उदाहरण
val product = Product("1", "लैपटॉप", 999.99, "इलेक्ट्रॉनिक्स")
runBlocking { indexProduct(product) }

फ़ील्ड के आधार पर खोज

suspend fun searchByName(name: String): List<Product> {
    val response = client.search<Product>({ s ->
        s.index("products")
            .query { q ->
                q.match { m ->
                    m.field("name")
                        .query(name)
                }
            }
    }, Product::class.java)

    return response.hits().hits().map { it.source()!! }
}

डॉक्यूमेंट हटाना

suspend fun deleteProduct(id: String) {
    client.delete { d ->
        d.index("products")
            .id(id)
    }
}

फ़िल्टरिंग और एग्रीगेशन

Elasticsearch जटिल क्वेरी को सपोर्ट करता है। उदाहरण के लिए, मूल्य सीमा में उत्पादों की खोज और श्रेणी के अनुसार एग्रीगेशन:

suspend fun searchWithAggregation(minPrice: Double, maxPrice: Double) {
    val response = client.search<Product>({ s ->
        s.index("products")
            .query { q ->
                q.range { r ->
                    r.field("price")
                        .gte(minPrice.toString())
                        .lte(maxPrice.toString())
                }
            }
            .aggregations("by_category") { a ->
                a.terms { t ->
                    t.field("category")
                }
            }
    }, Product::class.java)

    // एग्रीगेशन परिणाम प्राप्त करें
    val categories = response.aggregations()
        ?.get("by_category")
        ?.sterms()
        ?.buckets()
        ?.map { "${it.key()}: ${it.docCount()}" }
        ?: emptyList()

    println("श्रेणियाँ: $categories")
}

बल्क प्रोसेसिंग (Bulk API)

बड़े पैमाने पर इंडेक्सिंग के लिए bulk का उपयोग करें:

suspend fun bulkIndexProducts(products: List<Product>) {
    val bulkRequest = client.bul