Hugging Face's logo

Datasets:
LevelUp2x
/
adaptai

Dataset card Files
xet
 Community
adaptai / platform /dbops /binaries /weaviate-src /cluster /schema /reader.go
ADAPT-Chase's picture
ADAPT-Chase
Add files using upload-large-folder tool
95d599c verified
Raw History Blame Contribute Delete
7.46 kB
// _ _
// __ _____ __ ___ ___ __ _| |_ ___
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
// \ V V / __/ (_| |\ V /| | (_| | || __/
// \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
//
// Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
//
// CONTACT: hello@weaviate.io
//
package schema
import (
"context"
"github.com/cenkalti/backoff/v4"
"github.com/prometheus/client_golang/prometheus"
"github.com/weaviate/weaviate/cluster/types"
"github.com/weaviate/weaviate/cluster/utils"
"github.com/weaviate/weaviate/entities/models"
"github.com/weaviate/weaviate/entities/versioned"
"github.com/weaviate/weaviate/usecases/monitoring"
"github.com/weaviate/weaviate/usecases/sharding"
)
// SchemaReader is used for retrying schema queries. It is a thin wrapper around
// the original schema, separating retry logic from the actual operation.
// Retry may be needed due to eventual consistency issues where
// updates might take some time to arrive at the follower.
type SchemaReader struct {
schema *schema
versionedSchemaReader VersionedSchemaReader
}
func NewSchemaReader(sc *schema, vsr VersionedSchemaReader) SchemaReader {
return SchemaReader{
schema: sc,
versionedSchemaReader: vsr,
}
}
func NewSchemaReaderWithoutVersion(sc *schema) SchemaReader {
return SchemaReader{
schema: sc,
versionedSchemaReader: VersionedSchemaReader{
schema: sc,
WaitForUpdate: func(context.Context, uint64) error { return nil },
},
}
}
func (rs SchemaReader) States() map[string]types.ClassState {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("States"))
defer t.ObserveDuration()
return rs.schema.States()
}
func (rs SchemaReader) ClassInfo(class string) (ci ClassInfo) {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("ClassInfo"))
defer t.ObserveDuration()
res, _ := rs.ClassInfoWithVersion(context.TODO(), class, 0)
return res
}
// ClassEqual returns the name of an existing class with a similar name, and "" otherwise
// strings.EqualFold is used to compare classes
func (rs SchemaReader) ClassEqual(name string) string {
x, _ := rs.schema.ClassEqual(name)
return x
}
func (rs SchemaReader) MultiTenancy(class string) models.MultiTenancyConfig {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("MultiTenancy"))
defer t.ObserveDuration()
res, _ := rs.MultiTenancyWithVersion(context.TODO(), class, 0)
return res
}
// Read performs a read operation `reader` on the specified class and sharding state
func (rs SchemaReader) Read(class string, reader func(*models.Class, *sharding.State) error) error {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("Read"))
defer t.ObserveDuration()
return rs.retry(func(s *schema) error {
return s.Read(class, reader)
})
}
func (rs SchemaReader) Shards(class string) ([]string, error) {
var shards []string
err := rs.Read(class, func(class *models.Class, state *sharding.State) error {
shards = state.AllPhysicalShards()
return nil
})
return shards, err
}
func (rs SchemaReader) LocalShards(class string) ([]string, error) {
var shards []string
err := rs.Read(class, func(class *models.Class, state *sharding.State) error {
shards = state.AllLocalPhysicalShards()
return nil
})
return shards, err
}
// ReadOnlyClass returns a shallow copy of a class.
// The copy is read-only and should not be modified.
func (rs SchemaReader) ReadOnlyClass(class string) (cls *models.Class) {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("ReadOnlyClass"))
defer t.ObserveDuration()
res, _ := rs.ReadOnlyClassWithVersion(context.TODO(), class, 0)
return res
}
func (rs SchemaReader) GetAliasesForClass(class string) []*models.Alias {
return rs.schema.GetAliasesForClass(class)
}
// ReadOnlyVersionedClass returns a shallow copy of a class along with its version.
// The copy is read-only and should not be modified.
func (rs SchemaReader) ReadOnlyVersionedClass(className string) versioned.Class {
class, version := rs.schema.ReadOnlyClass(className)
return versioned.Class{
Class: class,
Version: version,
}
}
func (rs SchemaReader) metaClass(class string) (meta *metaClass) {
rs.retry(func(s *schema) error {
if meta = s.metaClass(class); meta == nil {
return ErrClassNotFound
}
return nil
})
return
}
// ReadOnlySchema returns a read only schema
// Changing the schema outside this package might lead to undefined behavior.
//
// it creates a shallow copy of existing classes
//
// This function assumes that class attributes are being overwritten.
// The properties attribute is the only one that might vary in size;
// therefore, we perform a shallow copy of the existing properties.
// This implementation assumes that individual properties are overwritten rather than partially updated
func (rs SchemaReader) ReadOnlySchema() models.Schema {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("ReadOnlySchema"))
defer t.ObserveDuration()
return rs.schema.ReadOnlySchema()
}
func (rs SchemaReader) ResolveAlias(alias string) string {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("ResolveAlias"))
defer t.ObserveDuration()
return rs.schema.ResolveAlias(alias)
}
func (rs SchemaReader) Aliases() map[string]string {
return rs.schema.getAliases("", "")
}
// ShardOwner returns the node owner of the specified shard
func (rs SchemaReader) ShardOwner(class, shard string) (owner string, err error) {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("ShardOwner"))
defer t.ObserveDuration()
res, err := rs.ShardOwnerWithVersion(context.TODO(), class, shard, 0)
return res, err
}
// ShardFromUUID returns shard name of the provided uuid
func (rs SchemaReader) ShardFromUUID(class string, uuid []byte) (shard string) {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("ShardFromUUID"))
defer t.ObserveDuration()
res, _ := rs.ShardFromUUIDWithVersion(context.TODO(), class, uuid, 0)
return res
}
// ShardReplicas returns the replica nodes of a shard
func (rs SchemaReader) ShardReplicas(class, shard string) (nodes []string, err error) {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("ShardReplicas"))
defer t.ObserveDuration()
res, err := rs.ShardReplicasWithVersion(context.TODO(), class, shard, 0)
return res, err
}
// TenantsShards returns shard name for the provided tenant and its activity status
func (rs SchemaReader) TenantsShards(class string, tenants ...string) (map[string]string, error) {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("TenantsShards"))
defer t.ObserveDuration()
return rs.TenantsShardsWithVersion(context.TODO(), 0, class, tenants...)
}
func (rs SchemaReader) GetShardsStatus(class, tenant string) (models.ShardStatusList, error) {
t := prometheus.NewTimer(monitoring.GetMetrics().SchemaReadsLocal.WithLabelValues("GetShardsStatus"))
defer t.ObserveDuration()
return rs.schema.GetShardsStatus(class, tenant)
}
func (rs SchemaReader) Len() int { return rs.schema.len() }
func (rs SchemaReader) retry(f func(*schema) error) error {
return backoff.Retry(func() error {
return f(rs.schema)
}, utils.NewBackoff())
}