Elasticsearch C++ क्लाइंट: elasticlient पूर्ण गाइड

Elasticsearch C++ क्लाइंट: elasticlient के साथ पूर्ण गाइड

Elasticsearch एक शक्तिशाली वितरित सर्च इंजन है, जो Apache Lucene पर आधारित है। C++ से इसके साथ इंटरैक्ट करने के लिए कई लाइब्रेरी उपलब्ध हैं। इस लेख में हम elasticlient पर विस्तार से चर्चा करेंगे - एक हल्का, आधुनिक और उपयोगकर्ता-अनुकूल क्लाइंट जो HTTP अनुरोधों के लिए libcurl और JSON हैंडलिंग के लिए nlohmann/json का उपयोग करता है। यह नेटिव ऐप्स, सर्वर घटकों और डेटा विश्लेषण टूल्स में सर्च फीचर्स को एम्बेड करने के लिए आदर्श है।

elasticlient की मुख्य विशेषताएं

• Elasticsearch के सभी मुख्य ऑपरेशंस: डॉक्यूमेंट इंडेक्सिंग, अपडेट, डिलीट।
• फुल-टेक्स्ट सर्च, फिल्टर और एग्रीगेशन के साथ सर्च क्वेरी।
• इंडेक्स प्रबंधन: बनाना, हटाना, मैपिंग कॉन्फ़िगर करना।
• उच्च प्रदर्शन के लिए बल्क प्रोसेसिंग।
• SSL/TLS और बेसिक ऑथेंटिकेशन सपोर्ट।
• कॉलबैक मैकेनिज्म के माध्यम से एसिंक्रोनस अनुरोध।

लाइब्रेरी इंस्टॉलेशन

elasticlient को बिल्ड करने के लिए C++17 सपोर्ट वाला कंपाइलर और निर्भरताएं चाहिए: libcurl (डेवलपमेंट) और nlohmann-json। पैकेज मैनेजर (Ubuntu/Debian) के माध्यम से इंस्टॉल करें:

sudo apt install libcurl4-openssl-dev nlohmann-json3-dev cmake g++

सोर्स से बिल्ड करें:

git clone https://github.com/elastic/elasticlient.git
cd elasticlient
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j4
sudo make install

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

शुरू करने के लिए, अपने Elasticsearch क्लस्टर का URL देते हुए क्लाइंट का एक इंस्टेंस बनाएं:

#include <elasticlient/client.h>
#include <iostream>

int main() {
    elasticlient::Client client({"http://localhost:9200"});
    // कनेक्शन जांचें
    auto ping = client.ping();
    if (ping.status() == 200) {
        std::cout << "कनेक्शन सफल!" << std::endl;
    }
    return 0;
}

एकाधिक नोड्स वाले क्लस्टर के लिए URL की सूची दें:

elasticlient::Client client({
    "http://node1:9200",
    "http://node2:9200",
    "http://node3:9200"
});

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

नया डॉक्यूमेंट इंडेक्स करना (बनाना या अपडेट करना):

#include <nlohmann/json.hpp>
using json = nlohmann::json;

json doc = {
    {"title", "C++ के लिए Elasticsearch"},
    {"content", "elasticlient क्लाइंट का उपयोग करने की विस्तृत गाइड"},
    {"tags", {"cpp", "elasticsearch", "सर्च"}},
    {"views", 0}
};

auto result = client.index("articles", "article", doc.dump(), "1");
if (result.status() == 201) {
    std::cout << "डॉक्यूमेंट बन गया: " << result.body() << std::endl;
}

ID द्वारा डॉक्यूमेंट प्राप्त करें:

auto getResult = client.get("articles", "article", "1");
if (getResult.status() == 200) {
    json docJson = json::parse(getResult.body());
    std::cout << "शीर्षक: " << docJson["_source"]["title"] << std::endl;
}

मौजूदा डॉक्यूमेंट को अपडेट करें (आंशिक):

json updateFields = {
    {"doc", {{"views", 42}}}
};
auto updateResult = client.update("articles", "article", "1", updateFields.dump());

सर्च और फिल्टरेशन

Query DSL का उपयोग करके फुल-टेक्स्ट सर्च करें:

json searchQuery = {
    {"query", {
        {"bool", {
            {"must", {
                {{"match", {{"content", "गाइड"}}}}
            }},
            {"filter", {
                {{"term", {{"tags", "cpp"}}}}
            }}
        }}
    }},
    {"size", 10}
};

auto searchResult = client.search("articles", searchQuery.dump());
if (searchResult.status() == 200) {
    json hits = json::parse(searchResult.body())["hits"]["hits"];
    for (const auto& hit : hits) {
        std::cout << "डॉक्यूमेंट ID: " << hit["_id"] << ", स्कोर: " << hit["_score"] << std::endl;
    }
}

इंडेक्स प्रबंधन

नया इंडेक्स बनाएं और मैपिंग सेट करें:

json mapping = {
    {"mappings", {
        {"properties", {
            {"title", {{"type", "text"}}},
            {"content", {{"type", "text"}}},
            {"tags", {{"type", "keyword"}}},
            {"views", {{"type", "integer"}}}
        }}
    }}
};

auto createResult = client.createIndex("articles", mapping.dump());
if (createResult.status() == 200) {
    std::cout << "इंडेक्स बन गया!" << std::endl;
}

इंडेक्स हटाएं:

auto deleteResult = client.deleteIndex("articles");
if (deleteResult.status() == 200) {
    std::cout << "इंडेक्स हटा दिया गया" << std::endl;
}

एग्रीगेशन

डेटा विश्लेषण के लिए एग्रीगेशन का उपयोग करें:

json aggQuery = {
    {"size", 0},
    {"aggs", {
        {"avg_views", {{"avg", {{"field", "views"}}}}},
        {"tag_terms", {{"terms", {{"field", "tags"}}}}}
    }}
};

auto aggResult = client.search("articles", aggQuery.dump());
if (aggResult.status() == 200) {
    json body = json::parse(aggResult.body());
    std::cout << "औसत व्यू: " << body["aggregations"]["avg_views"]["value"] << std::endl;
}

बल्क ऑपरेशंस

एक साथ कई डॉक्यूमेंट इंडेक्स करें:

std::string bulkData;
json doc1 = {{"title", "पहला लेख"}, {"content", "यह पहला लेख है"}};
json doc2 = {{"title", "दूसरा लेख"}, {"content", "यह दूसरा लेख है"}};

bulkData += R"({"index": {"_index": "articles", "_id": "2"}})" + "\n";
bulkData += doc1.dump() + "\n";
bulkData += R"({"index": {"_index": "articles", "_id": "3"}})" + "\n";
bulkData += doc2.dump() + "\n";

auto bulkResult = client.bulk(bulkData);
if (bulkResult.status() == 200) {
    std::cout << "बल्क ऑपरेशन सफल!" << std::endl;
}

निष्कर्ष

elasticlient C++ डेवलपर्स के लिए Elasticsearch के साथ काम करने का एक सरल और प्रभावी तरीका प्रदान करता है। इसकी आधुनिक API, आसान इंस्टॉलेशन और सभी मुख्य फीचर्स का समर्थन इसे नेटिव एप्लिकेशन और सर्वर-साइड सिस्टम के लिए एक बेहतरीन विकल्प बनाता है। अधिक जानकारी के लिए आधिकारिक दस्तावेज़ देखें या GitHub पर प्रोजेक्ट विज़िट करें।