集合别名

在 v1.32 中添加

集合别名允许您为集合创建替代名称。这对于在不中断服务的情况下迁移集合、进行 A/B 测试或为集合提供更方便的名称非常有用。别名充当对集合的引用 - 当您使用别名查询和管理对象时，Weaviate 会自动将请求路由到目标集合。

集合别名的使用

Weaviate 会自动将别名请求路由到目标集合，用于对象相关操作。您可以在任何需要集合名称的地方使用别名，例如：

• 管理对象：通过集合别名创建、批量导入、读取、更新和删除对象。
• 查询对象：通过别名获取对象并执行搜索（向量、关键词、混合、图像、生成式/RAG）和聚合。

创建别名

要创建别名，请指定别名名称和它应指向的目标集合。

PythonJavaScript/TypeScriptGoJava v6Java v5 (已弃用)C#

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

# Create a collection first
client.collections.create(
    name="Articles",
    vector_config=wvc.config.Configure.Vectors.self_provided(),
    properties=[
        wvc.config.Property(name="title", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="content", data_type=wvc.config.DataType.TEXT),
    ],
)

# Create an alias pointing to the collection
client.alias.create(alias_name="ArticlesAlias", target_collection="Articles")

// Create a collection first
await client.collections.create({
    name: "Articles",
    vectorizers: weaviate.configure.vectors.selfProvided(),
    properties: [
        { name: "title", dataType: weaviate.configure.dataType.TEXT },
        { name: "content", dataType: weaviate.configure.dataType.TEXT },
    ],
})

console.log('Created collection "Articles"')
// Create an alias pointing to the collection
await client.alias.create({
    alias: "ArticlesAlias",
    collection: "Articles"
})

console.log('Created alias "ArticlesAlias"')

// Create a collection first
err := client.Schema().ClassCreator().WithClass(&models.Class{
  Class:      "Articles",
  Vectorizer: "none",
  Properties: []*models.Property{
  	{Name: "title", DataType: schema.DataTypeText.PropString()},
  	{Name: "content", DataType: schema.DataTypeText.PropString()},
  },
}).Do(ctx)

require.NoError(t, err)

// Create an alias pointing to the collection
err = client.Alias().AliasCreator().WithAlias(&alias.Alias{
  Alias: "ArticlesProd",
  Class: "Articles",
}).Do(ctx)

// Create a collection first
client.collections.create("Articles", col -> col.vectorConfig(VectorConfig.selfProvided())
    .properties(Property.text("title"), Property.text("content")));

// Create an alias pointing to the collection
client.alias.create("Articles", "ArticlesAlias");

// Create a collection first
WeaviateClass articlesClass = WeaviateClass.builder()
    .className("Articles")
    .properties(Arrays.asList(
        Property.builder()
            .name("title")
            .dataType(Arrays.asList(DataType.TEXT))
            .build(),
        Property.builder()
            .name("content")
            .dataType(Arrays.asList(DataType.TEXT))
            .build()))
    .build();

Result<Boolean> createResult = client.schema().classCreator()
    .withClass(articlesClass)
    .run();

// Create an alias pointing to the collection
Result<Boolean> aliasResult = client.alias().creator()
    .withClassName("Articles")
    .withAlias("ArticlesProd")
    .run();

// Create a collection first
await client.Collections.Create(
    new CollectionCreateParams
    {
        Name = Articles,
        VectorConfig = Configure.Vector("default", v => v.SelfProvided()),
        Properties = [Property.Text("title"), Property.Text("content")],
    }
);

// Create an alias pointing to the collection
await client.Alias.Create(ArticlesAlias, Articles);

注意

• 别名名称必须唯一，并且不能与任何现有的集合或别名名称匹配
• 多个别名可以指向同一个集合
• 别名只能在与对象相关的操作（管理对象和查询）中代替集合名称使用

列出所有别名

检索您的 Weaviate 实例中的所有别名。

PythonJavaScript/TypeScriptGoJava v6Java v5 (已弃用)C#

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

# Get all aliases in the instance
all_aliases = client.alias.list_all()

for alias_name, alias_info in all_aliases.items():
    print(f"Alias: {alias_info.alias} -> Collection: {alias_info.collection}")

// Get all aliases in the instance
const allAliases = await client.alias.listAll()

if (allAliases) {
    for (const [_, aliasInfo] of Object.entries(allAliases)) {
        console.log(`Alias: ${aliasInfo.alias} -> Collection: ${aliasInfo.collection}`);
    }
}

// Get all aliases in the instance
allAliases, err := client.Alias().Getter().Do(ctx)

require.NoError(t, err)

// Filter to show only aliases from this example
for _, aliasInfo := range allAliases {
  if aliasInfo.Class == "Articles" || aliasInfo.Class == "ArticlesV2" {
  	fmt.Printf("Alias: %s -> Collection: %s\n", aliasInfo.Alias, aliasInfo.Class)
  }
}

// Get all aliases in the instance
List<Alias> allAliases = client.alias.list();

for (Alias aliasInfo : allAliases) {
  System.out.printf("Alias: %s -> Collection: %s\n", aliasInfo.alias(), aliasInfo.collection());
}

// Get all aliases in the instance
Result<Map<String, Alias>> allAliasesResult = client.alias().allGetter().run();
Map<String, Alias> allAliases = allAliasesResult.getResult();

for (Map.Entry<String, Alias> entry : allAliases.entrySet()) {
  Alias aliasInfo = entry.getValue();
  System.out.println("Alias: " + aliasInfo.getAlias() +
      " -> Collection: " + aliasInfo.getClassName());
}

// Get all aliases in the instance
var allAliases = await client.Alias.List();

foreach (var entry in allAliases)
{
    Console.WriteLine($"Alias: {entry.Name} -> Collection: {entry.TargetCollection}");
}

列出特定集合的别名

获取指向特定集合的所有别名。

PythonJavaScript/TypeScriptGoJava v6Java v5 (已弃用)C#

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

# Get all aliases pointing to a specific collection
collection_aliases = client.alias.list_all(collection="Articles")

for alias_name, alias_info in collection_aliases.items():
    print(f"Alias pointing to Articles: {alias_info.alias}")

// Get all aliases pointing to a specific collection
const collectionAliases = await client.alias.listAll({ collection: "Articles" })

if (collectionAliases) {
    for (const [_, aliasInfo] of Object.entries(collectionAliases)) {
        console.log(`Alias pointing to Articles: ${aliasInfo.alias}`);
    }
}

// Get all aliases pointing to a specific collection
collectionAliases, err := client.Alias().Getter().WithClassName("Articles").Do(ctx)

require.NoError(t, err)

for _, aliasInfo := range collectionAliases {
  fmt.Printf("Alias pointing to Articles: %s\n", aliasInfo.Alias)
}

// Get all aliases pointing to a specific collection
List<Alias> collectionAliases = client.alias.list(a -> a.collection("Articles"));

for (Alias aliasInfo : collectionAliases) {
  System.out.printf("Alias pointing to Articles: %s\n", aliasInfo.alias());
}

// Get all aliases pointing to a specific collection
Result<Map<String, Alias>> collectionAliasesResult = client.alias()
    .allGetter()
    .withClassName("Articles")
    .run();
Map<String, Alias> collectionAliases = collectionAliasesResult.getResult();

for (Map.Entry<String, Alias> entry : collectionAliases.entrySet()) {
  Alias aliasInfo = entry.getValue();
  System.out.println("Alias pointing to Articles: " + aliasInfo.getAlias());
}

// Get all aliases pointing to a specific collection
var collectionAliases = await client.Alias.List(Articles);

foreach (var entry in collectionAliases)
{
    Console.WriteLine($"Alias pointing to Articles: {entry.Name}");
}

获取别名详细信息

检索有关特定别名的信息。

PythonJavaScript/TypeScriptGoJava v6Java v5 (已弃用)C#

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

# Get information about a specific alias
alias_info = client.alias.get(alias_name="ArticlesAlias")

if alias_info:
    print(f"Alias: {alias_info.alias}")
    print(f"Target collection: {alias_info.collection}")

// Get information about a specific alias
const aliasInfo = await client.alias.get("ArticlesAlias")

if (aliasInfo) {
    console.log(`Alias: ${aliasInfo.alias}`);
    console.log(`Target collection: ${aliasInfo.collection}`);
}

// Get information about a specific alias
aliasInfo, err := client.Alias().AliasGetter().WithAliasName("ArticlesProd").Do(ctx)

require.NoError(t, err)

if aliasInfo != nil {
  fmt.Printf("Alias: %s\n", aliasInfo.Alias)
  fmt.Printf("Target collection: %s\n", aliasInfo.Class)
}

// Get information about a specific alias
Optional<Alias> aliasInfoOpt = client.alias.get("ArticlesAlias");

aliasInfoOpt.ifPresent(aliasInfo -> {
  System.out.printf("Alias: %s\n", aliasInfo.alias());
  System.out.printf("Target collection: %s\n", aliasInfo.collection());
});

// Get information about a specific alias
Result<Alias> aliasInfoResult = client.alias()
    .getter()
    .withAlias("ArticlesProd")
    .run();

if (aliasInfoResult.getResult() != null) {
  Alias aliasInfo = aliasInfoResult.getResult();
  System.out.println("Alias: " + aliasInfo.getAlias());
  System.out.println("Target collection: " + aliasInfo.getClassName());
}

// Get information about a specific alias
var aliasInfo = await client.Alias.Get(aliasName: ArticlesAlias);

if (aliasInfo != null)
{
    Console.WriteLine($"Alias: {aliasInfo.Name}");
    Console.WriteLine($"Target collection: {aliasInfo.TargetCollection}");
}

更新别名

更改别名指向的目标集合。此操作是原子的，并提供集合之间即时切换。

PythonJavaScript/TypeScriptGoJava v6Java v5 (已弃用)C#

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

# Create a new collection for migration
client.collections.create(
    name="ArticlesV2",
    vector_config=wvc.config.Configure.Vectors.self_provided(),
    properties=[
        wvc.config.Property(name="title", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="content", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(
            name="author", data_type=wvc.config.DataType.TEXT
        ),  # New field
    ],
)

# Update the alias to point to the new collection
success = client.alias.update(
    alias_name="ArticlesAlias", new_target_collection="ArticlesV2"
)

if success:
    print("Alias updated successfully")

// Create a new collection for migration
await client.collections.create({
    name: "ArticlesV2",
    vectorizers: weaviate.configure.vectors.selfProvided(),
    properties: [
        { name: "title", dataType: weaviate.configure.dataType.TEXT },
        { name: "content", dataType: weaviate.configure.dataType.TEXT },
        { name: "author", dataType: weaviate.configure.dataType.TEXT },  // New field
    ],
})

// Update the alias to point to the new collection
await client.alias.update({
    alias: "ArticlesAlias",
    newTargetCollection: "ArticlesV2"
})

console.log("Alias updated successfully")

// Create a new collection for migration
err := client.Schema().ClassCreator().WithClass(&models.Class{
  Class:      "ArticlesV2",
  Vectorizer: "none",
  Properties: []*models.Property{
  	{Name: "title", DataType: schema.DataTypeText.PropString()},
  	{Name: "content", DataType: schema.DataTypeText.PropString()},
  	{Name: "author", DataType: schema.DataTypeText.PropString()}, // New field
  },
}).Do(ctx)

require.NoError(t, err)

// Update the alias to point to the new collection
err = client.Alias().AliasUpdater().WithAlias(&alias.Alias{
  Alias: "ArticlesProd",
  Class: "ArticlesV2",
}).Do(ctx)

if err == nil {
  fmt.Println("Alias updated successfully")
}

// Create a new collection for migration
client.collections.create("ArticlesV2", col -> col.vectorConfig(VectorConfig.selfProvided())
    .properties(Property.text("title"), Property.text("content"), Property.text("author") // New field
    ));

// Update the alias to point to the new collection
client.alias.update("ArticlesAlias", "ArticlesV2");

// Create a new collection for migration
WeaviateClass articlesV2Class = WeaviateClass.builder()
    .className("ArticlesV2")
    .properties(Arrays.asList(
        Property.builder()
            .name("title")
            .dataType(Arrays.asList(DataType.TEXT))
            .build(),
        Property.builder()
            .name("content")
            .dataType(Arrays.asList(DataType.TEXT))
            .build(),
        Property.builder()
            .name("author")
            .dataType(Arrays.asList(DataType.TEXT))
            .build() // New field
    ))
    .build();

client.schema().classCreator()
    .withClass(articlesV2Class)
    .run();

// Update the alias to point to the new collection
Result<Boolean> updateResult = client.alias()
    .updater()
    .withAlias("ArticlesProd")
    .withNewClassName("ArticlesV2")
    .run();

if (updateResult.getResult()) {
  System.out.println("Alias updated successfully");
}

// Create a new collection for migration
await client.Collections.Create(
    new CollectionCreateParams
    {
        Name = ArticlesV2,
        VectorConfig = Configure.Vector("default", v => v.Text2VecTransformers()),
        Properties =
        [
            Property.Text("title"),
            Property.Text("content"),
            Property.Text("author"), // New field
        ],
    }
);

// Update the alias to point to the new collection
bool success =
    (await client.Alias.Update(aliasName: ArticlesAlias, targetCollection: ArticlesV2))
    != null;

if (success)
{
    Console.WriteLine("Alias updated successfully");
}

用例：零停机时间迁移

更新别名对于迁移尤其有用

1. 创建具有更新的集合定义的新的集合
2. 将数据导入到新的集合
3. 更新别名以指向新的集合
4. 继续使用别名 - 所有对它的查询现在都定向到新的集合

有关如何执行迁移的代码示例，请访问 教程：使用别名迁移集合

删除别名

删除一个别名。这只会删除别名指针，而不会删除基础集合。

PythonJavaScript/TypeScriptGoJava v6Java v5 (已弃用)C#

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

# Delete an alias (the underlying collection remains)
client.alias.delete(alias_name="ArticlesAlias")

// Delete an alias (the underlying collection remains)
await client.alias.delete("ArticlesAlias")

// Delete an alias (the underlying collection remains)
err = client.Alias().AliasDeleter().WithAliasName("ArticlesProd").Do(ctx)

// Delete an alias (the underlying collection remains)
client.alias.delete("ArticlesAlias");

// Delete an alias (the underlying collection remains)
Result<Boolean> deleteResult = client.alias()
    .deleter()
    .withAlias("ArticlesProd")
    .run();

// Delete an alias (the underlying collection remains)
await client.Alias.Delete(aliasName: ArticlesAlias);

注意

• 删除集合不会自动删除指向它的别名

在操作中使用别名

创建后，别名可以在所有与对象相关的操作中使用，例如数据导入和查询，代替集合名称。

PythonJavaScript/TypeScriptGoJava v6Java v5 (已弃用)C#

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

# Ensure the Articles collection exists (it might have been deleted in previous examples)

client.collections.create(
    name="Articles",
    vector_config=wvc.config.Configure.Vectors.self_provided(),
    properties=[
        wvc.config.Property(name="title", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="content", data_type=wvc.config.DataType.TEXT),
    ],
)
# Use the alias just like a collection name
articles = client.collections.use("ArticlesAlias")

# Insert data using the alias
articles.data.insert(
    {
        "title": "Using Aliases in Weaviate",
        "content": "Aliases make collection management easier...",
    }
)

# Query using the alias
results = articles.query.fetch_objects(limit=5)

for obj in results.objects:
    print(f"Found: {obj.properties['title']}")

// Ensure the Articles collection exists (it might have been deleted in previous examples)

await client.collections.create({
    name: "Articles",
    vectorizers: weaviate.configure.vectors.selfProvided(),
    properties: [
        { name: "title", dataType: weaviate.configure.dataType.TEXT },
        { name: "content", dataType: weaviate.configure.dataType.TEXT },
    ],
})
// Create an alias for easier access
await client.alias.create({
    alias: "ArticlesAlias",
    collection: "Articles"
})

// Use the alias just like a collection name
const articles = client.collections.use("ArticlesAlias")

// Insert data using the alias
await articles.data.insert({
    "title": "Using Aliases in Weaviate",
    "content": "Aliases make collection management easier...",
})

// Query using the alias
const results = await articles.query.fetchObjects({ limit: 5 })

for (const obj of results.objects) {
    console.log(`Found: ${obj.properties['title']}`);
}

// Create an alias for easier access
err := client.Alias().AliasCreator().WithAlias(&alias.Alias{
  Alias: "MyArticles",
  Class: "Articles",
}).Do(ctx)

require.NoError(t, err)

// Use the alias just like a collection name

// Insert data using the alias
w, err := client.Data().Creator().
  WithClassName("MyArticles").
  WithProperties(map[string]interface{}{
  	"title":   "Using Aliases in Weaviate",
  	"content": "Aliases make collection management easier...",
  }).Do(ctx)

require.NoError(t, err)

// Query using the alias
result, err := client.Data().ObjectsGetter().
  WithClassName("MyArticles").
  WithLimit(5).
  Do(ctx)

require.NoError(t, err)

for _, obj := range result {
  if title, ok := obj.Properties.(map[string]interface{})["title"]; ok {
  	fmt.Printf("Found: %v\n", title)
  }
}

// Use the alias just like a collection name
CollectionHandle<Map<String, Object>> articles = client.collections.use("ArticlesAlias");

// Insert data using the alias
articles.data.insert(Map.of("title", "Using Aliases in Weaviate", "content",
    "Aliases make collection management easier..."));

// Query using the alias
var results = articles.query.fetchObjects(q -> q.limit(5));

for (var obj : results.objects()) {
  System.out.printf("Found: %s\n", obj.properties().get("title"));
}

// Ensure the Articles collection exists
WeaviateClass articlesClass = WeaviateClass.builder()
    .className("Articles")
    .properties(Arrays.asList(
        Property.builder()
            .name("title")
            .dataType(Arrays.asList(DataType.TEXT))
            .build(),
        Property.builder()
            .name("content")
            .dataType(Arrays.asList(DataType.TEXT))
            .build()))
    .build();

client.schema().classCreator()
    .withClass(articlesClass)
    .run();

// Create an alias for easier access
client.alias().creator()
    .withClassName("Articles")
    .withAlias("MyArticles")
    .run();

// Use the alias just like a collection name
// Insert data using the alias
WeaviateObject article = WeaviateObject.builder()
    .className("MyArticles") // Using alias instead of actual class name
    .properties(new HashMap<String, Object>() {
      {
        put("title", "Using Aliases in Weaviate");
        put("content", "Aliases make collection management easier...");
      }
    })
    .build();

Result<ObjectGetResponse[]> insertResult = client.batch()
    .objectsBatcher()
    .withObject(article)
    .run();

// Query using the alias
Result<GraphQLResponse> queryResult = client.graphQL()
    .get()
    .withClassName("MyArticles") // Using alias
    .withFields(Field.builder().name("title").build())
    .withLimit(5)
    .run();

if (queryResult.getResult() != null) {
  Map<String, Object> data = (Map<String, Object>) queryResult.getResult().getData();
  Map<String, Object> get = (Map<String, Object>) data.get("Get");
  List<Map<String, Object>> myArticles = (List<Map<String, Object>>) get.get("MyArticles");

  for (Map<String, Object> obj : myArticles) {
    System.out.println("Found: " + obj.get("title"));
  }
}

// Ensure the Articles collection exists (it might have been deleted in previous examples)
// Note: In C# we check existence first to avoid errors if it already exists
if (!await client.Collections.Exists(Articles))
{
    await client.Collections.Create(
        new CollectionCreateParams
        {
            Name = Articles,
            VectorConfig = Configure.Vector("default", v => v.SelfProvided()),
            Properties = [Property.Text("title"), Property.Text("content")],
        }
    );
}
// Use the alias just like a collection name
var articles = client.Collections.Use(ArticlesAlias);

// Insert data using the alias
await articles.Data.Insert(
    new
    {
        title = "Using Aliases in Weaviate",
        content = "Aliases make collection management easier...",
    }
);

// Query using the alias
var results = await articles.Query.FetchObjects(limit: 5);

foreach (var obj in results.Objects)
{
    Console.WriteLine($"Found: {obj.Properties["title"]}");
}

更多资源

• 管理集合：基本操作
• 参考：集合定义

• API 参考：REST：别名

问题和反馈

如果您有任何问题或反馈，请在 用户论坛 中告诉我们。

技术问题

如果您有任何问题，请在我们的 社区论坛 上发帖。

文档反馈

通过打开 GitHub issue 提供反馈。