TestSupportedSelectWhere

26 type GlobalBoolConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[bool]

27

28 > func NewGlobalBoolSetting(key string, def bool, description string) GlobalBoolSetting { setting_gen.go

29 > return NewGlobalTypedSettingWithConverter[bool](key, convertBool, def, description)

30 > }

31

32 func NewGlobalBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) GlobalBoolConstrainedDefaultSetting {

43 type NamespaceBoolConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[bool]

44

45 > func NewNamespaceBoolSetting(key string, def bool, description string) NamespaceBoolSetting { setting_gen.go

46 > return NewNamespaceTypedSettingWithConverter[bool](key, convertBool, def, description)

47 > }

48

49 func NewNamespaceBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) NamespaceBoolConstrainedDefaultSetting {

60 type NamespaceIDBoolConstrainedDefaultSetting = NamespaceIDTypedConstrainedDefaultSetting[bool]

61

62 > func NewNamespaceIDBoolSetting(key string, def bool, description string) NamespaceIDBoolSetting { setting_gen.go

63 > return NewNamespaceIDTypedSettingWithConverter[bool](key, convertBool, def, description)

64 > }

65

66 func NewNamespaceIDBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) NamespaceIDBoolConstrainedDefaultSetting {

77 type TaskQueueBoolConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[bool]

78

79 > func NewTaskQueueBoolSetting(key string, def bool, description string) TaskQueueBoolSetting { setting_gen.go

80 > return NewTaskQueueTypedSettingWithConverter[bool](key, convertBool, def, description)

81 > }

82

83 func NewTaskQueueBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) TaskQueueBoolConstrainedDefaultSetting {

128 type DestinationBoolConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[bool]

129

130 > func NewDestinationBoolSetting(key string, def bool, description string) DestinationBoolSetting { setting_gen.go

131 > return NewDestinationTypedSettingWithConverter[bool](key, convertBool, def, description)

132 > }

133

134 func NewDestinationBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) DestinationBoolConstrainedDefaultSetting {

162 type GlobalIntConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[int]

163

164 > func NewGlobalIntSetting(key string, def int, description string) GlobalIntSetting { setting_gen.go

165 > return NewGlobalTypedSettingWithConverter[int](key, convertInt, def, description)

166 > }

167

168 func NewGlobalIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) GlobalIntConstrainedDefaultSetting {

179 type NamespaceIntConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[int]

180

181 > func NewNamespaceIntSetting(key string, def int, description string) NamespaceIntSetting { setting_gen.go

182 > return NewNamespaceTypedSettingWithConverter[int](key, convertInt, def, description)

183 > }

184

185 func NewNamespaceIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) NamespaceIntConstrainedDefaultSetting {

189 type IntPropertyFnWithNamespaceFilter = TypedPropertyFnWithNamespaceFilter[int]

190

191 > func GetIntPropertyFnFilteredByNamespace(value int) IntPropertyFnWithNamespaceFilter { setting_gen.go

192 > return GetTypedPropertyFnFilteredByNamespace(value)

193 > }

194

195 type NamespaceIDIntSetting = NamespaceIDTypedSetting[int]

213 type TaskQueueIntConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[int]

214

215 > func NewTaskQueueIntSetting(key string, def int, description string) TaskQueueIntSetting { setting_gen.go

216 > return NewTaskQueueTypedSettingWithConverter[int](key, convertInt, def, description)

217 > }

218

219 > func NewTaskQueueIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) TaskQueueIntConstrainedDefaultSetting { setting_gen.go

220 > return NewTaskQueueTypedSettingWithConstrainedDefault[int](key, convertInt, cdef, description)

221 > }

222

223 type IntPropertyFnWithTaskQueueFilter = TypedPropertyFnWithTaskQueueFilter[int]

230 type ShardIDIntConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[int]

231

232 > func NewShardIDIntSetting(key string, def int, description string) ShardIDIntSetting { setting_gen.go

233 > return NewShardIDTypedSettingWithConverter[int](key, convertInt, def, description)

234 > }

235

236 func NewShardIDIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) ShardIDIntConstrainedDefaultSetting {

264 type DestinationIntConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[int]

265

266 > func NewDestinationIntSetting(key string, def int, description string) DestinationIntSetting { setting_gen.go

267 > return NewDestinationTypedSettingWithConverter[int](key, convertInt, def, description)

268 > }

269

270 func NewDestinationIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) DestinationIntConstrainedDefaultSetting {

298 type GlobalFloatConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[float64]

299

300 > func NewGlobalFloatSetting(key string, def float64, description string) GlobalFloatSetting { setting_gen.go

301 > return NewGlobalTypedSettingWithConverter[float64](key, convertFloat, def, description)

302 > }

303

304 func NewGlobalFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) GlobalFloatConstrainedDefaultSetting {

315 type NamespaceFloatConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[float64]

316

317 > func NewNamespaceFloatSetting(key string, def float64, description string) NamespaceFloatSetting { setting_gen.go

318 > return NewNamespaceTypedSettingWithConverter[float64](key, convertFloat, def, description)

319 > }

320

321 func NewNamespaceFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) NamespaceFloatConstrainedDefaultSetting {

349 type TaskQueueFloatConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[float64]

350

351 > func NewTaskQueueFloatSetting(key string, def float64, description string) TaskQueueFloatSetting { setting_gen.go

352 > return NewTaskQueueTypedSettingWithConverter[float64](key, convertFloat, def, description)

353 > }

354

355 func NewTaskQueueFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) TaskQueueFloatConstrainedDefaultSetting {

366 type ShardIDFloatConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[float64]

367

368 > func NewShardIDFloatSetting(key string, def float64, description string) ShardIDFloatSetting { setting_gen.go

369 > return NewShardIDTypedSettingWithConverter[float64](key, convertFloat, def, description)

370 > }

371

372 func NewShardIDFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) ShardIDFloatConstrainedDefaultSetting {

400 type DestinationFloatConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[float64]

401

402 > func NewDestinationFloatSetting(key string, def float64, description string) DestinationFloatSetting { setting_gen.go

403 > return NewDestinationTypedSettingWithConverter[float64](key, convertFloat, def, description)

404 > }

405

406 func NewDestinationFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) DestinationFloatConstrainedDefaultSetting {

434 type GlobalStringConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[string]

435

436 > func NewGlobalStringSetting(key string, def string, description string) GlobalStringSetting { setting_gen.go

437 > return NewGlobalTypedSettingWithConverter[string](key, convertString, def, description)

438 > }

439

440 func NewGlobalStringSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[string], description string) GlobalStringConstrainedDefaultSetting {

570 type GlobalDurationConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[time.Duration]

571

572 > func NewGlobalDurationSetting(key string, def time.Duration, description string) GlobalDurationSetting { setting_gen.go

573 > return NewGlobalTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

574 > }

575

576 func NewGlobalDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) GlobalDurationConstrainedDefaultSetting {

587 type NamespaceDurationConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[time.Duration]

588

589 > func NewNamespaceDurationSetting(key string, def time.Duration, description string) NamespaceDurationSetting { setting_gen.go

590 > return NewNamespaceTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

591 > }

592

593 func NewNamespaceDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) NamespaceDurationConstrainedDefaultSetting {

604 type NamespaceIDDurationConstrainedDefaultSetting = NamespaceIDTypedConstrainedDefaultSetting[time.Duration]

605

606 > func NewNamespaceIDDurationSetting(key string, def time.Duration, description string) NamespaceIDDurationSetting { setting_gen.go

607 > return NewNamespaceIDTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

608 > }

609

610 func NewNamespaceIDDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) NamespaceIDDurationConstrainedDefaultSetting {

621 type TaskQueueDurationConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[time.Duration]

622

623 > func NewTaskQueueDurationSetting(key string, def time.Duration, description string) TaskQueueDurationSetting { setting_gen.go

624 > return NewTaskQueueTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

625 > }

626

627 > func NewTaskQueueDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) TaskQueueDurationConstrainedDefaultSetting { setting_gen.go

628 > return NewTaskQueueTypedSettingWithConstrainedDefault[time.Duration](key, convertDuration, cdef, description)

629 > }

630

631 type DurationPropertyFnWithTaskQueueFilter = TypedPropertyFnWithTaskQueueFilter[time.Duration]

638 type ShardIDDurationConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[time.Duration]

639

640 > func NewShardIDDurationSetting(key string, def time.Duration, description string) ShardIDDurationSetting { setting_gen.go

641 > return NewShardIDTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

642 > }

643

644 func NewShardIDDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) ShardIDDurationConstrainedDefaultSetting {

655 type TaskTypeDurationConstrainedDefaultSetting = TaskTypeTypedConstrainedDefaultSetting[time.Duration]

656

657 > func NewTaskTypeDurationSetting(key string, def time.Duration, description string) TaskTypeDurationSetting { setting_gen.go

658 > return NewTaskTypeTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

659 > }

660

661 func NewTaskTypeDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) TaskTypeDurationConstrainedDefaultSetting {

672 type DestinationDurationConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[time.Duration]

673

674 > func NewDestinationDurationSetting(key string, def time.Duration, description string) DestinationDurationSetting { setting_gen.go

675 > return NewDestinationTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

676 > }

677

678 func NewDestinationDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) DestinationDurationConstrainedDefaultSetting {

689 type ChasmTaskTypeDurationConstrainedDefaultSetting = ChasmTaskTypeTypedConstrainedDefaultSetting[time.Duration]

690

691 > func NewChasmTaskTypeDurationSetting(key string, def time.Duration, description string) ChasmTaskTypeDurationSetting { setting_gen.go

692 > return NewChasmTaskTypeTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

693 > }

694

695 func NewChasmTaskTypeDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) ChasmTaskTypeDurationConstrainedDefaultSetting {

723 type NamespaceMapConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[map[string]any]

724

725 > func NewNamespaceMapSetting(key string, def map[string]any, description string) NamespaceMapSetting { setting_gen.go

726 > return NewNamespaceTypedSettingWithConverter[map[string]any](key, convertMap, def, description)

727 > }

728

729 func NewNamespaceMapSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[map[string]any], description string) NamespaceMapConstrainedDefaultSetting {

845 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

846 // when using non-empty maps or slices as defaults, the result may not be what you want.

847 > func NewGlobalTypedSetting[T any](key string, def T, description string) GlobalTypedSetting[T] { setting_gen.go

848 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

849 > warnDefaultSharedStructure(key, def)

850 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

851 > _ = deepCopyForMapstructure(def)

852 >

853 > s := GlobalTypedSetting[T]{

854 > key: MakeKey(key),

855 > def: def,

856 > convert: ConvertStructure[T](def),

857 > description: description,

858 > }

859 > register(s)

860 > return s

861 > }

862

863 // NewGlobalTypedSettingWithConverter creates a setting with a custom converter function.

864 > func NewGlobalTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) GlobalTypedSetting[T] { setting_gen.go

865 > s := GlobalTypedSetting[T]{

866 > key: MakeKey(key),

867 > def: def,

868 > convert: convert,

869 > description: description,

870 > }

871 > register(s)

872 > return s

873 > }

874

875 // NewGlobalTypedSettingWithConstrainedDefault creates a setting with a compound default value.

885 }

886

887 > func (s GlobalTypedSetting[T]) Key() Key { return s.key } setting_gen.go

888 func (s GlobalTypedSetting[T]) Precedence() Precedence { return PrecedenceGlobal }

889 func (s GlobalTypedSetting[T]) Validate(v any) error {

981 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

982 // when using non-empty maps or slices as defaults, the result may not be what you want.

983 > func NewNamespaceTypedSetting[T any](key string, def T, description string) NamespaceTypedSetting[T] { setting_gen.go

984 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

985 > warnDefaultSharedStructure(key, def)

986 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

987 > _ = deepCopyForMapstructure(def)

988 >

989 > s := NamespaceTypedSetting[T]{

990 > key: MakeKey(key),

991 > def: def,

992 > convert: ConvertStructure[T](def),

993 > description: description,

994 > }

995 > register(s)

996 > return s

997 > }

998

999 // NewNamespaceTypedSettingWithConverter creates a setting with a custom converter function.

1000 > func NewNamespaceTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) NamespaceTypedSetting[T] { setting_gen.go

1001 > s := NamespaceTypedSetting[T]{

1002 > key: MakeKey(key),

1003 > def: def,

1004 > convert: convert,

1005 > description: description,

1006 > }

1007 > register(s)

1008 > return s

1009 > }

1010

1011 // NewNamespaceTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1021 }

1022

1023 > func (s NamespaceTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1024 func (s NamespaceTypedSetting[T]) Precedence() Precedence { return PrecedenceNamespace }

1025 func (s NamespaceTypedSetting[T]) Validate(v any) error {

1105 }

1106

1107 > func GetTypedPropertyFnFilteredByNamespace[T any](value T) TypedPropertyFnWithNamespaceFilter[T] { setting_gen.go

1108 > return func(namespace string) T {

1109 return value

1110 }

1134

1135 // NewNamespaceIDTypedSettingWithConverter creates a setting with a custom converter function.

1136 > func NewNamespaceIDTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) NamespaceIDTypedSetting[T] { setting_gen.go

1137 > s := NamespaceIDTypedSetting[T]{

1138 > key: MakeKey(key),

1139 > def: def,

1140 > convert: convert,

1141 > description: description,

1142 > }

1143 > register(s)

1144 > return s

1145 > }

1146

1147 // NewNamespaceIDTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1157 }

1158

1159 > func (s NamespaceIDTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1160 func (s NamespaceIDTypedSetting[T]) Precedence() Precedence { return PrecedenceNamespaceID }

1161 func (s NamespaceIDTypedSetting[T]) Validate(v any) error {

1253 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

1254 // when using non-empty maps or slices as defaults, the result may not be what you want.

1255 > func NewTaskQueueTypedSetting[T any](key string, def T, description string) TaskQueueTypedSetting[T] { setting_gen.go

1256 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

1257 > warnDefaultSharedStructure(key, def)

1258 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

1259 > _ = deepCopyForMapstructure(def)

1260 >

1261 > s := TaskQueueTypedSetting[T]{

1262 > key: MakeKey(key),

1263 > def: def,

1264 > convert: ConvertStructure[T](def),

1265 > description: description,

1266 > }

1267 > register(s)

1268 > return s

1269 > }

1270

1271 // NewTaskQueueTypedSettingWithConverter creates a setting with a custom converter function.

1272 > func NewTaskQueueTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) TaskQueueTypedSetting[T] { setting_gen.go

1273 > s := TaskQueueTypedSetting[T]{

1274 > key: MakeKey(key),

1275 > def: def,

1276 > convert: convert,

1277 > description: description,

1278 > }

1279 > register(s)

1280 > return s

1281 > }

1282

1283 // NewTaskQueueTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1284 > func NewTaskQueueTypedSettingWithConstrainedDefault[T any](key string, convert func(any) (T, error), cdef []TypedConstrainedValue[T], description string) TaskQueueTypedConstrainedDefaultSetting[T] { setting_gen.go

1285 > s := TaskQueueTypedConstrainedDefaultSetting[T]{

1286 > key: MakeKey(key),

1287 > cdef: cdef,

1288 > convert: convert,

1289 > description: description,

1290 > }

1291 > register(s)

1292 > return s

1293 > }

1294

1295 > func (s TaskQueueTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1296 func (s TaskQueueTypedSetting[T]) Precedence() Precedence { return PrecedenceTaskQueue }

1297 func (s TaskQueueTypedSetting[T]) Validate(v any) error {

1300 }

1301

1302 > func (s TaskQueueTypedConstrainedDefaultSetting[T]) Key() Key { return s.key } setting_gen.go

1303 func (s TaskQueueTypedConstrainedDefaultSetting[T]) Precedence() Precedence { return PrecedenceTaskQueue }

1304 func (s TaskQueueTypedConstrainedDefaultSetting[T]) Validate(v any) error {

1430

1431 // NewShardIDTypedSettingWithConverter creates a setting with a custom converter function.

1432 > func NewShardIDTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) ShardIDTypedSetting[T] { setting_gen.go

1433 > s := ShardIDTypedSetting[T]{

1434 > key: MakeKey(key),

1435 > def: def,

1436 > convert: convert,

1437 > description: description,

1438 > }

1439 > register(s)

1440 > return s

1441 > }

1442

1443 // NewShardIDTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1453 }

1454

1455 > func (s ShardIDTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1456 func (s ShardIDTypedSetting[T]) Precedence() Precedence { return PrecedenceShardID }

1457 func (s ShardIDTypedSetting[T]) Validate(v any) error {

1566

1567 // NewTaskTypeTypedSettingWithConverter creates a setting with a custom converter function.

1568 > func NewTaskTypeTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) TaskTypeTypedSetting[T] { setting_gen.go

1569 > s := TaskTypeTypedSetting[T]{

1570 > key: MakeKey(key),

1571 > def: def,

1572 > convert: convert,

1573 > description: description,

1574 > }

1575 > register(s)

1576 > return s

1577 > }

1578

1579 // NewTaskTypeTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1589 }

1590

1591 > func (s TaskTypeTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1592 func (s TaskTypeTypedSetting[T]) Precedence() Precedence { return PrecedenceTaskType }

1593 func (s TaskTypeTypedSetting[T]) Validate(v any) error {

1685 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

1686 // when using non-empty maps or slices as defaults, the result may not be what you want.

1687 > func NewDestinationTypedSetting[T any](key string, def T, description string) DestinationTypedSetting[T] { setting_gen.go

1688 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

1689 > warnDefaultSharedStructure(key, def)

1690 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

1691 > _ = deepCopyForMapstructure(def)

1692 >

1693 > s := DestinationTypedSetting[T]{

1694 > key: MakeKey(key),

1695 > def: def,

1696 > convert: ConvertStructure[T](def),

1697 > description: description,

1698 > }

1699 > register(s)

1700 > return s

1701 > }

1702

1703 // NewDestinationTypedSettingWithConverter creates a setting with a custom converter function.

1704 > func NewDestinationTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) DestinationTypedSetting[T] { setting_gen.go

1705 > s := DestinationTypedSetting[T]{

1706 > key: MakeKey(key),

1707 > def: def,

1708 > convert: convert,

1709 > description: description,

1710 > }

1711 > register(s)

1712 > return s

1713 > }

1714

1715 // NewDestinationTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1725 }

1726

1727 > func (s DestinationTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1728 func (s DestinationTypedSetting[T]) Precedence() Precedence { return PrecedenceDestination }

1729 func (s DestinationTypedSetting[T]) Validate(v any) error {

1858

1859 // NewChasmTaskTypeTypedSettingWithConverter creates a setting with a custom converter function.

1860 > func NewChasmTaskTypeTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) ChasmTaskTypeTypedSetting[T] { setting_gen.go

1861 > s := ChasmTaskTypeTypedSetting[T]{

1862 > key: MakeKey(key),

1863 > def: def,

1864 > convert: convert,

1865 > description: description,

1866 > }

1867 > register(s)

1868 > return s

1869 > }

1870

1871 // NewChasmTaskTypeTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1881 }

1882

1883 > func (s ChasmTaskTypeTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1884 func (s ChasmTaskTypeTypedSetting[T]) Precedence() Precedence { return PrecedenceChasmTaskType }

1885 func (s ChasmTaskTypeTypedSetting[T]) Validate(v any) error {

69 )

70

71 > func NewConverterLegacy(fnInterceptor FieldNameInterceptor, whereConverter ExprConverter) *ConverterLegacy { converter_legacy.go

72 > if fnInterceptor == nil {

73 fnInterceptor = &NopFieldNameInterceptor{}

74 }

75 > return &ConverterLegacy{ converter_legacy.go

76 > fnInterceptor: fnInterceptor,

77 > whereConverter: whereConverter,

78 > }

79 }

80

114 }

115

116 > func NewAndConverter(whereConverter ExprConverter) ExprConverter { converter_legacy.go

117 > return &andConverter{

118 > where: whereConverter,

119 > }

120 > }

121

122 > func NewOrConverter(whereConverter ExprConverter) ExprConverter { converter_legacy.go

123 > return &orConverter{

124 > where: whereConverter,

125 > }

126 > }

127

128 func NewRangeCondConverter(

130 fvInterceptor FieldValuesInterceptor,

131 notBetweenSupported bool,

132 > ) ExprConverter { converter_legacy.go

133 > if fnInterceptor == nil {

134 fnInterceptor = &NopFieldNameInterceptor{}

135 }

136 > if fvInterceptor == nil { converter_legacy.go

137 fvInterceptor = &NopFieldValuesInterceptor{}

138 }

139 > return &rangeCondConverter{ converter_legacy.go

140 > fnInterceptor: fnInterceptor,

141 > fvInterceptor: fvInterceptor,

142 > notBetweenSupported: notBetweenSupported,

143 > }

144 }

145

150 customSaNameType searchattribute.NameTypeMap,

151 chasmMapper *chasm.VisibilitySearchAttributesMapper,

152 > ) ExprConverter { converter_legacy.go

153 > if fnInterceptor == nil {

154 fnInterceptor = &NopFieldNameInterceptor{}

155 }

156 > if fvInterceptor == nil { converter_legacy.go

157 fvInterceptor = &NopFieldValuesInterceptor{}

158 }

159

160 > combinedTypeMap := store.CombineTypeMaps(customSaNameType, chasmMapper) converter_legacy.go

161 >

162 > return &comparisonExprConverter{

163 > fnInterceptor: fnInterceptor,

164 > fvInterceptor: fvInterceptor,

165 > allowedOperators: allowedOperators,

166 > combinedTypeMap: combinedTypeMap,

167 > chasmMapper: chasmMapper,

168 > }

169 }

170

171 > func NewIsConverter(fnInterceptor FieldNameInterceptor) ExprConverter { converter_legacy.go

172 > return &isConverter{

173 > fnInterceptor: fnInterceptor,

174 > }

175 > }

176

177 func NewNotSupportedExprConverter() ExprConverter {

181 // ConvertWhereOrderBy transforms WHERE SQL statement to Elasticsearch query.

182 // It also supports ORDER BY clause.

183 > func (c *ConverterLegacy) ConvertWhereOrderBy(whereOrderBy string) (*QueryParamsLegacy, error) { converter_legacy.go

184 > whereOrderBy = strings.TrimSpace(whereOrderBy)

185 >

186 > if whereOrderBy != "" &&

187 > !strings.HasPrefix(strings.ToLower(whereOrderBy), "order by ") &&

188 > !strings.HasPrefix(strings.ToLower(whereOrderBy), "group by ") {

189 > whereOrderBy = "where " + whereOrderBy converter_legacy.go

190 > }

191 // sqlparser can't parse just WHERE clause but instead accepts only valid SQL statement.

192 > sql := fmt.Sprintf("select * from table1 %s", whereOrderBy) converter_legacy.go

193 > return c.ConvertSql(sql)

194 }

195

197 //

198 //nolint:staticcheck

199 > func (c *ConverterLegacy) ConvertSql(sql string) (*QueryParamsLegacy, error) { converter_legacy.go

200 > stmt, err := sqlparser.Parse(sql)

201 > if err != nil {

202 return nil, NewConverterError("%s: %v", MalformedSqlQueryErrMessage, err)

203 }

204

205 > selectStmt, isSelect := stmt.(*sqlparser.Select) converter_legacy.go

206 > if !isSelect {

207 return nil, NewConverterError("%s: statement must be 'select' not %T", NotSupportedErrMessage, stmt)

208 }

209

210 > return c.convertSelect(selectStmt) converter_legacy.go

211 }

212

213 > func (c *ConverterLegacy) convertSelect(sel *sqlparser.Select) (*QueryParamsLegacy, error) { converter_legacy.go

214 > if sel.Limit != nil {

215 return nil, NewConverterError("%s: 'limit' clause", NotSupportedErrMessage)

216 }

217

218 > queryParams := &QueryParamsLegacy{} converter_legacy.go

219 > if sel.Where != nil {

220 > query, err := c.whereConverter.Convert(sel.Where.Expr) converter_legacy.go

221 > if err != nil {

222 return nil, wrapConverterError("unable to convert filter expression", err)

223 }

224 // Result must be BoolQuery.

225 > if _, isBoolQuery := query.(*elastic.BoolQuery); !isBoolQuery { converter_legacy.go

226 > query = elastic.NewBoolQuery().Filter(query) converter_legacy.go

227 > }

228 > queryParams.Query = query converter_legacy.go

229 }

230

231 > if len(sel.GroupBy) > 1 { converter_legacy.go

232 return nil, NewConverterError("%s: 'group by' clause supports only a single field", NotSupportedErrMessage)

233 }

234 > for _, groupByExpr := range sel.GroupBy { converter_legacy.go

235 _, colName, err := convertColName(c.fnInterceptor, groupByExpr, FieldNameGroupBy)

236 if err != nil {

240 }

241

242 > for _, orderByExpr := range sel.OrderBy { converter_legacy.go

243 _, colName, err := convertColName(c.fnInterceptor, orderByExpr.Expr, FieldNameSorter)

244 if err != nil {

252 }

253

254 > if len(queryParams.GroupBy) > 0 && len(queryParams.Sorter) > 0 { converter_legacy.go

255 return nil, NewConverterError(

256 "%s: 'order by' clause is not supported with 'group by' clause",

259 }

260

261 > return queryParams, nil converter_legacy.go

262 }

263

264 > func (w *WhereConverter) Convert(expr sqlparser.Expr) (elastic.Query, error) { converter_legacy.go

265 > if expr == nil {

266 return nil, errors.New("cannot be nil")

267 }

268

269 > switch e := (expr).(type) { converter_legacy.go

270 > case *sqlparser.AndExpr: converter_legacy.go

271 > return w.And.Convert(e)

272 > case *sqlparser.OrExpr: converter_legacy.go

273 > return w.Or.Convert(e)

274 > case *sqlparser.ComparisonExpr: converter_legacy.go

275 > return w.ComparisonExpr.Convert(e)

276 > case *sqlparser.RangeCond: converter_legacy.go

277 > return w.RangeCond.Convert(e)

278 > case *sqlparser.ParenExpr: converter_legacy.go

279 > return w.Convert(e.Expr)

280 > case *sqlparser.IsExpr: converter_legacy.go

281 > return w.Is.Convert(e)

282 case *sqlparser.NotExpr:

283 return nil, NewConverterError("%s: 'not' expression", NotSupportedErrMessage)

291 }

292

293 > func (a *andConverter) Convert(expr sqlparser.Expr) (elastic.Query, error) { converter_legacy.go

294 > andExpr, ok := expr.(*sqlparser.AndExpr)

295 > if !ok {

296 return nil, NewConverterError("%v is not an 'and' expression", sqlparser.String(expr))

297 }

298

299 > leftExpr := andExpr.Left converter_legacy.go

300 > rightExpr := andExpr.Right

301 > leftQuery, err := a.where.Convert(leftExpr)

302 > if err != nil {

303 return nil, err

304 }

305 > rightQuery, err := a.where.Convert(rightExpr) converter_legacy.go

306 > if err != nil {

307 return nil, err

308 }

309

310 // If left or right is a BoolQuery built from AndExpr then reuse it w/o creating new BoolQuery.

311 > lqBool, isLQBool := leftQuery.(*elastic.BoolQuery) converter_legacy.go

312 > _, isLEAnd := leftExpr.(*sqlparser.AndExpr)

313 > if isLQBool && isLEAnd {

314 > return lqBool.Filter(rightQuery), nil converter_legacy.go

315 > }

316

317 > rqBool, isRQBool := rightQuery.(*elastic.BoolQuery) converter_legacy.go

318 > _, isREAnd := rightExpr.(*sqlparser.AndExpr)

319 > if isRQBool && isREAnd {

320 return rqBool.Filter(leftQuery), nil

321 }

322

323 > return elastic.NewBoolQuery().Filter(leftQuery, rightQuery), nil converter_legacy.go

324 }

325

326 > func (o *orConverter) Convert(expr sqlparser.Expr) (elastic.Query, error) { converter_legacy.go

327 > orExpr, ok := expr.(*sqlparser.OrExpr)

328 > if !ok {

329 return nil, NewConverterError("%v is not an 'or' expression", sqlparser.String(expr))

330 }

331

332 > leftExpr := orExpr.Left converter_legacy.go

333 > rightExpr := orExpr.Right

334 > leftQuery, err := o.where.Convert(leftExpr)

335 > if err != nil {

336 return nil, err

337 }

338 > rightQuery, err := o.where.Convert(rightExpr) converter_legacy.go

339 > if err != nil {

340 return nil, err

341 }

342

343 // If left or right is a BoolQuery built from OrExpr then reuse it w/o creating new BoolQuery.

344 > lqBool, isLQBool := leftQuery.(*elastic.BoolQuery) converter_legacy.go

345 > _, isLEOr := leftExpr.(*sqlparser.OrExpr)

346 > if isLQBool && isLEOr {

347 return lqBool.Should(rightQuery), nil

348 }

349

350 > rqBool, isRQBool := rightQuery.(*elastic.BoolQuery) converter_legacy.go

351 > _, isREOr := rightExpr.(*sqlparser.OrExpr)

352 > if isRQBool && isREOr {

353 return rqBool.Should(leftQuery), nil

354 }

355

356 > return elastic.NewBoolQuery().Should(leftQuery, rightQuery), nil converter_legacy.go

357 }

358

359 > func (r *rangeCondConverter) Convert(expr sqlparser.Expr) (elastic.Query, error) { converter_legacy.go

360 > rangeCond, ok := expr.(*sqlparser.RangeCond)

361 > if !ok {

362 return nil, NewConverterError("%v is not a range condition", sqlparser.String(expr))

363 }

364

365 > alias, colName, err := convertColName(r.fnInterceptor, rangeCond.Left, FieldNameFilter) converter_legacy.go

366 > if err != nil {

367 return nil, wrapConverterError("unable to convert left part of 'between' expression", err)

368 }

369

370 > fromValue, err := sqlquery.ParseValue(sqlparser.String(rangeCond.From)) converter_legacy.go

371 > if err != nil {

372 return nil, err

373 }

374 > toValue, err := sqlquery.ParseValue(sqlparser.String(rangeCond.To)) converter_legacy.go

375 > if err != nil {

376 return nil, err

377 }

378

379 > values, err := r.fvInterceptor.Values(alias, colName, fromValue, toValue) converter_legacy.go

380 > if err != nil {

381 return nil, wrapConverterError("unable to convert values of 'between' expression", err)

382 }

383 > fromValue = values[0] converter_legacy.go

384 > toValue = values[1]

385 >

386 > var query elastic.Query

387 > switch rangeCond.Operator {

388 > case "between":

389 > query = elastic.NewRangeQuery(colName).Gte(fromValue).Lte(toValue)

390 > case "not between": converter_legacy.go

391 > if !r.notBetweenSupported {

392 return nil, NewConverterError("%s: 'not between' expression", NotSupportedErrMessage)

393 }

394 > query = elastic.NewBoolQuery().MustNot(elastic.NewRangeQuery(colName).Gte(fromValue).Lte(toValue)) converter_legacy.go

395 default:

396 return nil, NewConverterError("%s: range condition operator must be 'between' or 'not between'", InvalidExpressionErrMessage)

397 }

398 > return query, nil converter_legacy.go

399 }

400

401 > func (i *isConverter) Convert(expr sqlparser.Expr) (elastic.Query, error) { converter_legacy.go

402 > isExpr, ok := expr.(*sqlparser.IsExpr)

403 > if !ok {

404 return nil, NewConverterError("%v is not an 'is' expression", sqlparser.String(expr))

405 }

406

407 > _, colName, err := convertColName(i.fnInterceptor, isExpr.Expr, FieldNameFilter) converter_legacy.go

408 > if err != nil {

409 return nil, wrapConverterError("unable to convert left part of 'is' expression", err)

410 }

411

412 > var query elastic.Query converter_legacy.go

413 > switch isExpr.Operator {

414 > case "is null":

415 > query = elastic.NewBoolQuery().MustNot(elastic.NewExistsQuery(colName))

416 > case "is not null": converter_legacy.go

417 > query = elastic.NewExistsQuery(colName)

418 default:

419 return nil, NewConverterError("%s: 'is' operator can be used with 'null' and 'not null' only", InvalidExpressionErrMessage)

420 }

421

422 > return query, nil converter_legacy.go

423 }

424

425 > func (c *comparisonExprConverter) Convert(expr sqlparser.Expr) (elastic.Query, error) { converter_legacy.go

426 > comparisonExpr, ok := expr.(*sqlparser.ComparisonExpr)

427 > if !ok {

428 return nil, NewConverterError("%v is not a comparison expression", sqlparser.String(expr))

429 }

430

431 > alias, colName, err := convertColName(c.fnInterceptor, comparisonExpr.Left, FieldNameFilter) converter_legacy.go

432 > if err != nil {

433 return nil, wrapConverterError(

434 fmt.Sprintf("unable to convert left side of %q", sqlparser.String(expr)),

437 }

438

439 > colValue, err := convertComparisonExprValue(comparisonExpr.Right) converter_legacy.go

440 > if err != nil {

441 return nil, wrapConverterError(

442 fmt.Sprintf("unable to convert right side of %q", sqlparser.String(expr)),

445 }

446

447 > colValues, isArray := colValue.([]any) converter_legacy.go

448 > // colValue should be an array only for "in (1,2,3)" queries.

449 > if !isArray {

450 > colValues = []any{colValue}

451 > }

452

453 > colValues, err = c.fvInterceptor.Values(alias, colName, colValues...) converter_legacy.go

454 > if err != nil {

455 return nil, wrapConverterError("unable to convert values of comparison expression", err)

456 }

457

458 > if _, ok := c.allowedOperators[comparisonExpr.Operator]; !ok { converter_legacy.go

459 return nil, NewConverterError("operator '%v' not allowed in comparison expression", comparisonExpr.Operator)

460 }

461

462 > tp, err := c.combinedTypeMap.GetType(colName) converter_legacy.go

463 > if err != nil {

464 return nil, err

465 }

466

467 > var query elastic.Query converter_legacy.go

468 > //nolint:revive // missing default case

469 > switch comparisonExpr.Operator {

470 > case sqlparser.GreaterEqualStr: converter_legacy.go

471 > query = elastic.NewRangeQuery(colName).Gte(colValues[0])

472 > case sqlparser.LessEqualStr:

473 > query = elastic.NewRangeQuery(colName).Lte(colValues[0])

474 > case sqlparser.GreaterThanStr: converter_legacy.go

475 > query = elastic.NewRangeQuery(colName).Gt(colValues[0])

476 > case sqlparser.LessThanStr: converter_legacy.go

477 > query = elastic.NewRangeQuery(colName).Lt(colValues[0])

478 > case sqlparser.EqualStr: converter_legacy.go

479 > // Not elastic.NewTermQuery to support partial word match for String custom search attributes.

480 > if tp == enumspb.INDEXED_VALUE_TYPE_KEYWORD || tp == enumspb.INDEXED_VALUE_TYPE_KEYWORD_LIST {

481 > query = elastic.NewTermQuery(colName, colValues[0]) converter_legacy.go

482 > } else { converter_legacy.go

483 > query = elastic.NewMatchQuery(colName, colValues[0]) converter_legacy.go

484 > }

485 > case sqlparser.NotEqualStr: converter_legacy.go

486 > // Not elastic.NewTermQuery to support partial word match for String custom search attributes.

487 > if tp == enumspb.INDEXED_VALUE_TYPE_KEYWORD || tp == enumspb.INDEXED_VALUE_TYPE_KEYWORD_LIST {

488 > query = elastic.NewBoolQuery().MustNot(elastic.NewTermQuery(colName, colValues[0]))

489 > } else {

490 query = elastic.NewBoolQuery().MustNot(elastic.NewMatchQuery(colName, colValues[0]))

491 }

492 > case sqlparser.InStr: converter_legacy.go

493 > query = elastic.NewTermsQuery(colName, colValues...)

494 > case sqlparser.NotInStr: converter_legacy.go

495 > query = elastic.NewBoolQuery().MustNot(elastic.NewTermsQuery(colName, colValues...))

496 > case sqlparser.StartsWithStr:

497 > v, ok := colValues[0].(string)

498 > if !ok {

499 return nil, NewConverterError("right-hand side of '%v' must be a string", comparisonExpr.Operator)

500 }

501 > query = elastic.NewPrefixQuery(colName, v) converter_legacy.go

502 > case sqlparser.NotStartsWithStr:

503 > v, ok := colValues[0].(string)

504 > if !ok {

505 return nil, NewConverterError("right-hand side of '%v' must be a string", comparisonExpr.Operator)

506 }

507 > query = elastic.NewBoolQuery().MustNot(elastic.NewPrefixQuery(colName, v)) converter_legacy.go

508 }

509

510 > return query, nil converter_legacy.go

511 }

512

513 // convertComparisonExprValue returns a string, int64, float64, bool or

514 // a slice with each value of one of those types.

515 > func convertComparisonExprValue(expr sqlparser.Expr) (any, error) { converter_legacy.go

516 > switch e := expr.(type) {

517 > case *sqlparser.SQLVal: converter_legacy.go

518 > v, err := sqlquery.ParseValue(sqlparser.String(e))

519 > if err != nil {

520 return nil, err

521 }

522 > return v, nil converter_legacy.go

523 > case sqlparser.BoolVal: converter_legacy.go

524 > return bool(e), nil

525 > case sqlparser.ValTuple: converter_legacy.go

526 > // This is "in (1,2,3)" case.

527 > exprs := []sqlparser.Expr(e)

528 > var result []any

529 > for _, expr := range exprs {

530 > v, err := convertComparisonExprValue(expr)

531 > if err != nil {

532 return nil, err

533 }

534 > result = append(result, v) converter_legacy.go

535 }

536 > return result, nil converter_legacy.go

537 case *sqlparser.GroupConcatExpr:

538 return nil, NewConverterError("%s: 'group_concat'", NotSupportedErrMessage)

554 }

555

556 > func convertColName(fnInterceptor FieldNameInterceptor, colNameExpr sqlparser.Expr, usage FieldNameUsage) (alias string, fieldName string, err error) { converter_legacy.go

557 > colName, isColName := colNameExpr.(*sqlparser.ColName)

558 > if !isColName {

559 return "", "", NewConverterError("%s: must be a column name but was %T", InvalidExpressionErrMessage, colNameExpr)

560 }

561

562 > colNameStr := sqlparser.String(colName) converter_legacy.go

563 > colNameStr = strings.ReplaceAll(colNameStr, "`", "")

564 > fieldName, err = fnInterceptor.Name(colNameStr, usage)

565 > if err != nil {

566 return "", "", err

567 }

568

569 > return colNameStr, fieldName, nil converter_legacy.go

570 }