UE::Editor::DataStorage Namespace Reference

Namespaces
namespace	ColumnUtils
namespace	Compatibility
namespace	Private
namespace	Queries
namespace	Ui

Classes
class	FAttributeBinder
class	FColumnMetaData
class	FColumnsMetaDataView
class	FColumnSorterInterface
class	FComboMetaDataView
struct	FDynamicColumnDescription
class	FForwardingMetaDataView
class	FGenericMetaDataView
struct	FHasher
struct	FHierarchyHandle
struct	FHierarchyRegistrationParams
struct	FKeyComparer
struct	FKeyCopy
struct	FKeyMove
struct	FKeyToKeyViewConverter
struct	FKeyViewComparer
struct	FKeyViewToKeyConverter
class	FMapKey
class	FMapKeyView
class	FMetaData
class	FMetaDataBase
class	FMetaDataEntryView
class	FMetaDataView
struct	FPrefixInfo
struct	FQueryDescription
class	FQueryMetaDataView
struct	FQueryResult
class	FRowHandleArray
class	FRowHandleArrayView
struct	FSortById
struct	FSortCaseInsensitive
struct	FSortCaseSensitive
class	FTextAttributeFormatted
struct	FToString
class	FValueTag
struct	ICommonQueryContext
struct	ICommonQueryWithEnvironmentContext
class	ICompatibilityProvider
class	ICoreProvider
struct	IDirectQueryContext
struct	IQueryContext
struct	IsSortByName
struct	IsSortByName< TSortByName< Flags > >
struct	ISubqueryContext
class	ITedsWidget
class	IUiProvider
class	TColumnSorterInterface
class	TColumnSorterInterface< FColumnSorterInterface::ESortType::ComparativeSort, ColumnType >
class	TColumnSorterInterface< FColumnSorterInterface::ESortType::FixedSize64, ColumnType >
class	TColumnSorterInterface< FColumnSorterInterface::ESortType::FixedSizeOnly, ColumnType >
class	TColumnSorterInterface< FColumnSorterInterface::ESortType::HybridSort, ColumnType >
struct	TOverloaded
struct	TSortByName
struct	TSortNameView
struct	TSortStringView
struct	TSortTypeInfo
struct	TSortTypeInfo< NameType >
struct	TSortTypeInfo< NumericType >
struct	TSortTypeInfo< StringType >
struct	TSortTypeInfo< TSortNameView< By > >
struct	TSortTypeInfo< TSortStringView< Casing, T > >
struct	TTypedElementColumnTypeList
struct	TTypedElementSubsystemTraits

Concepts
concept	TValueTagType
concept	THasDynamicColumnTemplateSpecifier
concept	TDynamicColumnTemplate
concept	TDataColumnType
concept	TTagColumnType
concept	TColumnType
concept	TEnumType
concept	SortCase
concept	SortBy

Typedefs
using	FColumn = FEditorDataStorageColumn
using	FTag = FEditorDataStorageTag
using	RowCreationCallbackRef = TFunctionRef< void(RowHandle Row)>
using	ColumnCreationCallbackRef = TFunctionRef< void(void *Column, const UScriptStruct &ColumnType)>
using	ColumnListCallbackRef = TFunctionRef< void(const UScriptStruct &ColumnType)>
using	ColumnListWithDataCallbackRef = TFunctionRef< void(void *Column, const UScriptStruct &ColumnType)>
using	ColumnCopyOrMoveCallback = void(*)(const UScriptStruct &ColumnType, void *Destination, void *Source)
using	TableHandle = uint64
using	RowHandle = uint64
using	QueryHandle = uint64
using	QueryCallback = TFunction< void(const FQueryDescription &, IQueryContext &)>
using	QueryCallbackRef = TFunctionRef< void(const FQueryDescription &, IQueryContext &)>
using	DirectQueryCallback = TFunction< void(const FQueryDescription &, IDirectQueryContext &)>
using	DirectQueryCallbackRef = TFunctionRef< void(const FQueryDescription &, IDirectQueryContext &)>
using	IndexHash = uint64
using	FUObjectIdNameColumn = FEditorDataStorageUObjectIdNameColumn
using	FLevelColumn = FTypedElementLevelColumn
using	FLevelTag = FEditorDataStorageLevelTag
using	FWorldTag = FEditorDataStorageWorldTag
using	FUrlColumn = FEditorDataStorageUrlColumn
using	FWebImageColumn = FEditorDataStorageWebImageColumn
using	MetaDataType = TVariant< bool, uint64, int64, double, FString >
using	MetaDataTypeView = TVariant< FEmptyVariantState, bool, uint64, int64, double, const FString * >
using	FTypedElementOnDataStorageCreation = FSimpleMulticastDelegate
using	FTypedElementOnDataStorageDestruction = FSimpleMulticastDelegate
using	FTypedElementOnDataStorageUpdate = FSimpleMulticastDelegate
using	FWidgetConstructor = FTypedElementWidgetConstructor
using	FSimpleWidgetConstructor = FSimpleWidgetConstructor
using	SubqueryCallback = TFunction< void(const FQueryDescription &, ISubqueryContext &)>
using	SubqueryCallbackRef = TFunctionRef< void(const FQueryDescription &, ISubqueryContext &)>

Enumerations
enum class	EQueryTickPhase : uint8 {   PrePhysics , DuringPhysics , PostPhysics , FrameEnd ,   Max }
enum class	EQueryTickGroups : uint8 {   Default , PreUpdate , Update , PostUpdate ,   SyncExternalToDataStorage , SyncDataStorageToExternal , SyncWidgets , Max }
enum class	EQueryCallbackType : uint8 {   None , Processor , ObserveAdd , ObserveRemove ,   PhasePreparation , PhaseFinalization , Max }
enum class	EExecutionMode : uint8 { Default , GameThread , Threaded , ThreadedChunks }
enum class	EQueryAccessType : uint8 { ReadOnly , OptionalReadOnly , ReadWrite , NUM }
enum class	EQueryDependencyFlags : uint8 { None = 0 , ReadOnly = 1 << 0 , GameThreadBound = 1 << 1 , AlwaysRefresh = 1 << 2 }
enum class	ENameSortBy : bool { Id , String }
enum class	ESortByNameFlags { Default = 0 , WithNone = 1 << 0 , RemoveLeadingSlash = 1 << 1 }
enum class	EDirectQueryExecutionFlags : uint32 {   Default = 0 , ParallelizeChunks = 1 << 0 , AutoBalanceParallelChunkProcessing = 1 << 1 , IgnoreActiveState = 1 << 2 ,   AllowBoundQueries = 1 << 3 , UE_DEPRECATED =("5.7", "Activation counts are no longer supported.") = IgnoreActiveState }
enum class	ERunQueryFlags : uint32 {   Default = 0 , ParallelizeChunks = 1 << 0 , AutoBalanceParallelChunkProcessing = 1 << 1 , IgnoreActiveState = 1 << 2 ,   AllowBoundQueries = 1 << 3 }

Functions
uint32	GetTypeHash (const FValueTag &InName)
uint32	GetTypeHash (const FDynamicColumnDescription &Descriptor)
FSimpleMulticastDelegate &	OnEditorDataStorageFeaturesEnabled ()
bool	AreEditorDataStorageFeaturesEnabled ()
template<class... Ts>
	TOverloaded (Ts...) -> TOverloaded< Ts... >
template<typename T >
const T *	GetDataStorageFeature (const FName InName)
template<typename T >
T *	GetMutableDataStorageFeature (const FName InName)
	ENUM_CLASS_FLAGS (EQueryDependencyFlags)
template<typename T >
IndexHash	GenerateIndexHash (const T *Object)
template<typename T >
IndexHash	GenerateIndexHash (const TWeakObjectPtr< T > &Object)
template<typename T >
IndexHash	GenerateIndexHash (const TObjectPtr< T > &Object)
template<typename T >
IndexHash	GenerateIndexHash (const TStrongObjectPtr< T > &Object)
IndexHash	GenerateIndexHash (const FString &Object)
IndexHash	GenerateIndexHash (FStringView Object)
IndexHash	GenerateIndexHash (FName Object)
IndexHash	GenerateIndexHash (const FSoftObjectPath &ObjectPath)
	ENUM_CLASS_FLAGS (FRowHandleArrayView::EFlags)
template<SortCase Casing, Private::SortStringViewCopyableType View>
	TSortStringView (Casing, const View &) -> TSortStringView< Casing, TStringView< typename View::ElementType > >
template<SortCase Casing>
	TSortStringView (Casing, const FText &) -> TSortStringView< Casing, FStringView >
template<SortBy By>
	TSortNameView (By, const FName &) -> TSortNameView< By >
template<typename... ValueTypes>
FPrefixInfo	CreateSortPrefix (uint32 ByteIndex, ValueTypes &&... Values)
template<typename Type >
Type *	GetRawPointer (const TWeakObjectPtr< Type > Object)
template<typename Type >
Type *	GetRawPointer (const TObjectPtr< Type > Object)
template<typename Type >
Type *	GetRawPointer (const TStrongObjectPtr< Type > Object)
template<typename Type >
Type *	GetRawPointer (const TObjectKey< Type > Object)
template<typename Type >
Type *	GetRawPointer (const TUniquePtr< Type > Object)
template<typename Type >
Type *	GetRawPointer (const TSharedPtr< Type > Object)
template<typename Type >
Type *	GetRawPointer (Type *Object)
template<typename Type >
Type *	GetRawPointer (Type &Object)
	ENUM_CLASS_FLAGS (EDirectQueryExecutionFlags)
	ENUM_CLASS_FLAGS (ERunQueryFlags)

Variables
const FName	StorageFeatureName = TEXT("EditorDataStorage")
const FName	CompatibilityFeatureName = TEXT("EditorDataStorageCompatibility")
const FName	UiFeatureName = TEXT("EditorDataStorageUi")
FAutoConsoleCommand	CVarAddDebugRows
FAutoConsoleCommand	CVarResetDebugEntities

Typedef Documentation

ColumnCopyOrMoveCallback

using UE::Editor::DataStorage::ColumnCopyOrMoveCallback = typedef void (*)(const UScriptStruct& ColumnType, void* Destination, void* Source)

ColumnCreationCallbackRef

using UE::Editor::DataStorage::ColumnCreationCallbackRef = typedef TFunctionRef<void(void* Column, const UScriptStruct& ColumnType)>

ColumnListCallbackRef

using UE::Editor::DataStorage::ColumnListCallbackRef = typedef TFunctionRef<void(const UScriptStruct& ColumnType)>

ColumnListWithDataCallbackRef

using UE::Editor::DataStorage::ColumnListWithDataCallbackRef = typedef TFunctionRef<void(void* Column, const UScriptStruct& ColumnType)>

DirectQueryCallback

using UE::Editor::DataStorage::DirectQueryCallback = typedef TFunction<void(const FQueryDescription&, IDirectQueryContext&)>

DirectQueryCallbackRef

using UE::Editor::DataStorage::DirectQueryCallbackRef = typedef TFunctionRef<void(const FQueryDescription&, IDirectQueryContext&)>

FColumn

using UE::Editor::DataStorage::FColumn = typedef FEditorDataStorageColumn

FLevelColumn

using UE::Editor::DataStorage::FLevelColumn = typedef FTypedElementLevelColumn

FLevelTag

using UE::Editor::DataStorage::FLevelTag = typedef FEditorDataStorageLevelTag

FSimpleWidgetConstructor

using UE::Editor::DataStorage::FSimpleWidgetConstructor = typedef FSimpleWidgetConstructor

FTag

using UE::Editor::DataStorage::FTag = typedef FEditorDataStorageTag

FTypedElementOnDataStorageCreation

using UE::Editor::DataStorage::FTypedElementOnDataStorageCreation = typedef FSimpleMulticastDelegate

FTypedElementOnDataStorageDestruction

using UE::Editor::DataStorage::FTypedElementOnDataStorageDestruction = typedef FSimpleMulticastDelegate

FTypedElementOnDataStorageUpdate

using UE::Editor::DataStorage::FTypedElementOnDataStorageUpdate = typedef FSimpleMulticastDelegate

FUObjectIdNameColumn

using UE::Editor::DataStorage::FUObjectIdNameColumn = typedef FEditorDataStorageUObjectIdNameColumn

FUrlColumn

using UE::Editor::DataStorage::FUrlColumn = typedef FEditorDataStorageUrlColumn

FWebImageColumn

using UE::Editor::DataStorage::FWebImageColumn = typedef FEditorDataStorageWebImageColumn

FWidgetConstructor

using UE::Editor::DataStorage::FWidgetConstructor = typedef FTypedElementWidgetConstructor

FWorldTag

using UE::Editor::DataStorage::FWorldTag = typedef FEditorDataStorageWorldTag

IndexHash

using UE::Editor::DataStorage::IndexHash = typedef uint64

MetaDataType

using UE::Editor::DataStorage::MetaDataType = typedef TVariant<bool, uint64, int64, double, FString>

MetaDataTypeView

using UE::Editor::DataStorage::MetaDataTypeView = typedef TVariant<FEmptyVariantState, bool, uint64, int64, double, const FString*>

QueryCallback

using UE::Editor::DataStorage::QueryCallback = typedef TFunction<void(const FQueryDescription&, IQueryContext&)>

QueryCallbackRef

using UE::Editor::DataStorage::QueryCallbackRef = typedef TFunctionRef<void(const FQueryDescription&, IQueryContext&)>

QueryHandle

using UE::Editor::DataStorage::QueryHandle = typedef uint64

RowCreationCallbackRef

using UE::Editor::DataStorage::RowCreationCallbackRef = typedef TFunctionRef<void(RowHandle Row)>

RowHandle

using UE::Editor::DataStorage::RowHandle = typedef uint64

SubqueryCallback

using UE::Editor::DataStorage::SubqueryCallback = typedef TFunction<void(const FQueryDescription&, ISubqueryContext&)>

SubqueryCallbackRef

using UE::Editor::DataStorage::SubqueryCallbackRef = typedef TFunctionRef<void(const FQueryDescription&, ISubqueryContext&)>

TableHandle

using UE::Editor::DataStorage::TableHandle = typedef uint64

Enumeration Type Documentation

EDirectQueryExecutionFlags

enum class UE::Editor::DataStorage::EDirectQueryExecutionFlags : uint32

strong

Enumerator
Default
ParallelizeChunks
AutoBalanceParallelChunkProcessing
IgnoreActiveState
AllowBoundQueries
UE_DEPRECATED

EExecutionMode

enum class UE::Editor::DataStorage::EExecutionMode : uint8

strong

Enumerator
Default
GameThread
Threaded
ThreadedChunks

ENameSortBy

enum class UE::Editor::DataStorage::ENameSortBy : bool

strong

Enumerator
Id
String

EQueryAccessType

enum class UE::Editor::DataStorage::EQueryAccessType : uint8

strong

Enumerator
ReadOnly	Provide read-only access.
OptionalReadOnly	Provide read-only access, but do not include when finding matching tables.
ReadWrite	Provide read and write access.
NUM

EQueryCallbackType

enum class UE::Editor::DataStorage::EQueryCallbackType : uint8

strong

Enumerator
None	No callback provided.
Processor	The query will be run every tick if at least one row matches.
ObserveAdd	The query will be run when a row is added that matches the query. The first recorded column will be actively monitored for changes.
ObserveRemove	The query will be run when a row is removed that matches the query. The first recorded column will be actively monitored for changes.
PhasePreparation	At the start of the assigned phase this query will run if there are any matches. These queries will have any deferred operations such as adding/removing rows/columns executed before the phase starts. This introduces sync points that hinder performance and are therefore recommended only for queries that save on work later in the phase such as repeated checks for validity.
PhaseFinalization	At the end of the assigned phase this query will run if there are any matches. These queries will have any deferred operations such as adding/removing rows/columns executed before the phase ends. This introduces sync points that hinder performance and are therefore recommended only cases where delaying deferred operations is not possible e.g. when tables are known to be referenced outside the update cycle.
Max

EQueryDependencyFlags

enum class UE::Editor::DataStorage::EQueryDependencyFlags : uint8

strong

Enumerator
None
ReadOnly	If set the dependency is accessed as read-only. If not set the dependency requires Read/Write access.
GameThreadBound	If set the dependency can only be used from the game thread, otherwise it can be accessed from any thread.
AlwaysRefresh	If set the dependency will be re-fetched every iteration, otherwise only if not fetched before.

EQueryTickGroups

enum class UE::Editor::DataStorage::EQueryTickGroups : uint8

strong

Enumerator
Default	The standard group to run work in.
PreUpdate	General group that prepares for updating.
Update	General group that's used for updating data.
PostUpdate	General group that completes for updating.
SyncExternalToDataStorage	The group for queries that need to sync data from external sources such as subsystems or the world into the Data Storage. These typically run early in a phase.
SyncDataStorageToExternal	The group for queries that need to sync data from the Data Storage to external sources such as subsystems or the world into. These typically run late in a phase.
SyncWidgets	Queries grouped under this name will sync data to/from widgets.
Max

EQueryTickPhase

enum class UE::Editor::DataStorage::EQueryTickPhase : uint8

strong

Enumerator
PrePhysics
DuringPhysics
PostPhysics
FrameEnd
Max

ERunQueryFlags

enum class UE::Editor::DataStorage::ERunQueryFlags : uint32

strong

Enumerator
Default
ParallelizeChunks
AutoBalanceParallelChunkProcessing
IgnoreActiveState
AllowBoundQueries

ESortByNameFlags

enum class UE::Editor::DataStorage::ESortByNameFlags

strong

Enumerator
Default
WithNone
RemoveLeadingSlash	If an empty name is found, use the string "None" to represent it.

Function Documentation

AreEditorDataStorageFeaturesEnabled()

TYPEDELEMENTFRAMEWORK_API bool UE::Editor::DataStorage::AreEditorDataStorageFeaturesEnabled

(

)

CreateSortPrefix()

template<typename... ValueTypes>

FPrefixInfo UE::Editor::DataStorage::CreateSortPrefix	(	uint32	ByteIndex,
		ValueTypes &&...	Values
	)

ENUM_CLASS_FLAGS() [1/4]

UE::Editor::DataStorage::ENUM_CLASS_FLAGS

(

EDirectQueryExecutionFlags

)

ENUM_CLASS_FLAGS() [2/4]

UE::Editor::DataStorage::ENUM_CLASS_FLAGS

(

EQueryDependencyFlags

)

ENUM_CLASS_FLAGS() [3/4]

UE::Editor::DataStorage::ENUM_CLASS_FLAGS

(

ERunQueryFlags

)

ENUM_CLASS_FLAGS() [4/4]

UE::Editor::DataStorage::ENUM_CLASS_FLAGS

(

FRowHandleArrayView::EFlags

)

GenerateIndexHash() [1/8]

IndexHash UE::Editor::DataStorage::GenerateIndexHash ( const FSoftObjectPath &  ObjectPath )

inline

GenerateIndexHash() [2/8]

IndexHash UE::Editor::DataStorage::GenerateIndexHash ( const FString &  Object )

inline

GenerateIndexHash() [3/8]

template<typename T >

IndexHash UE::Editor::DataStorage::GenerateIndexHash

(

const T *

Object

)

GenerateIndexHash() [4/8]

template<typename T >

IndexHash UE::Editor::DataStorage::GenerateIndexHash

(

const TObjectPtr< T > &

Object

)

GenerateIndexHash() [5/8]

template<typename T >

IndexHash UE::Editor::DataStorage::GenerateIndexHash

(

const TStrongObjectPtr< T > &

Object

)

GenerateIndexHash() [6/8]

template<typename T >

IndexHash UE::Editor::DataStorage::GenerateIndexHash

(

const TWeakObjectPtr< T > &

Object

)

GenerateIndexHash() [7/8]

IndexHash UE::Editor::DataStorage::GenerateIndexHash ( FName  Object )

inline

GenerateIndexHash() [8/8]

IndexHash UE::Editor::DataStorage::GenerateIndexHash ( FStringView  Object )

inline

GetDataStorageFeature()

template<typename T >

const T * UE::Editor::DataStorage::GetDataStorageFeature

(

const FName

InName

)

GetMutableDataStorageFeature()

template<typename T >

T * UE::Editor::DataStorage::GetMutableDataStorageFeature

(

const FName

InName

)

GetRawPointer() [1/8]

template<typename Type >

Type * UE::Editor::DataStorage::GetRawPointer

(

const TObjectKey< Type >

Object

)

GetRawPointer() [2/8]

template<typename Type >

Type * UE::Editor::DataStorage::GetRawPointer

(

const TObjectPtr< Type >

Object

)

GetRawPointer() [3/8]

template<typename Type >

Type * UE::Editor::DataStorage::GetRawPointer

(

const TSharedPtr< Type >

Object

)

GetRawPointer() [4/8]

template<typename Type >

Type * UE::Editor::DataStorage::GetRawPointer

(

const TStrongObjectPtr< Type >

Object

)

GetRawPointer() [5/8]

template<typename Type >

Type * UE::Editor::DataStorage::GetRawPointer

(

const TUniquePtr< Type >

Object

)

GetRawPointer() [6/8]

template<typename Type >

Type * UE::Editor::DataStorage::GetRawPointer

(

const TWeakObjectPtr< Type >

Object

)

GetRawPointer() [7/8]

template<typename Type >

Type * UE::Editor::DataStorage::GetRawPointer

(

Type &

Object

)

GetRawPointer() [8/8]

template<typename Type >

Type * UE::Editor::DataStorage::GetRawPointer

(

Type *

Object

)

GetTypeHash() [1/2]

uint32 UE::Editor::DataStorage::GetTypeHash

(

const FDynamicColumnDescription &

Descriptor

)

GetTypeHash() [2/2]

uint32 UE::Editor::DataStorage::GetTypeHash

(

const FValueTag &

InName

)

OnEditorDataStorageFeaturesEnabled()

TYPEDELEMENTFRAMEWORK_API FSimpleMulticastDelegate & UE::Editor::DataStorage::OnEditorDataStorageFeaturesEnabled

(

)

TOverloaded()

template<class... Ts>

UE::Editor::DataStorage::TOverloaded

(

Ts...

)

-> TOverloaded< Ts... >

TSortNameView()

template<SortBy By>

UE::Editor::DataStorage::TSortNameView	(	By	,
		const FName &
	)		-> TSortNameView< By >

TSortStringView() [1/2]

template<SortCase Casing>

UE::Editor::DataStorage::TSortStringView	(	Casing	,
		const FText &
	)		-> TSortStringView< Casing, FStringView >

TSortStringView() [2/2]

template<SortCase Casing, Private::SortStringViewCopyableType View>

UE::Editor::DataStorage::TSortStringView	(	Casing	,
		const View &
	)		-> TSortStringView< Casing, TStringView< typename View::ElementType > >

Variable Documentation

CompatibilityFeatureName

TYPEDELEMENTFRAMEWORK_API const FName UE::Editor::DataStorage::CompatibilityFeatureName = TEXT("EditorDataStorageCompatibility")

CVarAddDebugRows

FAutoConsoleCommand UE::Editor::DataStorage::CVarAddDebugRows

Initial value:

= FAutoConsoleCommand(
        TEXT("Teds.Debug.PerformanceTest.AddRows"),
        TEXT("Teds.Debug.PerformanceTest.AddRows <NumRows>;  NumRows = number of rows to add"),
        FConsoleCommandWithArgsDelegate::CreateLambda([](const TArray<FString>& Args)
        {
            if (Args.Num() > 0)
            {
                int32 EntitiesToAdd;
                LexFromString(EntitiesToAdd, *Args[0]);
 
                ICoreProvider* DataStorageInterface = GetMutableDataStorageFeature<ICoreProvider>(StorageFeatureName);
            
                DataStorageInterface->BatchAddRow(Private::PerformanceTestCommandTable, EntitiesToAdd, [DataStorageInterface](RowHandle Row)
                    {
                        FTest_PingPongPrePhys* Column = DataStorageInterface->GetColumn<FTest_PingPongPrePhys>(Row);
                        Column->Value = 0;
                    });
            }
        }
    ))

CVarResetDebugEntities

FAutoConsoleCommand UE::Editor::DataStorage::CVarResetDebugEntities

Initial value:

= FAutoConsoleCommand(
        TEXT("Teds.Debug.PerformanceTest.RemoveAllRows"),
        TEXT("Removes all added rows for the performance test"),
        FConsoleCommandWithArgsDelegate::CreateLambda([](const TArray<FString>& Args)
        {
            using namespace UE::Editor::DataStorage::Queries;
 
            ICoreProvider* DataStorageInterface = GetMutableDataStorageFeature<ICoreProvider>(StorageFeatureName);
        
            QueryHandle Query = DataStorageInterface->RegisterQuery(
                Select().Where().All<FTest_PingPongPrePhys>().Compile());
 
            TArray<RowHandle> RowsToDelete;
 
            DataStorageInterface->RunQuery(Query, CreateDirectQueryCallbackBinding([&RowsToDelete](const IDirectQueryContext& Context, const RowHandle* RowArray)
            {
                RowsToDelete.Insert(RowArray, Context.GetRowCount(), RowsToDelete.Num());
            }));
 
            for (RowHandle Row : RowsToDelete)
            {
                DataStorageInterface->RemoveRow(Row);
            }
 
            DataStorageInterface->UnregisterQuery(Query);
        }
    ))

StorageFeatureName

TYPEDELEMENTFRAMEWORK_API const FName UE::Editor::DataStorage::StorageFeatureName = TEXT("EditorDataStorage")

UiFeatureName

TYPEDELEMENTFRAMEWORK_API const FName UE::Editor::DataStorage::UiFeatureName = TEXT("EditorDataStorageUi")