331 lines
11 KiB
Go
331 lines
11 KiB
Go
// Package main implement redis test data injection
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
|
|
"github.com/RediSearch/redisearch-go/v2/redisearch"
|
|
"github.com/redis/go-redis/v9"
|
|
)
|
|
|
|
var ac *redisearch.Autocompleter
|
|
|
|
// InitAutocompleterWithPool define func of initialize the Autocompleter with redigo pool
|
|
func init() {
|
|
// ac = redisearch.NewAutocompleterFromPool(pool, redisSearchDictName)
|
|
ac = redisearch.NewAutocompleter("localhost:6379", redisSearchDictName)
|
|
}
|
|
|
|
const (
|
|
gridKeysSet = "grid_keys"
|
|
zoneKeysSet = "zone_keys"
|
|
stationKeysSet = "station_keys"
|
|
componentNSPathKeysSet = "component_nspath_keys"
|
|
componentTagKeysSet = "component_tag_keys"
|
|
configKeysSet = "config_keys"
|
|
measurementTagKeysSet = "measurement_tag_keys"
|
|
|
|
// Grid -> Zone (e.g., grid1_zones_keys)
|
|
gridZoneSetKeyFormat = "grid%d_zones_keys"
|
|
// Zone -> Station (e.g., zone1_1_stations_keys)
|
|
zoneStationSetKeyFormat = "zone%d_%d_stations_keys"
|
|
// Station -> NSPath (e.g., station1_1_1_components_nspath_keys)
|
|
stationNSPathKeyFormat = "station%d_%d_%d_components_nspath_keys"
|
|
// NSPath -> CompTag (e.g., ns1_1_1_1_components_tag_keys)
|
|
nsPathCompTagKeyFormat = "ns%d_%d_%d_%d_components_tag_keys"
|
|
// CompTag -> Measurement (e.g., comptag1_1_1_1_1_measurement_keys)
|
|
compTagMeasKeyFormat = "comptag%d_%d_%d_%d_%d_measurement_keys"
|
|
)
|
|
|
|
const (
|
|
redisSearchDictName = "search_suggestions_dict"
|
|
defaultScore = 1.0
|
|
)
|
|
|
|
var configMetrics = []any{
|
|
"component", "base_extend", "rated", "setup", "model",
|
|
"stable", "bay", "craft", "integrity", "behavior",
|
|
}
|
|
|
|
func bulkInsertAllHierarchySets(ctx context.Context, rdb *redis.Client) error {
|
|
log.Println("starting bulk insertion of Redis hierarchy sets")
|
|
|
|
if err := insertStaticSets(ctx, rdb); err != nil {
|
|
return fmt.Errorf("static set insertion failed: %w", err)
|
|
}
|
|
|
|
if err := insertDynamicHierarchy(ctx, rdb); err != nil {
|
|
return fmt.Errorf("dynamic hierarchy insertion failed: %w", err)
|
|
}
|
|
|
|
if err := insertAllHierarchySuggestions(ac); err != nil {
|
|
return fmt.Errorf("dynamic hierarchy insertion failed: %w", err)
|
|
}
|
|
|
|
log.Println("bulk insertion complete.")
|
|
return nil
|
|
}
|
|
|
|
func insertStaticSets(ctx context.Context, rdb *redis.Client) error {
|
|
// grid_keys
|
|
if err := rdb.SAdd(ctx, gridKeysSet, "grid1", "grid2", "grid3").Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", gridKeysSet, err)
|
|
}
|
|
|
|
// zone_keys (3x3 = 9 members)
|
|
zoneMembers := make([]any, 0, 9)
|
|
for i := 1; i <= 3; i++ {
|
|
for j := 1; j <= 3; j++ {
|
|
zoneMembers = append(zoneMembers, fmt.Sprintf("zone%d_%d", i, j))
|
|
}
|
|
}
|
|
if err := rdb.SAdd(ctx, zoneKeysSet, zoneMembers...).Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", zoneKeysSet, err)
|
|
}
|
|
|
|
// config_keys
|
|
if err := rdb.SAdd(ctx, configKeysSet, configMetrics...).Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", configKeysSet, err)
|
|
}
|
|
|
|
log.Println("Static sets (grid_keys, zone_keys, config_keys) inserted.")
|
|
return nil
|
|
}
|
|
|
|
func insertDynamicHierarchy(ctx context.Context, rdb *redis.Client) error {
|
|
allStationKeys := make([]any, 0, 27)
|
|
allNSPathKeys := make([]any, 0, 81)
|
|
allCompTagKeys := make([]any, 0, 243)
|
|
allMeasurementTagKeys := make([]any, 0, 729)
|
|
|
|
// S: Grid Prefix (1-3)
|
|
for S := 1; S <= 3; S++ {
|
|
// Grid-Zone Set Key: gridS_zones_keys
|
|
gridZoneKey := fmt.Sprintf(gridZoneSetKeyFormat, S)
|
|
gridZoneMembers := make([]any, 0, 3)
|
|
|
|
// Y: Zone Index (1-3)
|
|
for Y := 1; Y <= 3; Y++ {
|
|
zoneID := fmt.Sprintf("%d_%d", S, Y)
|
|
zoneMember := "zone" + zoneID
|
|
gridZoneMembers = append(gridZoneMembers, zoneMember)
|
|
|
|
// Zone-Station Set Key: zoneS_Y_stations_keys
|
|
zoneStationKey := fmt.Sprintf(zoneStationSetKeyFormat, S, Y)
|
|
zoneStationMembers := make([]any, 0, 3)
|
|
|
|
// Z: Station Index (1-3)
|
|
for Z := 1; Z <= 3; Z++ {
|
|
stationID := fmt.Sprintf("%d_%d_%d", S, Y, Z)
|
|
stationKey := "station" + stationID
|
|
allStationKeys = append(allStationKeys, stationKey)
|
|
zoneStationMembers = append(zoneStationMembers, stationKey)
|
|
|
|
// Station-NSPath Set Key: stationS_Y_Z_components_nspath_keys
|
|
stationNSPathKey := fmt.Sprintf(stationNSPathKeyFormat, S, Y, Z)
|
|
stationNSMembers := make([]any, 0, 3)
|
|
|
|
// D: NSPath Index (1-3)
|
|
for D := 1; D <= 3; D++ {
|
|
nsPathID := fmt.Sprintf("%s_%d", stationID, D)
|
|
nsPathKey := "ns" + nsPathID
|
|
allNSPathKeys = append(allNSPathKeys, nsPathKey)
|
|
stationNSMembers = append(stationNSMembers, nsPathKey)
|
|
|
|
// NSPath-CompTag Set Key: nsS_Y_Z_D_components_tag_keys
|
|
nsCompTagKey := fmt.Sprintf(nsPathCompTagKeyFormat, S, Y, Z, D)
|
|
nsCompTagMembers := make([]any, 0, 3)
|
|
|
|
// I: CompTag Index (1-3)
|
|
for I := 1; I <= 3; I++ {
|
|
compTagID := fmt.Sprintf("%s_%d", nsPathID, I)
|
|
compTagKey := "cmptag" + compTagID
|
|
allCompTagKeys = append(allCompTagKeys, compTagKey)
|
|
nsCompTagMembers = append(nsCompTagMembers, compTagKey)
|
|
|
|
// CompTag-Measurement Set Key: comptagS_Y_Z_D_I_measurement_keys
|
|
compTagMeasKey := fmt.Sprintf(compTagMeasKeyFormat, S, Y, Z, D, I)
|
|
compTagMeasMembers := make([]any, 0, 3)
|
|
|
|
// M: Measurement Index (1-3)
|
|
for M := 1; M <= 3; M++ {
|
|
measurementID := fmt.Sprintf("%s_%d", compTagID, M)
|
|
measurementKey := "meas" + measurementID
|
|
allMeasurementTagKeys = append(allMeasurementTagKeys, measurementKey)
|
|
compTagMeasMembers = append(compTagMeasMembers, measurementKey)
|
|
}
|
|
|
|
if err := rdb.SAdd(ctx, compTagMeasKey, compTagMeasMembers...).Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", compTagMeasKey, err)
|
|
}
|
|
}
|
|
|
|
if err := rdb.SAdd(ctx, nsCompTagKey, nsCompTagMembers...).Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", nsCompTagKey, err)
|
|
}
|
|
}
|
|
|
|
if err := rdb.SAdd(ctx, stationNSPathKey, stationNSMembers...).Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", stationNSPathKey, err)
|
|
}
|
|
}
|
|
|
|
if err := rdb.SAdd(ctx, zoneStationKey, zoneStationMembers...).Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", zoneStationKey, err)
|
|
}
|
|
|
|
}
|
|
|
|
if err := rdb.SAdd(ctx, gridZoneKey, gridZoneMembers...).Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", gridZoneKey, err)
|
|
}
|
|
}
|
|
|
|
// 插入所有顶层动态 Set (将所有成员一次性插入到全局 Set 中)
|
|
if err := rdb.SAdd(ctx, stationKeysSet, allStationKeys...).Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", stationKeysSet, err)
|
|
}
|
|
if err := rdb.SAdd(ctx, componentNSPathKeysSet, allNSPathKeys...).Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", componentNSPathKeysSet, err)
|
|
}
|
|
if err := rdb.SAdd(ctx, componentTagKeysSet, allCompTagKeys...).Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", componentTagKeysSet, err)
|
|
}
|
|
if err := rdb.SAdd(ctx, measurementTagKeysSet, allMeasurementTagKeys...).Err(); err != nil {
|
|
return fmt.Errorf("sadd failed for %s: %w", measurementTagKeysSet, err)
|
|
}
|
|
|
|
log.Printf("inserted %d stations, %d nspaths, %d comptags, and %d measurements.\n",
|
|
len(allStationKeys), len(allNSPathKeys), len(allCompTagKeys), len(allMeasurementTagKeys))
|
|
|
|
return nil
|
|
}
|
|
|
|
func insertAllHierarchySuggestions(ac *redisearch.Autocompleter) error {
|
|
suggestions := make([]redisearch.Suggestion, 0, 10000)
|
|
// S: grid Index (1-3)
|
|
for S := 1; S <= 3; S++ {
|
|
gridStr := fmt.Sprintf("grid%d", S)
|
|
suggestions = append(suggestions, redisearch.Suggestion{Term: gridStr, Score: defaultScore})
|
|
|
|
// Y: zone Index (1-3)
|
|
for Y := 1; Y <= 3; Y++ {
|
|
zoneStr := fmt.Sprintf("zone%d_%d", S, Y)
|
|
gridZonePath := fmt.Sprintf("%s.%s", gridStr, zoneStr)
|
|
suggestions = append(suggestions, redisearch.Suggestion{Term: gridZonePath, Score: defaultScore})
|
|
|
|
// Z: station Index (1-3)
|
|
for Z := 1; Z <= 3; Z++ {
|
|
stationStr := fmt.Sprintf("station%d_%d_%d", S, Y, Z)
|
|
gridZoneStationPath := fmt.Sprintf("%s.%s", gridZonePath, stationStr)
|
|
suggestions = append(suggestions, redisearch.Suggestion{Term: gridZoneStationPath, Score: defaultScore})
|
|
|
|
// D: nsPath Index (1-3)
|
|
for D := 1; D <= 3; D++ {
|
|
nsPathStr := fmt.Sprintf("ns%d_%d_%d_%d", S, Y, Z, D)
|
|
gridZoneStationNSPath := fmt.Sprintf("%s.%s", gridZoneStationPath, nsPathStr)
|
|
suggestions = append(suggestions, redisearch.Suggestion{Term: gridZoneStationNSPath, Score: defaultScore})
|
|
|
|
// I: compTag Index (1-3)
|
|
for I := 1; I <= 3; I++ {
|
|
compTagStr := fmt.Sprintf("comptag%d_%d_%d_%d_%d", S, Y, Z, D, I)
|
|
fullCompTagPath := fmt.Sprintf("%s.%s", gridZoneStationNSPath, compTagStr)
|
|
suggestions = append(suggestions, redisearch.Suggestion{Term: fullCompTagPath, Score: defaultScore})
|
|
|
|
for _, metric := range configMetrics {
|
|
fullMetricPath := fmt.Sprintf("%s.%s", fullCompTagPath, metric)
|
|
suggestions = append(suggestions, redisearch.Suggestion{Term: fullMetricPath, Score: defaultScore})
|
|
// J: measTag Index (1-3)
|
|
for J := 1; J <= 3; J++ {
|
|
measTagStr := fmt.Sprintf("comptag%d_%d_%d_%d_%d_%d", S, Y, Z, D, I, J)
|
|
fullMeasurementPath := fmt.Sprintf("%s.%s", fullMetricPath, measTagStr)
|
|
suggestions = append(suggestions, redisearch.Suggestion{Term: fullMeasurementPath, Score: defaultScore})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
log.Printf("generated %d suggestions. starting bulk insertion into dictionary '%s'.", len(suggestions), redisSearchDictName)
|
|
|
|
// del ac suggestion
|
|
ac.Delete()
|
|
|
|
err := ac.AddTerms(suggestions...)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to add %d suggestions: %w", len(suggestions), err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func deleteAllHierarchySets(ctx context.Context, rdb *redis.Client) error {
|
|
log.Println("starting to collect all Redis Set keys for deletion...")
|
|
|
|
keysToDelete := []string{
|
|
gridKeysSet,
|
|
zoneKeysSet,
|
|
stationKeysSet,
|
|
componentNSPathKeysSet,
|
|
componentTagKeysSet,
|
|
configKeysSet,
|
|
measurementTagKeysSet,
|
|
}
|
|
|
|
for S := 1; S <= 3; S++ {
|
|
keysToDelete = append(keysToDelete, fmt.Sprintf(gridZoneSetKeyFormat, S))
|
|
|
|
for Y := 1; Y <= 3; Y++ {
|
|
keysToDelete = append(keysToDelete, fmt.Sprintf(zoneStationSetKeyFormat, S, Y))
|
|
|
|
for Z := 1; Z <= 3; Z++ {
|
|
keysToDelete = append(keysToDelete, fmt.Sprintf(stationNSPathKeyFormat, S, Y, Z))
|
|
|
|
for D := 1; D <= 3; D++ {
|
|
keysToDelete = append(keysToDelete, fmt.Sprintf(nsPathCompTagKeyFormat, S, Y, Z, D))
|
|
|
|
for I := 1; I <= 3; I++ {
|
|
keysToDelete = append(keysToDelete, fmt.Sprintf(compTagMeasKeyFormat, S, Y, Z, D, I))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
log.Printf("collected %d unique keys. Starting batch deletion...", len(keysToDelete))
|
|
|
|
deletedCount, err := rdb.Del(ctx, keysToDelete...).Result()
|
|
if err != nil {
|
|
return fmt.Errorf("batch deletion failed: %w", err)
|
|
}
|
|
|
|
log.Printf("Successfully deleted %d keys (Sets) from Redis.", deletedCount)
|
|
return nil
|
|
}
|
|
|
|
func main() {
|
|
rdb := redis.NewClient(&redis.Options{
|
|
Addr: "localhost:6379",
|
|
Password: "",
|
|
DB: 0,
|
|
})
|
|
|
|
ctx := context.Background()
|
|
|
|
if err := rdb.Ping(ctx).Err(); err != nil {
|
|
log.Fatalf("could not connect to Redis: %v", err)
|
|
}
|
|
log.Println("connected to Redis successfully")
|
|
|
|
if err := deleteAllHierarchySets(ctx, rdb); err != nil {
|
|
log.Fatalf("error delete exist set before bulk insertion: %v", err)
|
|
}
|
|
|
|
if err := bulkInsertAllHierarchySets(ctx, rdb); err != nil {
|
|
log.Fatalf("error during bulk insertion: %v", err)
|
|
}
|
|
}
|