搜索模式和基础

使用 Weaviate，您可以使用 向量相似度搜索、关键词搜索，或两者结合使用 混合搜索 来查询您的数据。您可以控制要返回的对象 属性 和 元数据。

此页面提供基本的搜索语法，帮助您入门。

您更喜欢自然语言查询吗？

查询代理将简单的英文问题自动转换为优化的 Weaviate 查询 - 无需手动构建查询。

仅云端

列出对象

您可以获取对象，而无需指定任何参数。这将以升序 UUID 顺序返回对象。

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

  API 文档

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

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

jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects()

for o in response.objects:
    print(o.properties)

const myCollection = client.collections.use('JeopardyQuestion');

const result = await myCollection.query.fetchObjects()
console.log(JSON.stringify(result, null, 2));

response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(graphql.Field{Name: "question"}).
  Do(ctx)

CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects();

for (var o : response.objects()) {
  System.out.println(o.properties());
}

Result<List<WeaviateObject>> resultObj = client.data().objectsGetter()
  .withClassName(className)
  .run();

var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects();

foreach (var o in response.Objects)
{
    Console.WriteLine(JsonSerializer.Serialize(o.Properties));
}

{
  Get {
    JeopardyQuestion {
      question
    }
  }
}

示例响应

输出如下所示

{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "question": "This prophet passed the time he spent inside a fish offering up prayers"
        },
        // shortened for brevity
      ]
    }
  }
}

其他信息

指定您希望查询返回的信息。您可以返回对象属性、对象 ID 和对象元数据。

limit 返回的对象

使用 limit 设置要返回的对象的固定最大数量。

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

  API 文档

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

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

jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    limit=1
)

for o in response.objects:
    print(o.properties)

const myCollection = client.collections.use('JeopardyQuestion');

const result = await myCollection.query.fetchObjects(
  { limit: 1 }
)
     
console.log(JSON.stringify(result, null, 2));

response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(graphql.Field{Name: "question"}).
  WithLimit(1).
  Do(ctx)

CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(
    q -> q.limit(1)
);

for (var o : response.objects()) {
  System.out.println(o.properties());
}

Result<List<WeaviateObject>> resultObj = client.data().objectsGetter()
  .withClassName(className)
  .withLimit(1) // Object IDs are included by default with the Java client
  .run();

var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(
    limit: 1
);

foreach (var o in response.Objects)
{
    Console.WriteLine(JsonSerializer.Serialize(o.Properties));
}

{
  Get {
    JeopardyQuestion (
      limit: 1
    ) {
      question
    }
  }
}

示例响应

输出如下所示

{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "question": "This prophet passed the time he spent inside a fish offering up prayers"
        },
        // Note this will only have one result as we limited it to 1
      ]
    }
  }
}

使用 limit 和 offset 进行分页

要在结果集的中间开始，请定义一个 offset。设置一个 limit 以从偏移量处返回对象。

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

  API 文档

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

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

jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    limit=1,
    offset=1
)

for o in response.objects:
    print(o.properties)

const myCollection = client.collections.use('JeopardyQuestion');

const result = await myCollection.query.fetchObjects({
  limit: 1,
  offset: 1,
})

console.log(JSON.stringify(result, null, 2));

response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(graphql.Field{Name: "question"}).
  WithLimit(1).
  WithOffset(1).
  Do(ctx)

CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(
    q -> q.limit(1).offset(1)
);

for (var o : response.objects()) {
  System.out.println(o.properties());
}

Result<List<WeaviateObject>> resultObj = client.data().objectsGetter()
  .withClassName(className)
  .withLimit(1)
  .withOffset(1)
  .run();

var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(offset: 1, limit: 1);

foreach (var o in response.Objects)
{
    Console.WriteLine(JsonSerializer.Serialize(o.Properties));
}

{
  Get {
    JeopardyQuestion (
      limit: 1
      offset: 1
    ) {
      question
    }
  }
}

示例响应

输出如下所示

{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "question": "Pythons are oviparous, meaning they do this"
        }
      ]
    }
  }
}

要分页浏览整个数据库，请使用 游标 代替 offset 和 limit。

检索对象 属性

您可以指定要返回哪些对象属性。默认情况下，将返回所有属性和对象 UUID。除非另有说明，否则将排除 Blob 和引用属性（这不适用于 Go 和 Java v5 客户端库）。

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

  API 文档

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

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

jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    limit=1,
    return_properties=["question", "answer", "points"]
)

for o in response.objects:
    print(o.properties)

const myCollection = client.collections.use('JeopardyQuestion');

const result = await myCollection.query.fetchObjects({
  limit: 1,
  returnProperties: ['question', 'answer', 'points'],
})

console.log(JSON.stringify(result, null, 2));

response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(
  	graphql.Field{Name: "question"},
  	graphql.Field{Name: "answer"},
  	graphql.Field{Name: "points"},
  ).
  WithLimit(1).
  Do(ctx)

CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(
    q -> q.limit(1).returnProperties("question", "answer", "points")
);

for (var o : response.objects()) {
  System.out.println(o.properties());
}

Result<List<WeaviateObject>> resultObj = client.data().objectsGetter()
  .withClassName(className)
  .withLimit(1)
  .run();
resultObj.getResult().get(0).getProperties().get(propertyName);

var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(
    limit: 1,
    returnProperties: new[] { "question", "answer", "points" }
);

foreach (var o in response.Objects)
{
    Console.WriteLine(JsonSerializer.Serialize(o.Properties));
}

{
  Get {
    JeopardyQuestion (limit: 1) {
      question
      answer
      points
    }
  }
}

示例响应

输出如下所示

{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "answer": "Jonah",
          "points": 100,
          "question": "This prophet passed the time he spent inside a fish offering up prayers"
        },
      ]
    }
  }
}

检索对象 向量

您可以检索对象向量。（同样适用于使用 命名向量 的情况。）

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

  API 文档

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

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

jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    include_vector=True,
    limit=1
)

print(response.objects[0].vector["default"])

const myCollection = client.collections.use('JeopardyQuestion');

const result = await myCollection.query.fetchObjects({
  includeVector: true,
  limit: 1,

})

console.log(JSON.stringify(result, null, 2));

response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(
  	graphql.Field{
  		Name: "_additional",
  		Fields: []graphql.Field{
  			{Name: "vector"},
  		},
  	},
  ).
  WithLimit(1).
  Do(ctx)

CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(q -> q
    .includeVector()
    .limit(1));

if (!response.objects().isEmpty()) {
  System.out.println(response.objects().get(0).vectors());
}

Result<List<WeaviateObject>> resultObj = client.data().objectsGetter()
  .withClassName(className)
  .withLimit(1)
  .withVector()
  .run();

var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(
    includeVectors: new[] { "default" },
    limit: 1
);

Console.WriteLine("Vector for 'default':");
if (response.Objects.Any())
{
    Console.WriteLine(JsonSerializer.Serialize(response.Objects.First()));
}

{
  Get {
    JeopardyQuestion (limit: 1) {
      _additional {
        vector
      }
    }
  }
}

示例响应

输出如下所示

{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "_additional": {
            "vector": [
              0.0065065133,
              -0.017786196,
              0.005879146,
              0.006707012,
              ...  // shortened for brevity
            ]
          }
        },
      ]
    }
  }
}

检索对象 id

您可以检索对象 id (uuid)。

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

  API 文档

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

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

jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    # Object IDs are included by default with the `v4` client! :)
    limit=1
)

for o in response.objects:
    print(o.uuid)

const myCollection = client.collections.use('JeopardyQuestion');

const result = await myCollection.query.fetchObjects({
  // Object IDs are included by default with the `v3` client! :)
  limit: 1,
})

for (let object of result.objects) {
   console.log(JSON.stringify(object.uuid, null, 2));
}

response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(
  	graphql.Field{
  		Name: "_additional",
  		Fields: []graphql.Field{
  			{Name: "id"},
  		},
  	},
  ).
  WithLimit(1).
  Do(ctx)

CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(
    // Object IDs are included by default with the v6 client! :)
    q -> q.limit(1));

for (var o : response.objects()) {
  System.out.println(o.uuid());
}

Result<List<WeaviateObject>> resultObj = client.data().objectsGetter()
  .withClassName(className)
  .withLimit(1)
  .run();
resultObj.getResult().get(0).getId();

var jeopardy = client.Collections.Use("JeopardyQuestion");
// Ensure you use a UUID that actually exists in your DB, or fetch one first
var allObjs = await jeopardy.Query.FetchObjects(limit: 1);
var idToFetch = allObjs.Objects.First().UUID;

var response = await jeopardy.Query.FetchObjectByID((Guid)idToFetch);

Console.WriteLine(response);

{
  Get {
    JeopardyQuestion (limit: 1) {
      _additional {
        id
      }
    }
  }
}

示例响应

输出如下所示

{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "_additional": {
            "id": "0002bf92-80c8-5d94-af34-0d6c5fea1aaf"
          }
        },
        // shortened for brevity
      ]
    }
  }
}

检索交叉引用属性

交叉引用和查询性能

涉及交叉引用的查询可能比不涉及交叉引用的查询慢，尤其是在大规模情况下，例如对于多个对象或复杂查询。

首先，我们强烈建议您考虑是否可以避免在数据模式中使用交叉引用。作为可扩展的 AI 数据库，Weaviate 擅长使用向量、关键词和混合搜索进行复杂查询，包括过滤器。您可以通过重新思考数据模式来避免交叉引用，从而受益匪浅。

例如，与其创建带有交叉引用的单独的“作者”和“书籍”集合，不如考虑将作者信息直接嵌入到书籍对象中，并使用搜索和过滤器按作者特征查找书籍。

要检索交叉引用对象的属性，请指定

• 交叉引用属性
• 目标交叉引用集合
• 要检索的属性

PythonJavaScript/TypeScriptGoJava v6C#GraphQL

  API 文档

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

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

from weaviate.classes.query import QueryReference

jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    return_references=[
        QueryReference(
            link_on="hasCategory",
            return_properties=["title"]
        ),
    ],
    limit=2
)

for o in response.objects:
    print(o.properties["question"])
    # print referenced objects
    for ref_obj in o.references["hasCategory"].objects:
        print(ref_obj.properties)

const myCollection = client.collections.use('JeopardyQuestion');

const result = await myCollection.query.fetchObjects({
  limit: 2,
  returnReferences: [{
    linkOn: 'hasCategory',
    returnProperties: ['title'],
  }]
})

result.objects.forEach(item => 
  console.log(JSON.stringify(item.references, null, 2))
);

response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(
  	graphql.Field{Name: "question"},
  	graphql.Field{
  		Name: "hasCategory",
  		Fields: []graphql.Field{
  			{Name: "... on JeopardyCategory", Fields: []graphql.Field{{Name: "title"}}},
  		},
  	},
  ).
  WithLimit(2).
  Do(ctx)

CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(q -> q
    .returnReferences(QueryReference.single("hasCategory",
        r -> r.returnProperties("title")))
    .limit(2));

for (var o : response.objects()) {
  System.out.println(o.properties().get("question"));
  // print referenced objects
  if (o.references() != null && o.references().get("hasCategory") != null) {
    for (var refObj : o.references().get("hasCategory")) {
      System.out.println(refObj);
    }
  }
}

var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(
    returnReferences: [new QueryReference(linkOn: "hasCategory", fields: ["title"])],
    limit: 2
);

foreach (var o in response.Objects)
{
    if (o.Properties.ContainsKey("question"))
        Console.WriteLine(o.Properties["question"]);

    // print referenced objects
    // Note: References are grouped by property name ('hasCategory')
    if (o.References != null && o.References.ContainsKey("hasCategory"))
    {
        foreach (var refObj in o.References["hasCategory"])
        {
            Console.WriteLine(JsonSerializer.Serialize(refObj.Properties));
        }
    }
}

{
  Get {
    JeopardyQuestion (
      limit: 2
    )
    {
      question
      hasCategory {
        ... on JeopardyCategory {
          title
        }
      }
    }
  }
}

示例响应

输出如下所示

    {
        "data": {
            "Get": {
                "JeopardyQuestion": [
                    {
                        "hasCategory": [{"title": "THE BIBLE"}],
                        "question": "This prophet passed the time he spent inside a fish offering up prayers",
                    },
                    {
                        "hasCategory": [{"title": "ANIMALS"}],
                        "question": "Pythons are oviparous, meaning they do this",
                    },
                ]
            }
        }
    }

检索元数据值

您可以指定要返回的元数据字段。

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

  API 文档

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

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

from weaviate.classes.query import MetadataQuery

jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    limit=1,
    return_metadata=MetadataQuery(creation_time=True)
)

for o in response.objects:
    print(o.properties)  # View the returned properties
    print(o.metadata.creation_time)  # View the returned creation time

const myCollection = client.collections.use('JeopardyQuestion');

const result = await myCollection.query.fetchObjects({
  limit: 2,
  returnMetadata: ['creationTime', ]
})

for (let object of result.objects) {
  console.log(JSON.stringify(object.properties, null, 2));
  console.log(JSON.stringify(object.metadata?.creationTime, null, 2));
}

response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithLimit(1).
  WithFields(
  	graphql.Field{Name: "question"},
  	graphql.Field{
  		Name: "_additional",
  		Fields: []graphql.Field{
  			{Name: "creationTimeUnix"},
  		},
  	},
  ).
  Do(ctx)

CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(q -> q.limit(1)
    .returnMetadata(Metadata.CREATION_TIME_UNIX)
);

for (var o : response.objects()) {
  System.out.println(o.properties()); // View the returned properties
  System.out.println(o.createdAt()); // View the returned creation time
}

Result<List<WeaviateObject>> resultObj = client.data().objectsGetter()
  .withClassName(className)
  .run();
resultObj.getResult().get(0).getLastUpdateTimeUnix();
resultObj.getResult().get(0).getCreationTimeUnix();

var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(
    limit: 1,
    returnMetadata: MetadataOptions.CreationTime
);

foreach (var o in response.Objects)
{
    Console.WriteLine(JsonSerializer.Serialize(o.Properties)); // View the returned properties
    Console.WriteLine(o.Metadata.CreationTime); // View the returned creation time
}

{
  Get {
    JeopardyQuestion (
      limit: 1
    ) {
      question
      _additional { creationTimeUnix }
    }
  }
}

有关元数据字段的完整列表，请参阅 GraphQL：附加属性。

多租户

如果 多租户 已启用，请在每个查询中指定 tenant 参数。

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

  API 文档

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

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

# Connect to the collection
mt_collection = client.collections.use("WineReviewMT")

# Get the specific tenant's version of the collection
collection_tenant_a = mt_collection.with_tenant("tenantA")

# Query tenantA's version
response = collection_tenant_a.query.fetch_objects(
    return_properties=["review_body", "title"],
    limit=1,
)

print(response.objects[0].properties)

const myMTCollection = client.collections.use('WineReviewMT');
const collectionTenantA = myMTCollection.withTenant('tenantA');

const multiTenantResult = await collectionTenantA.query.fetchObjects({
  limit: 1,
  returnProperties: ['review_body','title']
})

console.log(JSON.stringify(multiTenantResult.objects[0].properties, null, 2));

response, err := client.GraphQL().Get().
  WithClassName("MultiTenancyClass").
  WithFields(graphql.Field{Name: "property1"}, graphql.Field{Name: "property2"}).
  WithLimit(1).
  WithTenant("tenantA").
  Do(ctx)

// Connect to the collection
CollectionHandle<Map<String, Object>> mtCollection =
    client.collections.use("WineReviewMT");

// Get the specific tenant's version of the collection
var collectionTenantA = mtCollection.withTenant("tenantA");

// Query tenantA's version
var response = collectionTenantA.query
    .fetchObjects(q -> q.returnProperties("review_body", "title").limit(1));

if (!response.objects().isEmpty()) {
  System.out.println(response.objects().get(0).properties());
}

Result<List<WeaviateObject>> resultObj = client.data().objectsGetter()
  .withClassName(className)
  .withTenant(tenantName)
  .withVector()
  .run();

var mtCollection = client.Collections.Use("WineReviewMT").WithTenant("tenantA");

var response = await mtCollection.Query.FetchObjects(
    returnProperties: new[] { "review_body", "title" },
    limit: 1
);

if (response.Objects.Any())
{
    Console.WriteLine(JsonSerializer.Serialize(response.Objects.First().Properties));
    Assert.Equal("WineReviewMT", response.Objects.First().Collection);
}

复制

对于启用了复制的集合，您可以在查询中指定一致性级别。这适用于 CRUD 查询以及搜索。

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

  API 文档

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

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

from weaviate.classes.config import ConsistencyLevel

questions = client.collections.use(collection_name).with_consistency_level(
    consistency_level=ConsistencyLevel.QUORUM
)
response = collection.query.fetch_object_by_id("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")

# The parameter passed to `withConsistencyLevel` can be one of:
# * 'ALL',
# * 'QUORUM' (default), or
# * 'ONE'.
#
# It determines how many replicas must acknowledge a request
# before it is considered successful.

for o in response.objects:
    print(o.properties)  # Inspect returned objects

const myCollection = client.collections.use('Article').withConsistency('QUORUM');

const result = await myCollection.query.fetchObjectById("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")

console.log(JSON.stringify(result, null, 2));

// The parameter passed to `withConsistencyLevel` can be one of:
// * 'ALL',
// * 'QUORUM' (default), or
// * 'ONE'.
//
// It determines how many replicas must acknowledge a request
// before it is considered successful.

package main

import (
    "context"
    "fmt"

    "github.com/weaviate/weaviate-go-client/v5/weaviate/data/replication"  // for consistency levels
    "github.com/weaviate/weaviate-go-client/v5/weaviate"
)

func main() {
    cfg := weaviate.Config{
        Host:   "localhost:8080",
        Scheme: "http",
    }
    client, err := weaviate.NewClient(cfg)
    if err != nil {
        panic(err)
    }

    data, err := client.Data().ObjectsGetter().
        WithClassName("MyClass").
        WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
        WithConsistencyLevel(replication.ConsistencyLevel.ONE).  // default QUORUM
        Do(context.Background())

    if err != nil {
        panic(err)
    }
    fmt.Printf("%v", data)
}

// The parameter passed to "WithConsistencyLevel" can be one of:
// * replication.ConsistencyLevel.ALL,
// * replication.ConsistencyLevel.QUORUM (default), or
// * replication.ConsistencyLevel.ONE.
//
// It determines how many replicas must acknowledge a request
// before it is considered successful.

var jeopardyWithConsistency = client.collections.use("JeopardyQuestion")
    .withConsistencyLevel(ConsistencyLevel.QUORUM);
var response = jeopardyWithConsistency.query.fetchObjectById(uuid);

System.out.println(response.get().properties());

package io.weaviate;

import java.util.List;
import io.weaviate.client.Config;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.data.model.WeaviateObject;
import io.weaviate.client.v1.data.replication.model.ConsistencyLevel;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Result<List<WeaviateObject>> result = client.data().objectsGetter()
      .withClassName("MyClass")
      .withID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")
      .withConsistencyLevel(ConsistencyLevel.ONE)  // default QUORUM
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

// The parameter passed to `withConsistencyLevel` can be one of:
// * ConsistencyLevel.ALL,
// * ConsistencyLevel.QUORUM (default), or
// * ConsistencyLevel.ONE.
//
// It determines how many replicas must acknowledge a request
// before it is considered successful.

var jeopardy = client
    .Collections.Use("JeopardyQuestion")
    .WithConsistencyLevel(ConsistencyLevels.Quorum);

var response = await jeopardy.Query.FetchObjectByID((Guid)validId);

// The parameter passed to `withConsistencyLevel` can be one of:
// * 'ALL',
// * 'QUORUM' (default), or
// * 'ONE'.
//
// It determines how many replicas must acknowledge a request
// before it is considered successful.

Console.WriteLine(response);

curl "https://:8080/v1/objects/MyClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303?consistency_level=QUORUM"

# The parameter "consistency_level" can be one of ALL, QUORUM (default), or ONE. Determines how many
# replicas must acknowledge a request before it is considered successful.
# curl "/v1/objects/{ClassName}/{id}?consistency_level=ONE"

相关页面

• 连接到 Weaviate
• API 参考：GraphQL：Get
• 有关教程，请参阅 查询
• 有关使用 GraphQL API 进行搜索，请参阅 GraphQL API

问题和反馈

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

技术问题

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

文档反馈

通过打开 GitHub issue 提供反馈。