阿里havenask之indexlib

已于 2023-08-13 11:34:31 修改
阅读量1.2k 收藏 2
点赞数 2
文章标签： 数据库 c++ 数据结构
于 2023-05-19 15:54:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyg_031113/article/details/130767735
版权

GitHub - alibaba/havenask

havenask/aios/indexlib at main · alibaba/havenask · GitHub

indexlib是其中核心的索引库。本文将用脑图详解其设计。

倒排索引：context-->docid
正排索引：docid-->(Attribute/Schema)
KV索引：  key-->value

测试用例

#include "gtest/gtest.h"
#include <chrono>
#include "autil/legacy/any_jsonizable.h"
#include "glog/logging.h"
#include "autil/legacy/jsonizable.h"
#include "config/index_partition_schema.h"
#include "index_base/schema_adapter.h"
#include "storage/file_system_wrapper.h"
#include "document/raw_document.h"
#include "document/raw_document/default_raw_document.h"
#include "document/extend_document/indexlib_extend_document.h"
#include "document/index_document/normal_document/index_document.h"
#include "document/index_document/normal_document/normal_document.h"
#include "document/index_document/normal_document/attribute_document.h"
#include "document/index_document/normal_document/summary_document.h"
#include "document/document_factory_wrapper.h"
#include "document/document_parser.h"
#include "document/document_parser/normal_parser/normal_document_parser.h"
#include "config/field_schema.h"
#include "partition/index_builder.h"
#include "util/memory_control/quota_control.h"
#include "util/memory_control/memory_quota_controller.h"
#include "partition/online_partition.h"
#include "util/term.h"
#include "partition/index_partition_reader.h"
#include "index/normal/summary/summary_reader.h"
#include "document/index_document/normal_document/search_summary_document.h"
#include "alog/Configurator.h"
static alog::Logger *_logger;
namespace ajson = autil::legacy;
class MySchema : public autil::legacy::Jsonizable
{
public:
    
    void Jsonize(autil::legacy::Jsonizable::JsonWrapper& json) override
    {
        json.Jsonize("name", name);
        json.Jsonize("age", age); 
    }
    void Print(){
        LOG(INFO) << "name is: " << name << " age: " << age;
    }
private:
    std::string name;
    int age;
};
TEST(TestBuilder, test_json) {
    alog::Configurator::configureLogger("./logger.conf");
    _logger = alog::Logger::getRootLogger();
    // IE_ROOT_LOG_SETLEVEL(DEBUG);
    LOG(INFO) << "test json...";
    std::string raw_json = R"(
    {
        "name" : "hello",
        "age" : 3
    }
    )";
    LOG(INFO) << "raw json: " <<  raw_json;
    MySchema ms;
    autil::legacy::FromJsonString(ms, raw_json);
    ms.Print();
    // LOG(INFO) << ms;
}
static std::string GetSchema() {
    std::string mJsonStringHead = R"(
    {
        "table_name": "mainse_summary",
        "table_type": "normal",
        "fields": [
            { "field_name": "quantity", "field_type": "INTEGER" },
            { "field_name": "provcity", "compress_type": "uniq|equal", "field_type": "STRING" },
            { "field_name": "category", "field_type": "INTEGER" },
            { "field_name": "nid", "field_type": "STRING" },
            { "field_name": "zk_time", "field_type": "STRING" },
            { "field_name": "title", "field_type": "STRING" },
            { "field_name": "user", "field_type": "STRING" },
            { "field_name": "user_id", "field_type": "STRING" },
            { "field_name": "vip", "field_type": "STRING" },
            { "field_name": "ends", "field_type": "STRING" },
            { "field_name": "pid", "field_type": "STRING" },
            { "field_name": "nick", "field_type": "STRING" },
            { "field_name":"int32_multi", "field_type":"int32", "multi_value": true}
        ],
        "indexs": [
            {
                "index_fields": "nid",
                "index_name": "pk",
                "index_type": "PRIMARYKEY64",
                "pk_hash_type": "default_hash",
                "pk_storage_type": "hash_table"
            }
        ],
        "attributes" : [
            {
                "pack_name" : "pack_attr",
                "sub_attributes" : ["category", "int32_multi"]
            },
            {
                "pack_name" : "uniq_pack_attr",
                "sub_attributes" : ["nick", "pid"],
                "compress_type" : "uniq"
            },
            "quantity", "provcity", "vip"
        ],
    )";
    std::string mJsonStringTail = R"(
    }
    )";

    std::string jsonString = mJsonStringHead + R"(
        "summarys": {
            "summary_fields": [ "nid", "title", "pid", "provcity", "category" ]
        }
        )" + mJsonStringTail;
    return jsonString;
}
static indexlib::config::IndexPartitionSchemaPtr global_schema;
TEST(TestBuilder, load_schema) {
    LOG(INFO) << "test load schema";
    std::string schema_json = GetSchema();
    LOG(INFO) << schema_json;
    //1
    indexlib::config::IndexPartitionSchemaPtr schema(new indexlib::config::IndexPartitionSchema("myschema"));
    FromJsonString(*schema, schema_json);
    //2
    ASSERT_NO_THROW(indexlib::index_base::SchemaAdapter::LoadSchema(schema_json, schema));
    //3
    indexlib::storage::FileSystemWrapper::Delete("/tmp/myschema.json", true);
    indexlib::storage::FileSystemWrapper::AtomicStore("/tmp/myschema.json", schema_json);
    schema = indexlib::index_base::SchemaAdapter::LoadSchema("/tmp", "myschema.json");
    ASSERT_TRUE(schema);

    //schema field
    LOG(INFO) << "field count:" << schema->GetFieldSchema()->GetFieldCount();
    LOG(INFO) << "index count:" << schema->GetIndexSchema()->GetIndexCount();
    // LOG(INFO) << "index count:" << schema->GetSummarySchema()->GetSummaryCount();
    LOG(INFO) << "attr count:" << schema->GetAttributeSchema()->GetAttributeCount();
    auto attr_schema = schema->GetAttributeSchema();
    for(int i = 0; i < attr_schema->GetAttributeCount(); i++) {
        LOG(INFO) << "attr name: " << attr_schema->GetAttributeConfig(i)->GetAttrName()
                  << " id: " << attr_schema->GetAttributeConfig(i)->GetAttrId();
    }
    for(int i = 0; i < attr_schema->GetPackAttributeCount(); i++) {
        LOG(INFO) << "pack attr: " << attr_schema->GetPackAttributeConfig(i)->GetAttrName();
        std::vector<std::string> attrNames;
        attr_schema->GetPackAttributeConfig(i)->GetSubAttributeNames(attrNames);
        for(auto &sub: attrNames) {
            LOG(INFO) << "sub name: " << sub;
        }
    }
    auto summary_schema = schema->GetSummarySchema();
    // LOG(INFO) << "compress: " << summary_schema->GetSummaryConfig("quantity")->GetFieldConfig()->GetCompressType().GetCompressStr();
    // for(int i = 0; i < summary_schema->GetSummaryGroupConfigCount(); i++) {
    //     auto group = summary_schema->GetSummaryGroupConfig(i);
    //     LOG(INFO) << "summary group: " << group->GetGroupName()
    //               << " compress_type: " << group->GetCompressType()
    //               << " filed_count: " << group->GetSummaryFieldsCount();
    // }
    global_schema = schema;

}

static indexlib::document::RawDocumentPtr ParseDocStr(const std::string& docStr)
{
    const std::string DP_SPATIAL_KEY_VALUE_SEPARATOR = "|";
    const std::string DP_KEY_VALUE_SEPARATOR        = ",";
    const std::string DP_KEY_VALUE_EQUAL_SYMBOL     = "=";
    const std::string DP_CMD_SEPARATOR              = ";";
    const std::string DP_TOKEN_SEPARATOR            = " ";
    const char   DP_MULTI_VALUE_SEPARATOR      = ' ';
    const std::string DP_MAIN_JOIN_FIELD = "main_join";
    const std::string DP_SUB_JOIN_FIELD = "sub_join";
    std::vector<std::string> keyValues = autil::StringUtil::split(docStr, DP_SPATIAL_KEY_VALUE_SEPARATOR);
    if (keyValues.size() <= 1)
    {
        keyValues = autil::StringUtil::split(docStr, DP_KEY_VALUE_SEPARATOR);
    }

    indexlib::document::RawDocumentPtr rawDoc(new indexlib::document::DefaultRawDocument);
    for (size_t i = 0; i < keyValues.size(); ++i)
    {
        std::vector<std::string> keyValue = autil::StringUtil::split(keyValues[i], 
                DP_KEY_VALUE_EQUAL_SYMBOL);

        std::string key = keyValue[0];
        autil::StringUtil::trim(key);

        std::string value;
        if(keyValue.size() == 2)
        {
            value = keyValue[1];
            autil::StringUtil::trim(value);
        }
        rawDoc->setField(key, value);
    }
    return rawDoc;
}
static int64_t GetTsMirco() {
    return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
}
static indexlib::document::DocumentPtr global_doc;
TEST(TestBuilder, CreateDoc){
    std::string doc_str1 =
    "cmd=add,quantity=10,provcity=shanghai,category=1,nid=123,zk_time=1684305956,title=hello1,user=huozai,user_id=98765,vip=svip,ends=some_ends,pid=203,nick=world,int32_multi=2 3;";
    std::string doc_str2 =
    "cmd=add,quantity=11,provcity=shanghaj,category=2,nid=124,zk_time=1684305957,title=hello2,user=huozaj,user_id=98766,vip=tvip,ends=some_fnds,pid=204,nick=worle,int32_multi=4 5;";
    std::string doc_str3 =
    "cmd=add,quantity=12,provcity=shanghak,category=3,nid=125,zk_time=1684305958,title=hello3,user=huozak,user_id=98767,vip=ivip,ends=some_gnds,pid=205,nick=worlf,int32_multi=6 7;";
    //1 from doc str to raw doc
    auto raw_doc = ParseDocStr(doc_str1);
    ASSERT_TRUE(raw_doc);
    raw_doc->setDocTimestamp(GetTsMirco());
    LOG(INFO) << raw_doc->toString();
    raw_doc->SetTimestamp(GetTsMirco());
    raw_doc->setField("__ts__", std::to_string(raw_doc->GetTimestamp()/1000000 + 10000000));
    raw_doc->setDocTimestamp(raw_doc->GetTimestamp());


    //2 build normal doc
    indexlib::document::IndexlibExtendDocumentPtr extend_doc(new indexlib::document::IndexlibExtendDocument());
    extend_doc->setRawDocument(raw_doc);
    auto classified_doc = extend_doc->getClassifiedDocument();
    LOG(INFO) << "classifiedDoc: pk: " << classified_doc->getPrimaryKey();
    LOG(INFO) << "classifiedDoc: index: " << classified_doc->getIndexDocument()->GetPrimaryKey();
    LOG(INFO) << "classifiedDoc: attr packfield count: " << classified_doc->getAttributeDoc()->GetPackFieldCount();
    LOG(INFO) << "classifiedDoc: summary nonempty count: " << classified_doc->getSummaryDoc()->GetNotEmptyFieldCount();
    LOG(INFO) << "raw doc type: " << raw_doc->getDocOperateType();
    std::string schema_json = GetSchema();
    indexlib::config::IndexPartitionSchemaPtr schema(new indexlib::config::IndexPartitionSchema("myschema"));
    FromJsonString(*schema, schema_json);
    // schema->SetDefaultTTL(1000000); //TTL
    // schema->SetEnableTTL(true, DEFAULT_REGIONID, "__ts__");
    indexlib::document::DocumentFactoryWrapper wrapper(schema);
    wrapper.Init();
    indexlib::document::DocumentParserPtr parser(wrapper.CreateDocumentParser());
    auto normal_doc_parser = dynamic_cast<indexlib::document::NormalDocumentParser*>(parser.get());
    ASSERT_TRUE(normal_doc_parser != nullptr);
    indexlib::document::DocumentPtr doc = parser->Parse(extend_doc);
    ASSERT_TRUE(doc);
    indexlib::document::NormalDocumentPtr normal_doc = DYNAMIC_POINTER_CAST( indexlib::document::NormalDocument, doc);
    ASSERT_TRUE(normal_doc);
    global_doc = doc;
}

TEST(TestBuilder, TestOfflineBuilder){
    LOG(INFO) << "-----------------------begin offline---------------------";
    ASSERT_TRUE(global_schema);
    ASSERT_TRUE(global_doc);
    indexlib::config::IndexPartitionOptionsPtr options(new indexlib::config::IndexPartitionOptions);
    options->SetIsOnline(false);
    std::string mergeConfigStr = "{\"class_name\":\"default\",\"parameters\":{\"split_num\":\"1\"}}";
    autil::legacy::FromJsonString(options->GetMergeConfig().GetSplitSegmentConfig(), mergeConfigStr);
    auto& buildConfig = options->GetBuildConfig();
    buildConfig.enablePackageFile = false;
    buildConfig.maxDocCount = 1024;
    buildConfig.ttl = 1000000;
    indexlib::util::QuotaControlPtr memoryQuotaControl(new indexlib::util::QuotaControl(1024*1024*100));
    // indexlib::storage::FileSystemWrapper::DeleteDir("./tdata/builder");
    indexlib::partition::IndexBuilderPtr builder(new indexlib::partition::IndexBuilder("./tdata/builder", *options, global_schema, memoryQuotaControl));
    ASSERT_TRUE(builder->Init());
    for(int i = 0; i < 1000; i++) {
        ASSERT_TRUE(builder->Build(global_doc));
    }
    ASSERT_TRUE(builder->Merge(*options));
    builder->EndIndex();
}

TEST(TestBuilder, TestOnlineBuild){
    LOG(INFO) << "-----------------------begin online---------------------";
    ASSERT_TRUE(global_schema);
    ASSERT_TRUE(global_doc);
    indexlib::config::IndexPartitionOptionsPtr options(new indexlib::config::IndexPartitionOptions);
    options->SetIsOnline(true);
    std::string mergeConfigStr = "{\"class_name\":\"default\",\"parameters\":{\"split_num\":\"1\"}}";
    autil::legacy::FromJsonString(options->GetMergeConfig().GetSplitSegmentConfig(), mergeConfigStr);
    auto& buildConfig = options->GetBuildConfig();
    buildConfig.enablePackageFile = false;
    buildConfig.maxDocCount = 1024;
    buildConfig.ttl = 1000000;
    indexlib::util::MemoryQuotaControllerPtr quotaControl(new indexlib::util::MemoryQuotaController(100*1024*1024));
    indexlib::partition::OnlinePartitionPtr part(new indexlib::partition::OnlinePartition("online", quotaControl));
    options->GetOnlineConfig().onDiskFlushRealtimeIndex = true;
    options->GetOnlineConfig().maxRealtimeDumpInterval = 10000;
    options->GetOnlineConfig().maxRealtimeMemSize = 100*1024*1024;
    auto rs =  part->Open("./tdata/builder", "", global_schema, *options);
    ASSERT_EQ(rs,  indexlib::partition::IndexPartition::OS_OK);
   
    //todo  use IndexPartitionCreator::Create create partition
    indexlib::util::QuotaControlPtr memoryQuotaControlOnline(new indexlib::util::QuotaControl(100*1024*1024));
    indexlib::partition::IndexBuilderPtr online_builder(new indexlib::partition::IndexBuilder(part, memoryQuotaControlOnline));
    ASSERT_TRUE(online_builder->Init());

    //online add doc
    for(int i = 0; i < 100; i++) {
        ASSERT_TRUE(online_builder->Build(global_doc));
    }
    online_builder->EndIndex();
    LOG(INFO) << "online add doc ok";
    //query
    auto partReader = part->GetReader();
    ASSERT_TRUE(partReader);
    auto indexReader = partReader->GetIndexReader();
    ASSERT_TRUE(indexReader);
    indexlib::util::Term t("123", "pk");
    auto ite = indexReader->Lookup(t);
    ASSERT_TRUE(ite != nullptr);
    auto docid = ite->SeekDoc(INVALID_DOCID);
    LOG(INFO) << "type: " << ite->GetMatchValueType() << " dockid: " << docid;
    LOG(INFO) << "enable: " << _logger->isLevelEnabled(alog::LOG_LEVEL_INFO);
    IE_LOG(ERROR, "hello ie log");
    ALOG_ERROR(_logger, "hello :%s", "world");
    auto summaryReader = partReader->GetSummaryReader();
    ASSERT_TRUE(summaryReader != nullptr);
    indexlib::document::SearchSummaryDocument summaryDoc(NULL, 40960);
    ASSERT_TRUE(summaryReader->GetDocument(docid, &summaryDoc));
    int count = 3;
    LOG(INFO) << "field count: " << count;
    for(int i = 0; i < count; i++) {
        const autil::ConstString* field = summaryDoc.GetFieldValue(i);
        ASSERT_TRUE(field != nullptr);
        LOG(INFO) << "value is: " << *field;
    }
    
}

LOG配置

logger.conf

alog.rootLogger=INFO, indexlibAppender
alog.max_msg_len=2000000
alog.appender.indexlibAppender=ConsoleAppender
#alog.appender.indexlibAppender=FileAppender
#alog.appender.indexlibAppender.fileName=TestLog.log
alog.appender.indexlibAppender.flush=true
alog.appender.indexlibAppender.layout=PatternLayout
#alog.appender.indexlibAppender.layout.LogPattern=[%%d] [%%t], %%f() [%%n] [%%l] [%%m]
alog.appender.indexlibAppender.layout.LogPattern=[%%h][xxxx][%%d][%%l][%%t][%%p][%%F:%%n %%f] : [%%m]

alog.logger.indexlib=INFO
inherit.indexlib.test=false
alog.logger.local.LocalFileSystem=INFO

alog.logger.ErrorLogCollector=TRACE1,ErrorLogCollectorAppender
inherit.ErrorLogCollector=false
alog.appender.ErrorLogCollectorAppender=FileAppender
alog.appender.ErrorLogCollectorAppender.fileName=error_log_collector.log
alog.appender.ErrorLogCollectorAppender.flush=true
alog.appender.ErrorLogCollectorAppender.max_file_size=100
alog.appender.ErrorLogCollectorAppender.layout=PatternLayout
alog.appender.ErrorLogCollectorAppender.layout.LogPattern=[%%h][xxxx][%%d][%%l][%%t][%%p][%%F:%%n %%f] : [%%m]
alog.appender.ErrorLogCollectorAppender.compress=true
alog.appender.ErrorLogCollectorAppender.log_keep_count=100

# alog.logger.indexlib.test=INFO, indexlibTestAppender
# alog.appender.indexlibTestAppender=ConsoleAppender
# alog.appender.indexlibTestAppender.layout=PatternLayout
# alog.appender.indexlibTestAppender.layout.LogPattern=[%%d] [%%t/%%p,PSM:%%f():%%n] [%%m]
# inherit.indexlib.test=false

生成数据在磁盘的结构

├── deploy_meta.0
├── deploy_meta.1
├── index_format_version
├── __indexlib_fs_root_link__@1684478171 -> ./tdata/builder
├── join_index_partition
├── merge_resource
│   └── version.1
├── rt_index_partition
│   ├── segment_1073741824_level_0
│   │   ├── attribute
│   │   │   ├── pack_attr
│   │   │   │   ├── data
│   │   │   │   ├── data_info
│   │   │   │   └── offset
│   │   │   ├── provcity
│   │   │   │   ├── data
│   │   │   │   ├── data_info
│   │   │   │   └── offset
│   │   │   ├── quantity
│   │   │   │   └── data
│   │   │   ├── uniq_pack_attr
│   │   │   │   ├── data
│   │   │   │   ├── data_info
│   │   │   │   └── offset
│   │   │   └── vip
│   │   │       ├── data
│   │   │       ├── data_info
│   │   │       └── offset
│   │   ├── counter
│   │   ├── deletionmap
│   │   │   └── data_1073741824
│   │   ├── deploy_index
│   │   ├── index
│   │   │   ├── pk
│   │   │   │   └── data
│   │   │   └── virtual_timestamp_index
│   │   │       ├── dictionary
│   │   │       ├── index_format_option
│   │   │       └── posting
│   │   ├── operation_log
│   │   │   ├── data
│   │   │   └── meta
│   │   ├── segment_file_list
│   │   ├── segment_info
│   │   ├── segment_metrics
│   │   └── summary
│   │       ├── data
│   │       └── offset
│   └── version.0
├── schema.json
├── segment_0_level_0
│   ├── attribute
│   │   ├── pack_attr
│   │   │   ├── data
│   │   │   ├── data_info
│   │   │   └── offset
│   │   ├── provcity
│   │   │   ├── data
│   │   │   ├── data_info
│   │   │   └── offset
│   │   ├── quantity
│   │   │   └── data
│   │   ├── uniq_pack_attr
│   │   │   ├── data
│   │   │   ├── data_info
│   │   │   └── offset
│   │   └── vip
│   │       ├── data
│   │       ├── data_info
│   │       └── offset
│   ├── counter
│   ├── deletionmap
│   │   └── data_0
│   ├── deploy_index
│   ├── index
│   │   └── pk
│   │       └── data
│   ├── segment_file_list
│   ├── segment_info
│   ├── segment_metrics
│   └── summary
│       ├── data
│       └── offset
├── segment_1_level_0
│   ├── attribute
│   │   ├── pack_attr
│   │   │   ├── category
│   │   │   ├── data
│   │   │   ├── data_info
│   │   │   ├── int32_multi
│   │   │   └── offset
│   │   ├── provcity
│   │   │   ├── data
│   │   │   ├── data_info
│   │   │   └── offset
│   │   ├── quantity
│   │   │   └── data
│   │   ├── uniq_pack_attr
│   │   │   ├── data
│   │   │   ├── data_info
│   │   │   └── offset
│   │   └── vip
│   │       ├── data
│   │       ├── data_info
│   │       └── offset
│   ├── counter
│   ├── deletionmap
│   ├── deploy_index
│   ├── index
│   │   └── pk
│   │       └── data
│   ├── segment_file_list
│   ├── segment_info
│   ├── segment_metrics
│   └── summary
│       ├── data
│       └── offset
├── summary_info
│   ├── index_summary.0
│   └── index_summary.1
├── version.0
└── version.1

分层架构

脑图详解 

wyg_031113
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
10 年磨一剑，阿里开源自研搜索引擎 Havenask！
csdn_te_blog_001的博客
12-15 117
信息化时代，搜索引擎是很多兵家必争之地。这一场的角逐也从传统的互联网领域逐渐拓展到了分布式系统之上。近日，阿里重磅开源了自研的搜索引擎 Havenask（），它也在今年双 11 活动中大展身手，支持了淘宝、天猫、菜鸟、优酷在内整个阿里的搜索业务，旨在为用户提供高性能、低成本、易用的搜索服务。在功能性方面，Havenask 具有灵活的定制和开发能力，支持算法快速迭代，能够帮助开发者量身定做适合自身业务的智能搜索服务，助力业务增长。
HA3搜索引擎梳理与分析
Path
06-13 4438
HA3搜索引擎梳理与分析 一、HA3技术体系梳理 HA3搜索引擎技术体系图 1.1 内核 网络访问存储：通过网络访问盘古系统（集中式存储）实现存储与计算分离，支持独立扩展，降低运维成本，提高稳定性 热数据cache：支持使用mmap（lock/非lock方式）、blockcache对数据进行加载，实现对热数据的memcache 自适应bitmap：支持根据检索热度自动将部分token转换为b...
Havenask 分布式索引构建服务 --Build Service
阿里技术
12-27 1404
Havenask 是阿里巴巴广泛使用的自研大规模分布式检索系统，是过去十多年阿里在电商领域积累下来的核心竞争力产品，广泛应用在搜推广和大数据检索等典型场景，在 2022 年云栖大会-云计算加速开源创新论坛上完成开源首发，同时作为阿里云开放搜索 OpenSearch 底层搜索引擎，OpenSearch 自 2014 年商业化，目前已有千余家外部客户。下图展示了 Havenask 中一个完整的搜索服务：在线系统、索引系统、管控系统、扩展插件，且包括了查询流、数据流、控制流。
阿里开源自研高性能核心搜索引擎 Havenask
阿里技术
03-02 1258
Havenask 是过去十多年阿里在电商领域积累下来的核心竞争力产品。
【一文读懂】基于 Havenask 向量检索 + 大模型，构建可靠的智能问答服务
阿里技术
03-13 1271
Havenask 是阿里巴巴广泛使用的自研大规模分布式检索系统，是过去十多年阿里在电商领域积累下来的核心竞争力产品，广泛应用在搜推广和大数据检索等典型场景。在 2022 年云栖大会-云计算加速开源创新论坛上完成开源首发，同时作为阿里云开放搜索 OpenSearch 底层搜索引擎，OpenSearch 自 2014 年商业化，目前已有千余家外部客户。Havenask 通过深度集成 proxima 向量库，以 Havenask 中的一种索引类型的方式支持向量检索。
15年技术沉淀，起底阿里核心搜索引擎 Havenask 演进之路
CSDN资讯
10-23 1万+
15年技术沉淀，起底阿里核心搜索引擎 Havenask 演进之路
Docker之自定义镜像上传至阿里云
04-13
Docker之自定义镜像上传至阿里云
技术之瞳-阿里
08-13
这是在阿里的师兄给我的一份电子版的技术之瞳
揭秘阿里自研搜索引擎 Havenask 在线检索服务
阿里技术
01-09 1700
Havenask 是阿里巴巴广泛使用的自研大规模分布式检索系统，是过去十多年阿里在电商领域积累下来的核心竞争力产品，广泛应用在搜推广和大数据检索等典型场景。在 2022 年云栖大会-云计算加速开源创新论坛上完成开源首发，同时作为阿里云开放搜索 OpenSearch 底层搜索引擎，OpenSearch 自 2014 年商业化，目前已有千余家外部客户。下图展示了 Havenask 中一个完整的搜索服务：在线系统、索引系统、管控系统、扩展插件，且包括了查询流、数据流、控制流。
【前沿技术】 阿里开源搜索引擎 Havenask 的消息系统
阿里技术
02-22 1131
Havenask 是阿里巴巴广泛使用的自研大规模分布式检索系统，是过去十多年阿里在电商领域积累下来的核心竞争力产品，广泛应用在搜推广和大数据检索等典型场景。在 2022 年云栖大会-云计算加速开源创新论坛上完成开源首发，同时作为阿里云开放搜索 OpenSearch 底层搜索引擎，OpenSearch 自 2014 年商业化，目前已有千余家外部客户。下图展示了 Havenask 中一个完整的搜索服务：在线系统、索引系统、管控系统、扩展插件，且包括了查询流、数据流、控制流。
HA3 SQL样本实验：一种混合计算查询的全新样本解决方案
阿里技术
08-09 2511
HA3（对外开源代号：Havenask ）是阿里智能引擎团队自研的大规模分布式检索系统，广泛应用于阿里内部的搜索业务，是十多年来阿里在电商领域积累下来的核心竞争力产品。Ha3 SQL 是在原有Ha3引擎基础上，新增的SQL查询功能，引擎内置了SQL形式的的查询语法，允许用户通过写SQL语句来构造引擎查询。
阿里巴巴10个顶级开源项目，确定不来看看？
m0_50180963的博客
10-21 1765
一、创作由来 Hello 大家好，我是l拉不拉米，今天给大家分享10个阿里巴巴开源的顶级项目，都是Java开发必备利器。 这10个项目均来自Github上阿里巴巴公开的开源项目。 都是java3c在工作中用过或者之前学习过的项目，也有写过个别项目的文章，但是从没有整理到一起过。周末花了大概半天的时间，一一整理出来，方便大家阅读学习。 阿里巴巴的github地址 二、项目介绍 1、arthas 截至目前，github上有27.4k个星和6k的fork，是阿里巴巴最受欢迎的开源项目。 Art
iGraph架构演进之三战
weixin_34307464的博客
03-16 1426
前言 iGraph是搜索事业部工程团队打造的实时在线图存储与查询的系统，提供大规模图数据的存储、查询、更新和计算服务，目前承载了集团多个部门5000+表的数据，双11期间proxy入口峰值流量1106w qps、实时数据峰值更新506w qps，是名副其实的在线数据航空母舰。 在过去2年多的时间里面，iGraph架构经历了3次大的演进，分别是： (1)...
揭秘阿里中台！一文看懂阿里推荐业务的两大利器
勇往直前的专栏
08-04 1074
从工程的角度看，搜索和推荐既有差异点，又有共同点。阿里巴巴集团的搜索和推荐系统由同一个部门研发，因此很多工程能力是复用的，如搜索和推荐业务的算分服务引擎都是RS/RTP。 本文介绍阿里巴巴推荐的中台产品—BE召回引擎和RTP算分服务，这是阿里巴巴推荐业务的两项利器。 召回引擎BE BE（Basic Engine）是基于阿里巴巴集团另一个更底层的框架服务Suez构建的。在Suez框架服务的基础上，BE实现了与推荐业务相关的各种功能组件，如向量召回技术、多表join召回，以及以自定义插件形式提供..
阿里云、Elastic联合举办Elasticsearch 自研引擎年度发布
SupeerDons的博客
02-25 112
阿里云、Elastic联合举办Elasticsearch 自研引擎年度发布，阿里云高级专家揭秘自研ES日志引擎核心技术，还可免费体验全新功能， 点击观看： 阿里云Elasticsearch 自研引擎年度发布-云视频-阿里云开发者社区https://developer.aliyun.com/live/248284?utm_content=g_1000325588 ...
揭秘阿里中台！一文看懂阿里推荐业务的两项利器 | 赠书
CSDN资讯
07-29 3699
从工程的角度看，搜索和推荐既有差异点，又有共同点。阿里巴巴集团的搜索和推荐系统由同一个部门研发，因此很多工程能力是复用的，如搜索和推荐业务的算分服务引擎都是RS/RTP。本文介绍阿里巴巴...
五十款阿里开源软件说明介绍
热门推荐
纸上得来终觉浅，绝知此事要躬行
02-13 3万+
通过写这篇文章从开源中国站上面看了很多，也从那里将开源软件的基本的介绍和下载地址拷贝到了文章当中，总体给我的一个感受就是阿里的开源实在太强大了，多到需要花大量的时间去了解。今天写这篇文章主要是对阿里开源的项目比较陌生，通过本文也有了一个大体的认知。每个人每天有24小时，但是大部分时间我们并不能集中精力学习做事，而时间对于我们而言都是很宝贵的，原因就是人的精力是有限的，不能像机器一样学习和频繁地机械运动。惰性乃人之常情，如果不写此文我想我明天可能就会忘记阿里的这一堆东东，让他们掉入头脑的“黑洞”，为拯救记忆和
一文详解：面向多级多模态场景的召回引擎
阿里文娱技术
06-24 611
优酷的多级多模态搜索引擎（MMS）提供了低延迟的跨模态、跨层级搜索能力，支持大规模多模态的索引。在视频分发、视频创作中都有着十分关键的应用场景。MMS技术在更多的智能交互场景也将发挥更广泛的应用场景。
Apollo使用（3）：分布式docker部署
最新发布
游王子的博客
07-24 597
Apollo 1.7.0版本开始会默认上传Docker镜像到，可以按照如下步骤获取。
阿里巴巴大数据实践之路
03-06
作为一个 AI 语言模型，我可以回答阿里巴巴大数据实践之路的相关问题。阿里巴巴在大数据领域积累了丰富的经验，通过构建数据中台，实现了数据的全流程管理和价值挖掘。同时，阿里巴巴还通过人工智能技术，推动了智能化的数据分析和应用，为企业提供了更加精准的决策支持和业务优化。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值