The SelectStatement of the view. More...

Classes
struct	AccessModeSetting

struct	ActiveCheckpointWrapper

struct	ActiveTimer

struct	AddColumnInfo

struct	AddConstraintInfo

struct	AddFieldInfo

class	AdditionalAuthenticatedData

struct	AddOperator

struct	AddOperatorOverflowCheck

struct	AddScalarFunctionOverloadInfo

struct	AddTableFunctionOverloadInfo

struct	AddTimeOperator

struct	aggregate_state_t

struct	AggregateBinaryInput

class	AggregateExecutor

class	AggregateExpressionMatcher

struct	AggregateFilterData

struct	AggregateFilterDataSet

struct	AggregateFinalizeData

class	AggregateFunction

class	AggregateFunctionCatalogEntry
	An aggregate function in the catalog. More...

struct	AggregateFunctionInfo

class	AggregateFunctionSet

struct	AggregateInputData

struct	AggregateObject

struct	AggregateStateType

struct	AggregateStateTypeInfo

struct	AggregateStatisticsInput

struct	AggregateUnaryInput

class	AllocatedData

class	Allocator

struct	AllocatorBackgroundThreadsSetting

struct	AllocatorBulkDeallocationFlushThresholdSetting

struct	AllocatorDebugInfo

struct	AllocatorFlushThresholdSetting

struct	AllowCommunityExtensionsSetting

struct	AllowedConfigsSetting

struct	AllowedDirectoriesSetting

struct	AllowedPathsSetting

struct	AllowExtensionsMetadataMismatchSetting

struct	AllowParserOverrideExtensionSetting

struct	AllowPersistentSecretsSetting

struct	AllowUnredactedSecretsSetting

struct	AllowUnsignedExtensionsSetting

class	AlterBinder
	The AlterBinder binds expressions in ALTER statements. More...

struct	AlterDatabaseInfo

struct	AlterEntryData

struct	AlterForeignKeyInfo

struct	AlterInfo

struct	AlterScalarFunctionInfo

struct	AlterTableFunctionInfo

struct	AlterTableInfo

struct	AlterViewInfo

struct	AlwaysFalse

struct	AnalyzeState

struct	AnyType

struct	AnyTypeInfo

class	Appender

struct	AppenderWrapper

struct	arena_deleter
	Call destructor without attempting to free the memory. More...

class	arena_stl_allocator

class	ArenaAllocator

struct	ArenaChunk

class	ArenaLinkedList

class	array_ptr
	array_ptr is a non-owning (optionally) bounds-checked pointer to an array More...

class	array_ptr_iterator

struct	ArrayCatFun

struct	ArrayConcatFun

struct	ArrayLengthFun

struct	ArrayType

struct	ArrayTypeInfo

struct	ArrayValue

struct	ArrayVector

union	arrow_string_view_t

struct	ArrowAppendData

class	ArrowAppender
	The ArrowAppender class can be used to incrementally construct an arrow array by appending data chunks into it. More...

struct	ArrowArrayInfo

struct	ArrowArrayScanState

class	ArrowArrayStreamWrapper

class	ArrowArrayWrapper

class	ArrowBatchGlobalState

class	ArrowBatchTask

struct	ArrowBignum

struct	ArrowBit

struct	ArrowBool8

struct	ArrowBoolData

struct	ArrowBuffer

struct	ArrowCollectorGlobalState

struct	ArrowCollectorLocalState

struct	ArrowConverter

struct	ArrowDateTimeInfo

struct	ArrowDecimalInfo

struct	ArrowEnumData

struct	ArrowExtensionMetadata

struct	ArrowFixedSizeListData

struct	ArrowGeometry

struct	ArrowInterval

struct	ArrowIntervalConverter

struct	ArrowJson

struct	ArrowLargeBufferSizeSetting

struct	ArrowListData

struct	ArrowListInfo

struct	ArrowListViewData

struct	ArrowLosslessConversionSetting

struct	ArrowMapData

class	ArrowMergeEvent

struct	ArrowNullData

struct	ArrowOutputListViewSetting

struct	ArrowOutputVersionSetting

struct	ArrowProjectedColumns

class	ArrowQueryResult

struct	ArrowResultWrapper

struct	ArrowRunEndEncodingState

struct	ArrowScalarBaseData

struct	ArrowScalarConverter

struct	ArrowScalarData

struct	ArrowScanFunctionData

struct	ArrowScanGlobalState

struct	ArrowScanLocalState

class	ArrowSchemaMetadata

class	ArrowSchemaWrapper

struct	ArrowStreamParameters

struct	ArrowStringInfo

struct	ArrowStringViewConstants

struct	ArrowStructData

struct	ArrowStructInfo

struct	ArrowTableFunction

struct	ArrowTableSchema

struct	ArrowTimeTzConverter

struct	ArrowToDuckDBConversion

class	ArrowType

class	ArrowTypeExtension

class	ArrowTypeExtensionData

struct	ArrowTypeExtensionSet
	The set of encoding functions. More...

struct	ArrowTypeInfo

struct	ArrowUnionData

class	ArrowUtil

struct	ArrowUUIDBlobConverter

struct	ArrowUUIDConverter

struct	ArrowVarcharConverter

struct	ArrowVarcharData

struct	ArrowVarcharToStringViewData

class	ART

class	ARTKey

class	ARTScanner
	ARTScanner scans the entire ART and processes each node. More...

struct	AsofLoopJoinThresholdSetting

class	AsyncResult

class	AsyncTask

class	atomic_ptr

class	AttachedDatabase
	The AttachedDatabase represents an attached database instance. More...

struct	AttachInfo

struct	AttachOptions

struct	AutoCheckpointSkipWalThresholdSetting

struct	AutoinstallExtensionRepositorySetting

struct	AutoinstallKnownExtensionsSetting

class	AutoloadException

struct	AutoloadKnownExtensionsSetting

class	BaseAppender
	The Appender class can be used to append elements to a table. More...

class	BaseColumnPruner

class	BaseExpression

class	BaseFileReader

class	BaseFileReaderOptions
	Parent class of file reader options. More...

class	BaseNode

class	BasePipelineEvent
	A BasePipelineEvent is used as the basis of any event that belongs to a specific pipeline. More...

class	BaseProfiler
	Profiler class to measure the elapsed time. More...

class	BaseQueryResult

struct	BaseRequest

class	BaseReservoirSampling
	Resevoir sampling is based on the 2005 paper "Weighted Random Sampling" by Efraimidis and Spirakis. More...

class	BaseResultRenderer

class	BaseScalarFunction

class	BaseSecret
	Base class from which BaseSecret classes can be made. More...

class	BaseStatistics

class	BaseUnionData

class	BaseUUID
	The BaseUUID class contains UUID related common and util functions. More...

class	basic_stringstream

class	BatchCollectionChunkScanState

class	BatchCollectorGlobalState

class	BatchCollectorLocalState

struct	BatchedChunkIteratorRange

struct	BatchedChunkScanState

class	BatchedDataCollection

class	BFTableFilter

struct	BFTableFilterState

struct	BigIntValue

class	Bignum
	The Bignum class is a static class that holds helper functions for the Bignum type. More...

struct	bignum_t

struct	BignumCastToVarchar

struct	BignumIntermediate

struct	BignumToDoubleCast

struct	BignumToIntCast

class	BinaryDeserializer

struct	BinaryExecutor

struct	BinaryLambdaWrapper

struct	BinaryLambdaWrapperWithNulls

class	BinarySerializer

struct	BinarySingleArgumentOperatorWrapper

struct	BinaryStandardOperatorWrapper

struct	BindCastFunction

struct	BindCastInfo
	Extra data that can be attached to a bind function of a cast, and is available during binding. More...

struct	BindCastInput

class	BindContext

class	Binder
	Bind the parsed query tree to the actual columns present in the catalog. More...

class	BinderException

struct	BindInfo

struct	Binding
	A Binding represents a binding to a table, table-producing function or subquery with a specified table index. More...

struct	BindingAlias

struct	BindLogicalTypeInput

struct	BindPreparedStatementCallbackInfo

struct	BindResult

class	Bit
	The Bit class is a static class that holds helper functions for the BIT type. More...

struct	BitLengthFun

class	Blob
	The Blob class is a static class that holds helper functions for the Blob type. More...

class	Block

class	block_iterator_t
	Iterator for data spread out over multiple blocks. More...

class	BlockAllocator

struct	BlockAllocatorMemorySetting

class	BlockHandle

struct	BlockIdVisitor

struct	BlockIndexManager

class	BlockingSample

class	BlockIteratorState

class	BlockIteratorState< BlockIteratorStateType::EXTERNAL >

class	BlockIteratorState< BlockIteratorStateType::IN_MEMORY >

class	BlockIteratorStateBase

class	BlockManager

class	BlockMemory

struct	BlockMetaData

struct	BlockPointer

class	BloomFilter

struct	BooleanValue

class	BoundAtClause
	The AT clause specifies which version of a table to read. More...

struct	BoundCastData
	Extra data that can be returned by the bind of a cast, and is available during execution of a cast. More...

class	BoundCastExpression

struct	BoundCastInfo

class	BoundCheckConstraint

struct	BoundColumnReferenceInfo

class	BoundColumnRefExpression

class	BoundConstantExpression

class	BoundConstraint
	Bound equivalent of Constraint. More...

struct	BoundCreateTableInfo

class	BoundDistinctModifier

class	BoundExpression

class	BoundForeignKeyConstraint

class	BoundFunctionExpression
	Represents a function call that has been bound to a base function. More...

class	BoundIndex
	The index is an abstract base class that serves as the basis for indexes. More...

class	BoundLambdaExpression

class	BoundLimitModifier

struct	BoundLimitNode

class	BoundNotNullConstraint

struct	BoundOrderByNode

class	BoundOrderModifier

struct	BoundParameterData

struct	BoundParameterMap

class	BoundReferenceExpression
	A BoundReferenceExpression represents a physical index into a DataChunk. More...

class	BoundResultModifier
	A ResultModifier. More...

struct	BoundStatement

class	BoundUniqueConstraint

class	BoxRenderer

struct	BoxRendererConfig

struct	BoxRendererFooter

struct	BoxRendererImplementation

struct	BoxRendererState

struct	BoxRenderRow

struct	BoxRenderValue

class	buffer_handle_map_t

struct	BufferAllocator

class	BufferedData

class	BufferedFileWriter

struct	BufferedIndexReplays

class	BufferHandle

class	BufferingLogStorage

class	BufferManager

struct	BufferPoolPayload

struct	BufferPoolReservation

class	BuiltinFunctions

struct	CachedFileInformation

struct	CachedGlobalSettings

class	CachingOperatorState
	Contains state for the CachingPhysicalOperator. More...

class	CachingPhysicalOperator

class	CardinalityEstimator

class	CardinalityHelper

class	CaseExpressionMatcher

struct	CaseInsensitiveStringCompare

struct	CaseInsensitiveStringEquality

struct	CaseInsensitiveStringHashFunction

struct	Cast

class	CastExpression
	CastExpression represents a type cast from one SQL type to another SQL type. More...

class	CastExpressionMatcher

struct	CastFromBitToBlob

struct	CastFromBitToNumeric

struct	CastFromBitToString

struct	CastFromBlob

struct	CastFromBlobToBit

struct	CastFromPointer

struct	CastFromTimeNS

struct	CastFromTimestampMS

struct	CastFromTimestampNS

struct	CastFromTimestampSec

struct	CastFromType

struct	CastFromUUID

struct	CastFromUUIDToBlob

class	CastFunctionSet

struct	CastLocalStateParameters

struct	CastParameters

struct	CastTimestampMsToDate

struct	CastTimestampMsToNs

struct	CastTimestampMsToTime

struct	CastTimestampMsToUs

struct	CastTimestampNsToDate

struct	CastTimestampNsToTime

struct	CastTimestampNsToTimeNs

struct	CastTimestampNsToUs

struct	CastTimestampSecToDate

struct	CastTimestampSecToMs

struct	CastTimestampSecToNs

struct	CastTimestampSecToTime

struct	CastTimestampSecToUs

struct	CastTimestampUsToMs

struct	CastTimestampUsToNs

struct	CastTimestampUsToSec

class	Catalog
	The Catalog object represents the catalog of the database. More...

class	CatalogEntry
	Abstract base class of an entry in the catalog. More...

struct	CatalogEntryEquality

struct	CatalogEntryHashFunction

struct	CatalogEntryInfo

struct	CatalogEntryLookup
	Return value of Catalog::LookupEntry. More...

class	CatalogEntryMap

class	CatalogEntryRetriever

struct	CatalogErrorMaxSchemasSetting

class	CatalogException

struct	CatalogLookup

struct	CatalogSearchEntry

class	CatalogSearchPath
	The schema search path, in order by which entries are searched if no schema entry is provided. More...

class	CatalogSet
	The Catalog Set stores (key, value) map of a set of CatalogEntries. More...

struct	CatalogTransaction

struct	CClientArrowOptionsWrapper

struct	CClientContextWrapper

class	CGroups

struct	ChangeColumnTypeInfo

struct	ChangeOwnershipInfo

struct	CharacterLengthFun

struct	CharLengthFun

class	CheckConstraint

class	CheckpointLock

class	CheckpointLogType

struct	CheckpointOptions

struct	CheckpointThresholdSetting

class	ChunkConstantInfo

class	ChunkInfo

struct	ChunkManagementState

class	ChunkScanState
	Abstract chunk fetcher. More...

class	ChunkVectorInfo

struct	CleanupBufferPool

struct	ClientConfig

class	ClientContext

class	ClientContextLock

class	ClientContextState

class	ClientContextWrapper

struct	ClientData

struct	ClientProperties
	A set of properties from the client context that can be used to interpret the query result. More...

struct	CMIntegralCompressFun

struct	CMIntegralDecompressFun

struct	CMStringCompressFun

struct	CMStringDecompressFun

struct	CMUtils

class	CollateCatalogEntry
	A collation catalog entry. More...

class	CollectionScanState

struct	ColumnBinding

struct	ColumnBindingEquality

struct	ColumnBindingHashFunction

class	ColumnBindingReplacer
	The ColumnBindingReplacer updates column bindings (e.g., after changing the operator plan), utility for optimizers. More...

struct	ColumnCheckpointInfo

class	ColumnData

class	ColumnDataAllocator

struct	ColumnDataAppendState

class	ColumnDataChunkIterationHelper

class	ColumnDataCollection

struct	ColumnDataLocalScanState

struct	ColumnDataParallelScanState

class	ColumnDataRow

class	ColumnDataRowCollection
	The ColumnDataRowCollection represents a set of materialized rows, as obtained from the ColumnDataCollection. More...

class	ColumnDataRowIterationHelper

struct	ColumnDataScanState

class	ColumnDefinition
	A column of a table. More...

class	ColumnDependencyManager
	Dependency Manager local to a table, responsible for keeping track of generated column dependencies. More...

struct	ColumnFetchState

struct	ColumnIndex

struct	ColumnIndexEquality

struct	ColumnIndexHashFunction

class	ColumnList
	A set of column definitions. More...

struct	ColumnPartitionData

class	ColumnRefExpression

struct	ColumnScanState

class	ColumnSegment
	TableFilter represents a filter pushed down into the table scan. More...

struct	ColumnSegmentInfo
	Column segment information. More...

struct	ColumnSegmentState

class	ColumnSegmentTree

class	ColumnStatistics

struct	CombinedListData

struct	CommitInfo

struct	CommonTableExpressionInfo

class	CommonTableExpressionMap

class	ComparisonExpressionMatcher

class	ComparisonExpressionTypeMatcher
	The ComparisonExpressionTypeMatcher class matches a comparison expression. More...

struct	ComparisonOperationWrapper

struct	ComparisonOperationWrapper< DistinctFrom >

struct	ComparisonOperationWrapper< NotDistinctFrom >

struct	compatible_with_t

struct	ComplexJSON
	Custom struct to handle both strings and nested JSON objects. More...

class	CompressedFile

class	CompressedFileSystem

struct	CompressedSegmentState

struct	CompressionAppendState

struct	CompressionAvailabilityResult

class	CompressionFunction

struct	CompressionFunctionSet
	The set of compression functions. More...

class	CompressionInfo

struct	CompressionState

struct	ConcatFun

struct	ConcatOperatorFun

struct	ConcatWsFun

struct	ConfigurationAlias

struct	ConfigurationOption

class	ConflictInfo
	ConflictInfo contains information to match indexes to ON CONFLICT DO targets. More...

class	ConflictManager

class	ConjunctionAndFilter

struct	ConjunctionAndFilterState

class	ConjunctionExpressionMatcher

class	ConjunctionFilter

class	ConjunctionOrFilter

struct	ConjunctionOrFilterState

class	Connection

class	ConnectionException

class	ConnectionManager

struct	ConsecutiveChildListInfo

class	ConstantExpression
	ConstantExpression represents a constant value in the query. More...

class	ConstantExpressionMatcher

class	ConstantFilter

struct	ConstantVector

class	Constraint
	Constraint is the base class of any type of table constraint. More...

class	ConstraintException

struct	ContainsFun

struct	ContainsFunctor

class	ContinuousIdSet

class	ConversionException

struct	ConvertToString

class	CoordinateReferenceSystem

class	CoordinateSystemCatalogEntry
	A coordinate system catalog entry. More...

struct	CopyFromFunctionBindInput

class	CopyFunction

struct	CopyFunctionBindInput

class	CopyFunctionCatalogEntry
	A table function in the catalog. More...

struct	CopyFunctionFileStatistics

struct	CopyFunctionInfo

struct	CopyInfo

struct	CopyOption

struct	CopyOptionsInput

class	CopyStatement

struct	CopyToSelectInput

struct	CorrelatedColumnInfo

struct	CorrelatedColumns

struct	CountZeros

struct	CountZeros< hugeint_t >

struct	CountZeros< uhugeint_t >

struct	CountZeros< uint32_t >

struct	CountZeros< uint64_t >

struct	CreateAggregateFunctionInfo

struct	CreateCollationInfo

struct	CreateCoordinateSystemInfo

struct	CreateCopyFunctionInfo

struct	CreateFunctionInfo

struct	CreateIndexInfo

struct	CreateIndexInput

class	CreateIndexScanState

struct	CreateInfo

struct	CreateMacroInfo

struct	CreatePragmaFunctionInfo

struct	CreateScalarFunctionInfo

struct	CreateSchemaInfo

class	CreateSecretFunction
	A CreateSecretFunction is a function adds a provider for a secret type. More...

class	CreateSecretFunctionSet

struct	CreateSecretInfo

struct	CreateSecretInput
	Input passed to a CreateSecretFunction. More...

struct	CreateSequenceInfo

class	CreateStatement

struct	CreateTableFunctionInfo

struct	CreateTableInfo

struct	CreateTypeInfo

struct	CreateViewInfo

class	CSVBuffer

class	CSVBufferHandle

class	CSVEncoder

struct	CSVEncoderBuffer
	Struct that holds encoder buffers. More...

class	CSVFileHandle

class	CSVLogStorage

struct	CSVOption

struct	CSVReaderOptions

struct	CSVStateMachineOptions

class	CSVWriter

struct	CSVWriterOptions

struct	CSVWriterState

struct	CTEBinding

struct	CTEBindState

class	CTERefPruner

struct	CurrentTransactionInvalidationPolicySetting

struct	CustomExtensionRepositorySetting

struct	CustomProfilingSettingsSetting

struct	CustomUserAgentSetting

struct	DatabaseCacheEntry

class	DatabaseFilePathManager
	The DatabaseFilePathManager is used to ensure we only ever open a single database file once. More...

struct	DatabaseHeader

class	DatabaseInstance

class	DatabaseManager
	The DatabaseManager is a class that sits at the root of all attached databases. More...

struct	DatabaseModificationType

struct	DatabasePathInfo

struct	DatabaseSize

struct	DatabaseWrapper

class	DataChunk
	A Data Chunk represents a set of vectors. More...

struct	DataPointer

class	DataTable
	DataTable represents a physical table on disk. More...

struct	DataTableInfo

class	Date
	The Date class is a static class that holds helper functions for the Date type. More...

struct	date_t
	Type used to represent dates (days since 1970-01-01) More...

struct	DateSpecial

struct	DateToStringCast

struct	DateValue

struct	DBConfig

struct	DBConfigOptions

class	DBInstanceCache

struct	DBInstanceCacheWrapper

struct	DConstants

struct	DebugAsofIejoinSetting

struct	DebugCheckpointAbortSetting

struct	DebugCheckpointSleepMsSetting

struct	DebugEvictionQueueSleepMicroSecondsSetting

struct	DebugForceExternalSetting

struct	DebugForceNoCrossProductSetting

struct	DebugPhysicalTableScanExecutionStrategySetting

struct	DebugSkipCheckpointOnCommitSetting

struct	DebugVerifyBlocksSetting

struct	DebugVerifyVectorSetting

struct	DebugWindowModeSetting

class	Decimal
	The Decimal class is a static class that holds helper functions for the Decimal type. More...

struct	DecimalAddOverflowCheck

struct	DecimalCastData

struct	DecimalCastOperation

struct	DecimalCastTraits

struct	DecimalCastTraits< hugeint_t >

struct	DecimalCastTraits< uhugeint_t >

struct	DecimalMultiplyOverflowCheck

struct	DecimalSubtractOverflowCheck

struct	DecimalToString

struct	DecimalType

struct	DecimalTypeInfo

struct	DecimalWidth

struct	DecimalWidth< hugeint_t >

struct	DecimalWidth< int16_t >

struct	DecimalWidth< int32_t >

struct	DecimalWidth< int64_t >

struct	DefaultBlockSizeSetting

struct	DefaultCasts

struct	DefaultCollationSetting

class	DefaultCoordinateSystemGenerator

struct	DefaultExtension

class	DefaultFunctionGenerator

class	DefaultGenerator

class	DefaultLogType

struct	DefaultMacro

struct	DefaultNamedParameter

struct	DefaultNullCheckOperator

struct	DefaultNullOrderSetting

struct	DefaultOptimizerType

struct	DefaultOrderSetting

struct	DefaultPayload

struct	DefaultSchema

class	DefaultSchemaGenerator

struct	DefaultSecretStorageSetting

class	DefaultTableFunctionGenerator

struct	DefaultTableMacro

class	DefaultTypeGenerator

struct	DefaultView

class	DefaultViewGenerator

class	DeleteFilter

struct	DeleteIndexInfo

struct	DeleteRequestInfo

class	DelimGetRef

struct	DeltaOnlyVariantEncodingEnabledSetting

struct	DenomInfo

struct	Dependency

class	DependencyCatalogSet
	This class mocks the CatalogSet interface, but does not actually store CatalogEntries. More...

struct	DependencyDependent

class	DependencyDependentEntry

struct	DependencyDependentFlags

class	DependencyEntry

struct	DependencyEquality

class	DependencyException

struct	DependencyFlags

struct	DependencyHashFunction

struct	DependencyInfo

class	DependencyItem

class	DependencyManager
	The DependencyManager is in charge of managing dependencies between catalog entries. More...

struct	DependencySubject

class	DependencySubjectEntry

struct	DependencySubjectFlags

struct	DeprecatedUsingKeySyntaxSetting

class	deque

class	Deserializer

struct	DialectOptions

class	DictionaryBuffer
	The DictionaryBuffer holds a selection vector. More...

struct	DictionaryVector

struct	DisableDatabaseInvalidationSetting

struct	DisabledCompressionMethodsSetting

struct	DisabledFilesystemsSetting

struct	DisabledLogTypes

struct	DisabledOptimizersSetting

struct	DisableTimestamptzCastsSetting

struct	DistinctCount

struct	DistinctFrom

struct	DistinctGreaterThan

struct	DistinctGreaterThanEquals

struct	DistinctGreaterThanNullsFirst

struct	DistinctLessThan

struct	DistinctLessThanEquals

struct	DistinctLessThanNullsFirst

class	DistinctModifier

class	DistinctStatistics

struct	double_na_equal

struct	DoubleValue

class	DPJoinNode

struct	DropInfo

struct	DropNotNullInfo

struct	DroppedFieldMapping

struct	dtime_ns_t
	Type used to represent TIME_NS. dtime_ns_t holds the nanoseconds since midnight. More...

struct	dtime_t
	Type used to represent time (microseconds) More...

struct	dtime_tz_t

class	DuckCatalog
	The Catalog object represents the catalog of the database. More...

struct	DuckCleanupInfo

class	DuckDB

struct	DuckDBAdbcConnectionWrapper

struct	DuckDBAPISetting

struct	DuckDBArrowSchemaHolder

struct	DuckDBResultData

class	DuckIndexEntry
	A duck index entry. More...

class	DuckSchemaEntry
	A schema in the catalog. More...

class	DuckTableEntry
	A table catalog entry. More...

class	DuckTransaction

class	DuckTransactionManager

struct	DummyBinding

class	DynamicFilter

struct	DynamicFilterData

struct	DynamicOrFilterThresholdSetting

class	DynamicTableFilterSet

class	enable_shared_from_this

struct	EnabledLogTypes

struct	EnableExternalAccessSetting

struct	EnableExternalFileCacheSetting

struct	EnableFSSTVectorsSetting

struct	EnableHTTPLoggingSetting

struct	EnableHTTPMetadataCacheSetting

struct	EnableLogging

struct	EnableMacroDependenciesSetting

struct	EnableObjectCacheSetting

struct	EnableProfilingSetting

struct	EnableProgressBarPrintSetting

struct	EnableProgressBarSetting

struct	EnableViewDependenciesSetting

class	EncodingFunction

struct	EncodingFunctionSet
	The set of encoding functions. More...

struct	EncodingUtil

struct	EncryptionCanary

class	EncryptionEngine

class	EncryptionKey

class	EncryptionKeyManager

struct	EncryptionNonce

class	EncryptionState

struct	EncryptionStateMetadata

struct	EncryptionTag

class	EncryptionTypes

class	EncryptionUtil

struct	EndsWithFun

struct	EntryBinding

struct	EntryLookupInfo

struct	EnumClassHash

struct	EnumType

struct	EnumTypeInfo

struct	EnumTypeInfoTemplated

struct	EnumUtil

struct	Equals

class	ErrorData

struct	ErrorDataWrapper

class	ErrorManager

struct	ErrorsAsJSONSetting

class	Event

class	Exception

struct	ExceptionEntry

struct	ExceptionFormatValue

struct	ExecuteFunctionState

class	ExecutionContext

class	Executor

class	ExecutorException

class	ExecutorTask

struct	ExpandDirectory

struct	ExperimentalMetadataReuseSetting

struct	ExplainOutputSetting

class	ExplainStatement

class	Expression
	The Expression class represents a bound Expression with a return type. More...

class	ExpressionBinder

struct	ExpressionBinding

struct	ExpressionEquality

class	ExpressionEqualityMatcher
	The ExpressionEqualityMatcher matches on equality with another (given) expression. More...

class	ExpressionExecutor
	ExpressionExecutor is responsible for executing a set of expressions and storing the result in a data chunk. More...

struct	ExpressionExecutorState

class	ExpressionFilter

struct	ExpressionFilterState

struct	ExpressionHashFunction

class	ExpressionIterator

class	ExpressionMatcher
	The ExpressionMatcher class contains a set of matchers that can be used to pattern match Expressions. More...

class	ExpressionRewriter
	The ExpressionRewriter performs a set of fixed rewrite rules on the expressions that occur in a SQL statement. More...

struct	ExpressionState

class	ExpressionTypeMatcher
	The ExpressionTypeMatcher class contains a set of matchers that can be used to pattern match ExpressionTypes. More...

struct	ExpressionWrapper

struct	ExtendedOpenFileInfo

class	Extension
	The Extension class is the base class used to define extensions. More...

class	ExtensionActiveLoad

struct	ExtensionAlias

struct	ExtensionDirectoriesSetting

struct	ExtensionDirectorySetting

struct	ExtensionEntry

struct	ExtensionFunctionEntry

struct	ExtensionFunctionOverloadEntry

class	ExtensionHelper

class	ExtensionInfo

struct	ExtensionInitResult

class	ExtensionInstallInfo

struct	ExtensionInstallOptions

struct	ExtensionLoadedInfo

class	ExtensionLoader

class	ExtensionManager

struct	ExtensionOption

struct	ExtensionRepository

struct	ExtensionTypeInfo

struct	ExtensionUpdateResult

class	ExternalDependency

struct	ExternalThreadsSetting

struct	ExtraBoundInfo

struct	ExtractStatementsWrapper

struct	ExtraDropInfo

struct	ExtraDropSecretInfo

class	ExtraOperatorInfo

class	ExtraPersistentColumnData

struct	ExtraTypeInfo

class	FastMod

class	FatalException

class	FileBuffer
	The FileBuffer represents a buffer that can be read or written to a Direct IO FileHandle. More...

class	FileFlags

struct	FileGlobInput

struct	FileHandle

class	FileLogStorage

struct	FileMetadata

class	FilenamePattern

struct	FileNameSegment

class	FileOpener
	Abstract type that provide client-specific context to FileSystem. More...

struct	FileOpenerInfo

class	FileOpenFlags

struct	FileSearchPathSetting

class	FileSystem

class	FileSystemLogType

class	FilterCombiner

class	FilterInfoWithTotalDomains

class	fixed_size_map_iterator

class	fixed_size_map_t
	Alternative to perfect_map_t when min/max keys are integral, small, and known. More...

class	FixedSizeAllocator

struct	FixedSizeAllocatorInfo
	Information to serialize a FixedSizeAllocator, which holds the index data. More...

class	FixedSizeBuffer

struct	FixedSizeUncompressed

struct	FixedSortKey

struct	FlatVector

struct	float_na_equal

struct	FloatValue

class	FoldableConstantMatcher

struct	ForceBitpackingModeSetting

struct	ForceCompressionSetting

struct	ForceMbedtlsUnsafeSetting

struct	ForceVariantShredding

class	ForeignKeyConstraint

struct	ForeignKeyInfo

struct	FrameBounds

struct	FrameDelta

class	FSSTPrimitives

struct	FSSTVector

class	Function
	Function is the base class used for any type of function (scalar, aggregate or simple function) More...

struct	FunctionBindExpressionInput

struct	FunctionData

struct	FunctionDataWrapper

struct	FunctionDescription

class	FunctionEntry
	A function in the catalog. More...

class	FunctionExpression
	Represents a function call. More...

class	FunctionExpressionMatcher

struct	FunctionList

struct	FunctionLocalState

class	FunctionMatcher
	The FunctionMatcher class contains a set of matchers that can be used to pattern match specific functions. More...

struct	FunctionModifiedDatabasesInput

struct	FunctionParameters

class	FunctionSet

struct	FunctionStatisticsInput

struct	GeneratedSettingInfo

struct	GenericSetting

struct	GenericUnaryWrapper

class	Geometry

class	GeometryExtent

struct	GeometryMinimumShreddingSize

class	GeometryPersistentColumnData

struct	GeometryStats

struct	GeometryStatsData

class	GeometryStatsFlags

class	GeometryTypeSet

struct	GeoType

struct	GeoTypeInfo

struct	GetCastFunctionInput

struct	GetPartitionStatsInput

struct	GetRequestInfo

struct	GlobalBinderState
	GlobalBinderState is state shared over the ENTIRE query, including subqueries, views, etc. More...

struct	GlobalFunctionData

class	GlobalHivePartitionState

class	GlobalOperatorState

class	GlobalSinkState

class	GlobalSourceState

struct	GlobalTableFunctionState

struct	GlobalUserSettings

class	GlobMultiFileList
	MultiFileList that takes a list of globs and resolves all of the globs lazily into files. More...

struct	GlobPatternFun

struct	GraphemeCluster

class	GraphemeIterator

struct	GreaterThan

struct	GreaterThanEquals

class	GroupByNode

class	GZipFile

class	GZipFileSystem

struct	HandleCastError

struct	has_deserialize

struct	has_deserialize< T, typename std::enable_if< std::is_same< decltype(T::Deserialize), shared_ptr< T >(Deserializer &)>::value, T >::type >

struct	has_deserialize< T, typename std::enable_if< std::is_same< decltype(T::Deserialize), std::shared_ptr< T >(Deserializer &)>::value, T >::type >

struct	has_deserialize< T, typename std::enable_if< std::is_same< decltype(T::Deserialize), T(Deserializer &)>::value, T >::type >

struct	has_deserialize< T, typename std::enable_if< std::is_same< decltype(T::Deserialize), unique_ptr< T >(Deserializer &)>::value, T >::type >

struct	has_serialize

struct	has_serialize< T, typename std::enable_if< std::is_same< decltype(std::declval< T >().Serialize(std::declval< Serializer & >())), void >::value, T >::type >

struct	HashArrowTypeExtension

struct	HashTypeInfo

struct	HeadRequestInfo

struct	HighlightingAnnotation

struct	HistogramAggState

class	HivePartitionedColumnData

class	HivePartitioning

struct	HivePartitioningFilterInfo

struct	HivePartitioningIndex

struct	HivePartitionKey

struct	HomeDirectorySetting

class	HTTPClient

class	HTTPException

struct	HTTPHeaders

struct	HTTPLoggingOutputSetting

class	HTTPLogType

struct	HTTPLogWriter

struct	HTTPParams

struct	HTTPProxyPasswordSetting

struct	HTTPProxySetting

struct	HTTPProxyUsernameSetting

struct	HTTPResponse

class	HTTPUtil

class	Hugeint
	The Hugeint class contains static operations for the INT128 type. More...

struct	hugeint_t

struct	HugeintCastToBignum
	--------------------------------— (u)HugeInt Cast --------------------------------— // More...

struct	HugeIntValue

class	HyperLogLog

struct	IeeeFloatingPointOpsSetting

struct	IgnoreUnknownCrsSetting

struct	IlikeEscapeFun

struct	ILikeFun

struct	ImmediateTransactionModeSetting

class	InCatalogEntry

class	InClauseExpressionMatcher

class	Index
	The index is an abstract base class that serves as the basis for indexes. More...

class	IndexAppendInfo

class	IndexBinder
	The IndexBinder binds indexes and expressions within index statements. More...

struct	IndexBufferInfo
	Information to serialize an index buffer to the WAL. More...

struct	IndexBuildBindData

struct	IndexBuildBindInput

struct	IndexBuildCombineInput

struct	IndexBuildFinalizeInput

struct	IndexBuildGlobalState

struct	IndexBuildInitGlobalStateInput

struct	IndexBuildInitLocalStateInput

struct	IndexBuildLocalState

struct	IndexBuildSinkInput

struct	IndexBuildSortInput

class	IndexCatalogEntry
	An index catalog entry. More...

struct	IndexDataTableInfo
	Wrapper class to allow copying a DuckIndexEntry (for altering the DuckIndexEntry metadata such as comments) More...

struct	IndexEntry
	IndexEntry contains an atomic in addition to the index to ensure correct binding. More...

struct	IndexInfo
	Additional index information for tables. More...

class	IndexPointer

struct	IndexScanMaxCountSetting

struct	IndexScanPercentageSetting

struct	IndexScanState

struct	IndexSerializationInfo

struct	IndexSerializationResult

struct	IndexStorageInfo
	Index (de)serialization information. More...

class	IndexType
	A index "type". More...

struct	IndexTypeInfo

class	IndexTypeSet

class	IndexVector

class	InFilter

class	InMemoryLogStorage

class	InMemoryLogStorageScanState
	State for scanning the in memory buffers. More...

class	InsertionOrderPreservingMap

class	InsertStatement

struct	IntCastToBignum
	--------------------------------— (u)Integral Cast --------------------------------— // More...

struct	IntegerCastData

struct	IntegerCastOperation

struct	IntegerDecimalCastData

struct	IntegerDecimalCastData< uint64_t >

struct	IntegerDecimalCastOperation

struct	IntegerDivisionSetting

struct	IntegerLiteral

struct	IntegerLiteralTypeInfo

class	IntegerTypeMatcher
	The IntegerTypeMatcher class matches only integer types (INTEGER, SMALLINT, TINYINT, BIGINT) More...

struct	IntegerValue

struct	IntegralValue

class	InternalAppender

class	InternalException

struct	InterruptDoneSignalState
	Synchronization primitive used to await a callback in InterruptMode::BLOCKING. More...

class	InterruptException

class	InterruptState
	State required to make the callback after some asynchronous operation within an operator source / sink. More...

class	Interval

struct	interval_t

struct	IntervalToStringCast

struct	IntervalValue

class	InvalidConfigurationException

class	InvalidInputException

class	InvalidTypeException

class	IOException

struct	is_atomic

struct	is_atomic< std::atomic< T > >

struct	is_insertion_preserving_map

struct	is_insertion_preserving_map< typename duckdb::InsertionOrderPreservingMap< Args... > >

struct	is_map

struct	is_map< typename duckdb::map< Args... > >

struct	is_optional_ptr

struct	is_optional_ptr< optional_ptr< T > >

struct	is_optionally_owned_ptr

struct	is_optionally_owned_ptr< optionally_owned_ptr< T > >

struct	is_pair

struct	is_pair< std::pair< T, U > >

struct	is_queue

struct	is_queue< typename std::priority_queue< T > >

struct	is_set

struct	is_set< duckdb::set< Args... > >

struct	is_shared_ptr

struct	is_shared_ptr< shared_ptr< T > >

struct	is_shared_ptr< std::shared_ptr< T > >

struct	is_unique_ptr

struct	is_unique_ptr< unique_ptr< T > >

struct	is_unordered_map

struct	is_unordered_map< typename duckdb::unordered_map< Args... > >

struct	is_unordered_set

struct	is_unordered_set< duckdb::unordered_set< Args... > >

struct	is_unsafe_vector

struct	is_unsafe_vector< typename duckdb::unsafe_vector< T > >

struct	is_vector

struct	is_vector< typename duckdb::vector< T > >

class	IsNotNullFilter

class	IsNullFilter

class	Iterator

struct	IteratorEntry
	Keeps track of the byte leading to the currently active child of the node. More...

class	IteratorKey
	Keeps track of the current key in the iterator leading down to the top node in the stack. More...

struct	JoinCondition
	JoinCondition represents a left-right comparison join condition. More...

struct	JoinRelationSet
	Set of relations, used in the join graph. More...

class	JoinRelationSetManager

class	JoinSide

struct	JSONComponent

struct	JSONFormatter

struct	JSONHighlighter

struct	JSONParser

struct	KeyRowIdOutput
	Output policy for scanning keys and row IDs. More...

class	KeyValueSecret

class	KeyValueSecretReader

class	KeywordHelper

class	LambdaExpression

class	LambdaRefExpression
	Represents a reference to a lambda parameter. More...

struct	LambdaSyntaxSetting

struct	LateMaterializationMaxRowsSetting

class	LazyMultiFileList
	Lazily expanded MultiFileList. More...

struct	LcaseFun

class	Leaf

struct	LegacyFilenamePattern

struct	LenFun

struct	LengthFun

struct	LengthGraphemeFun

struct	LessThan

struct	LessThanEquals

struct	LikeEscapeFun

struct	LikeFun

class	LimitModifier

class	LimitPercentModifier

struct	list_entry_t

struct	ListArgFunctor

struct	ListCatFun

struct	ListConcatFun

struct	ListType

struct	ListTypeInfo

struct	ListValue

struct	ListVector

struct	LoadInfo

class	LocalFileSystem

struct	LocalFunctionData

struct	LocalGlobResult

class	LocalSinkState

class	LocalSourceState

class	LocalStorage
	The LocalStorage class holds appends that have not been committed yet. More...

struct	LocalTableFunctionState

class	LocalTableManager

class	LocalTableStorage

struct	LocalUserSettings

struct	LockConfigurationSetting

struct	LogConfig

class	Logger
	Main logging interface. More...

struct	LoggingContext

struct	LoggingLevel

struct	LoggingMode

struct	LoggingStorage

struct	LogicalDependency

struct	LogicalDependencyEquality

struct	LogicalDependencyHashFunction

class	LogicalDependencyList
	The LogicalDependencyList containing LogicalDependency objects, not looked up in the catalog yet. More...

class	LogicalGet
	LogicalGet represents a scan operation from a data source. More...

struct	LogicalIndex

struct	LogicalIndexHashFunction

class	LogicalOperator

class	LogicalOperatorMatcher
	The LogicalOperatorMatcher class contains a set of matchers that can be used to match LogicalOperators. More...

class	LogicalOperatorVisitor

class	LogicalProjection
	LogicalProjection represents the projection list in a SELECT clause. More...

struct	LogicalType

struct	LogicalTypeModifier

class	LogicalUpdate

class	LogManager

struct	LogQueryPathSetting

class	LogStorage

class	LogStorageScanState

class	LogType

struct	LowerFun

struct	MacroBindResult

class	MacroCatalogEntry
	A macro function in the catalog. More...

class	MacroFunction

class	MagicBytes

class	MainHeader

struct	MakeSigned

struct	MakeSigned< hugeint_t >

struct	MakeSigned< uhugeint_t >

struct	MakeUnsigned

struct	MakeUnsigned< hugeint_t >

struct	MakeUnsigned< uhugeint_t >

class	ManagedResultSet

class	ManagedVectorBuffer
	The ManagedVectorBuffer holds a buffer handle. More...

struct	MangledDependencyName

struct	MangledEntryName

class	ManyExpressionTypeMatcher
	The ManyExpressionTypeMatcher class matches a set of ExpressionTypes. More...

class	ManyFunctionMatcher
	The ManyFunctionMatcher class matches a set of functions. More...

struct	map_entry_encoding
	Encoding Map Entry Struct used for byte replacement. More...

struct	MapType

struct	MapUtil

struct	MapValue

struct	MapVector

struct	MaterializedCTEInfo

class	MaterializedQueryResult

struct	MaxExpressionDepthSetting

struct	MaxMemorySetting

struct	MaxTempDirectorySizeSetting

struct	MaxVacuumTasksSetting

class	MD5Context

struct	MD5Fun

struct	MD5NumberFun

struct	MemoryInformation

struct	MemorySafety

class	MemoryStream

struct	MergeJoinThresholdSetting

struct	MergeSortTraits

struct	MergeSortTraits< std::pair< T... > >

struct	MergeSortTraits< std::tuple< T... > >

struct	MergeSortTree

struct	MetaBlockPointer

struct	MetadataBlock

struct	MetadataBlockInfo

struct	MetadataHandle

class	MetadataManager

struct	MetadataPointer

class	MetadataWriter

class	MetaPipeline
	MetaPipeline represents a set of pipelines that all have the same sink. More...

class	MetaTransaction
	The MetaTransaction manages multiple transactions for different attached databases. More...

class	MetricsLogType

class	MetricsUtils

struct	MetricTypeHashFunction

struct	MiniZStream

struct	MiniZStreamWrapper

class	MissingExtensionException

struct	MultiFileBindData

struct	MultiFileColumnDefinition

class	MultiFileColumnMapper

struct	MultiFileConstantEntry

struct	MultiFileConstantMap

struct	MultiFileConstantMapIndex
	index used to access the constant map More...

struct	MultiFileCount

struct	MultiFileFilterEntry

struct	MultiFileFilterMap

struct	MultiFileGlobalIndex

struct	MultiFileGlobalState

class	MultiFileList

class	MultiFileListIterationHelper

struct	MultiFileListScanData

struct	MultiFileLocalColumnId

struct	MultiFileLocalColumnIds
	fwd declare More...

struct	MultiFileLocalIndex

struct	MultiFileLocalState

struct	MultiFileOptions

struct	MultiFilePushdownInfo

struct	MultiFileReader
	The MultiFileReader class provides a set of helper methods to handle scanning from multiple files. More...

struct	MultiFileReaderBindData
	The bind data for the multi-file reader, obtained through MultiFileReader::BindReader. More...

struct	MultiFileReaderData
	Per-file data for the multi file reader. More...

struct	MultiFileReaderGlobalState
	Global state for MultiFileReads. More...

struct	MultiplyOperator

struct	MultiplyOperatorOverflowCheck

class	MutableLogger

struct	NeighborInfo

struct	NestedLoopJoinThresholdSetting

struct	NextUnsigned

struct	NextUnsigned< uint16_t >

struct	NextUnsigned< uint32_t >

struct	NextUnsigned< uint64_t >

struct	NextUnsigned< uint8_t >

struct	NFCNormalizeFun

class	Node

class	Node16

class	Node256
	Node256 holds up to 256 children. They are indexed by their key byte. More...

class	Node4
	Node4 holds up to four children sorted by their key byte. More...

class	Node48

struct	NodeChildren

class	NodeHandle

class	NodeStatistics

class	NopLogger

struct	NotDistinctFrom

struct	NotEquals

struct	NotIlikeEscapeFun

struct	NotILikeFun

class	NotImplementedException

struct	NotLikeEscapeFun

struct	NotLikeFun

class	NotNullConstraint

struct	NumericCastImpl

struct	NumericCastImpl< TO, FROM, false >

struct	NumericCastImpl< TO, FROM, true >

class	NumericHelper
	NumericHelper is a static class that holds helper functions for integers/doubles. More...

struct	NumericLimits

struct	NumericLimits< hugeint_t >

struct	NumericLimits< uhugeint_t >

struct	NumericStats

struct	NumericStatsData

class	NumericTypeMatcher
	The NumericTypeMatcher class matches any numeric type (DECIMAL, INTEGER, etc...) More...

struct	NumericValueUnion

class	ObjectCache

class	ObjectCacheEntry
	ObjectCache is the base class for objects caches in DuckDB. More...

struct	OctetLengthFun

struct	OffsetPruningResult

struct	OldImplicitCastingSetting

class	OnConflictInfo

struct	OpenFileInfo

struct	OperatorFinalizeInput

struct	OperatorInformation

struct	OperatorPartitionData

struct	OperatorPartitionInfo

class	OperatorProfiler

struct	OperatorSinkCombineInput

struct	OperatorSinkFinalizeInput

struct	OperatorSinkInput

struct	OperatorSinkNextBatchInput

struct	OperatorSourceInput

class	OperatorState

class	OptimisticDataWriter

struct	OptimisticWriteCollection

class	Optimizer

class	optional_idx

class	optional_ptr

class	OptionalFilter

class	optionally_owned_ptr

class	OptionalSelection

struct	OrderByNode
	Single node in ORDER BY statement. More...

struct	OrderByNonIntegerLiteralSetting

struct	OrderedAggregateThresholdSetting

class	OrderModifier

class	OutOfMemoryException

class	OutOfRangeException

struct	ParallelCollectionScanState

struct	ParallelTableScanState

class	ParameterExpression

class	ParameterNotAllowedException

class	ParameterNotResolvedException

class	ParsedExpression

class	ParsedExpressionIterator

struct	ParsedExtensionMetaData
	The parsed extension metadata footer. More...

struct	ParseInfo

class	Parser

class	ParserException

class	ParserExtension

struct	ParserExtensionInfo

struct	ParserExtensionParseData

struct	ParserExtensionParseResult

struct	ParserExtensionPlanResult

struct	ParserKeyword

struct	ParserOptions

struct	ParserOverrideResult

struct	PartialBlock

struct	PartialBlockAllocation

struct	PartialBlockForIndex

class	PartialBlockManager

struct	PartialBlockState
	The current state of a partial block. More...

struct	PartitionColumnDataAllocators
	Shared allocators for parallel partitioning. More...

class	PartitionedColumnData

struct	PartitionedColumnDataAppendState
	Local state for parallel partitioning. More...

class	PartitionedTupleData

struct	PartitionedTupleDataAppendState
	Local state for parallel partitioning. More...

struct	PartitionedWriteFlushThresholdSetting

struct	PartitionedWriteMaxOpenFilesSetting

struct	PartitioningColumnValue

struct	PartitionRowGroup

struct	PartitionStatistics

struct	PasswordSetting

class	Path

struct	PathSplit

struct	PendingQueryParameters

class	PendingQueryResult

struct	PendingStatementWrapper

struct	PerfectEquality

struct	PerfectHash

struct	PerfectHtThresholdSetting

class	PermissionException

struct	PersistentCollectionData

struct	PersistentColumnData

struct	PersistentRowGroupData

class	PersistentTableData

class	PhysicalArrowBatchCollector

class	PhysicalArrowCollector

class	PhysicalBatchCollector

struct	PhysicalIndex

struct	PhysicalIndexHashFunction

class	PhysicalOperator
	PhysicalOperator is the base class of the physical operators present in the execution plan. More...

class	PhysicalOperatorLogType

class	PhysicalPlan

class	PhysicalPlanGenerator
	The physical plan generator generates a physical execution plan from a logical query plan. More...

class	PhysicalResultCollector
	PhysicalResultCollector is an abstract class that is used to generate the final result of a query. More...

struct	PinThreadsSetting

class	Pipeline
	The Pipeline class represents an execution pipeline starting at a. More...

class	PipelineBuildState

class	PipelineTask

struct	PivotFilterThresholdSetting

struct	PivotLimitSetting

struct	PlanIndexInput

struct	PositionFunctor

class	PostIncrement
	Used to increment counters that need to be exception-proof. More...

struct	PostRequestInfo

class	PragmaFunction

class	PragmaFunctionCatalogEntry
	A pragma function in the catalog. More...

class	PragmaFunctionSet

struct	PragmaInfo

struct	PreferRangeJoinsSetting

struct	PrefetchState

class	Prefix

struct	PrefixFun

struct	PreparedBatchData

class	PreparedStatement
	A prepared statement. More...

struct	PreparedStatementCallbackInfo

class	PreparedStatementData

struct	PreparedStatementWrapper

struct	PreserveIdentifierCaseSetting

struct	PreserveInsertionOrderSetting

class	Printer
	Printer is a static class that allows printing to logs or stdout/stderr. More...

struct	PrivateAllocatorData

struct	ProduceArrowStringViewSetting

struct	ProducerToken

struct	ProfileOutputSetting

struct	ProfilingCoverageSetting

class	ProfilingInfo

struct	ProfilingModeSetting

class	ProfilingNode
	Recursive tree mirroring the operator tree. More...

class	ProfilingUtils

class	ProgressBar

class	ProgressBarDisplay

struct	ProgressBarTimeSetting

struct	ProgressData

struct	PushedDownExpressionState

struct	PutRequestInfo

struct	QualifiedColumnEquality

struct	QualifiedColumnHashFunction

struct	QualifiedColumnName

struct	QualifiedName

class	QueryAppender

struct	QueryBinderState

class	QueryContext

class	QueryErrorContext

class	QueryGraphEdges
	The QueryGraph contains edges between relations and allows edges to be created/queried. More...

class	QueryLogType

struct	QueryMetrics

class	QueryNode

struct	QueryParameters

class	QueryProfiler
	QueryProfiler collects the profiling metrics of a query. More...

struct	QueryProgress

class	QueryResult

class	QueryResultChunkScanState

class	queue

struct	Radix

class	RandomEngine

class	ReadStream

struct	RecursiveUnifiedVectorFormat

class	ReferencedColumn

struct	ReferencedExtractComponent

struct	ReferencedStructExtract

struct	ReferenceEquality

struct	ReferenceHashFunction

struct	RegexpEscapeFun

struct	RegexpExtractAllFun

struct	RegexpExtractFun

struct	RegexpFun

struct	RegexpMatchesFun

struct	RegexpReplaceFun

struct	RegexpSplitToArrayFun

struct	RegisteredLoggingContext

class	RegisteredStateManager

class	Relation

class	RelationContextWrapper

class	RelationManager

struct	RelationsSetToStats

class	RelationStatisticsHelper

struct	RelationStats

struct	RemapStructFun

struct	RemoveColumnInfo

struct	RemoveFieldInfo

class	RemoveUnusedColumns
	The RemoveUnusedColumns optimizer traverses the logical operator tree and removes any columns that are not required. More...

struct	RenameColumnInfo

struct	RenameDatabaseInfo

struct	RenameFieldInfo

struct	RenameTableInfo

struct	RenameViewInfo

struct	RenderDataCollection

struct	ReplacementBinding

struct	ReplacementScan

struct	ReplacementScanData

struct	ReplacementScanInput

struct	ReplayRange

class	ReservoirChunk

class	ReservoirRNG

class	ReservoirSample

class	ReservoirSamplePercentage
	The reservoir sample sample_size class maintains a streaming sample of variable size. More...

struct	ResetTableOptionsInfo

struct	ResizeInfo
	This is a helper data structure. It contains all fields necessary to resize a vector. More...

class	ResultArrowArrayStreamWrapper

class	ResultModifier
	A ResultModifier. More...

class	ResultSetManager

struct	RowFun

class	RowGroup

class	RowGroupCollection

class	RowGroupIterationHelper

struct	RowGroupOrderOptions

struct	RowGroupPointer

class	RowGroupReorderer

class	RowGroupSegmentTree

struct	RowGroupWriteData

struct	RowGroupWriteInfo

struct	RowIdSetOutput
	Output policy for scanning row IDs only into a set. More...

class	Rule

class	SampleOptions

class	ScalarFunction

struct	ScalarFunctionBindInput

class	ScalarFunctionCatalogEntry
	A scalar function in the catalog. More...

struct	ScalarFunctionInfo

class	ScalarFunctionSet

class	ScalarMacroCatalogEntry
	A macro function in the catalog. More...

class	ScalarMacroFunction

struct	ScalarSubqueryErrorOnMultipleRowsSetting

struct	ScanFilter

class	ScanFilterInfo

struct	ScanOptions

struct	ScanSamplingInfo

struct	SchedulerProcessPartialSetting

class	SchemaCatalogEntry
	A schema in the catalog. More...

struct	SchemaSetting

struct	ScopedConfigSetting

struct	SearchPathSetting

struct	SecretDirectorySetting

struct	SecretType
	Secret types contain the base settings of a secret. More...

class	SegmentBase

class	SegmentHandle

struct	SegmentLock

struct	SegmentNode

struct	SegmentScanState

class	SegmentStatistics

class	SegmentTree

struct	SelCache
	Selection vector cache used for caching vector slices. More...

struct	SelectionData

struct	SelectionVector

struct	SelectionVectorHelper

class	SelectivityOptionalFilter

struct	SelectivityOptionalFilterState

class	SelectStatement
	SelectStatement is a typical SELECT clause. More...

class	SequenceCatalogEntry
	A sequence catalog entry. More...

struct	SequenceData

class	SequenceException

struct	SequenceValue

struct	SequenceVector

class	SerializationCompatibility

struct	SerializationData

struct	SerializationDefaultValue

class	SerializationException

class	SerializationOptions

struct	SerializedStringSegmentState

class	Serializer

struct	SetColumnCommentInfo

struct	SetColumns

struct	SetCommentInfo

struct	SetDefaultInfo

class	SetMatcher

struct	SetNotNullInfo

struct	SetPartitionedByInfo

struct	SetSortedByInfo

struct	SetTableOptionsInfo

struct	SettingCallbackInfo

struct	SettingLookupResult

struct	Settings

class	SetTypesMatcher
	The SpecificTypeMatcher class matches only a type out of a set of types. More...

struct	SHA1Fun

struct	SHA256Fun

class	shared_ptr

class	SharedLruCache

class	ShowRef
	Represents a SHOW/DESCRIBE/SUMMARIZE statement. More...

struct	SimilarCatalogEntry
	Return value of SimilarEntryInSchemas. More...

class	SimpleBufferedData

class	SimpleFunction

class	SimpleMultiFileList

class	SimpleNamedParameterFunction

struct	SimplifiedToken

class	SingleFileStorageManager
	Stores the database in a single file. More...

struct	SingleJoinRelation
	Represents a single relation and any metadata accompanying that relation. More...

struct	SmallIntValue

class	Sort
	Class that sorts the data, follows the PhysicalOperator interface. More...

struct	sort_key_ptr_t
	Forces a pointer size of 8 bytes (even on 32-bit) More...

struct	SortKey

struct	SortKey< SortKeyType::NO_PAYLOAD_FIXED_16 >

struct	SortKey< SortKeyType::NO_PAYLOAD_FIXED_24 >

struct	SortKey< SortKeyType::NO_PAYLOAD_FIXED_32 >

struct	SortKey< SortKeyType::NO_PAYLOAD_FIXED_8 >

struct	SortKey< SortKeyType::NO_PAYLOAD_VARIABLE_32 >

struct	SortKey< SortKeyType::PAYLOAD_FIXED_16 >

struct	SortKey< SortKeyType::PAYLOAD_FIXED_24 >

struct	SortKey< SortKeyType::PAYLOAD_FIXED_32 >

struct	SortKey< SortKeyType::PAYLOAD_VARIABLE_32 >

struct	SortKeyNoPayload

struct	SortKeyPayload

struct	SortKeyPayloadState

struct	SortKeyUtils

struct	SortProjectionColumn

struct	SourcePartitionInfo

class	SpecificExpressionTypeMatcher
	The SpecificExpressionTypeMatcher class matches a single specified Expression type. More...

class	SpecificFunctionMatcher
	The SpecificFunctionMatcher class matches a single specified function name. More...

class	SpecificLogicalTypeMatcher
	The SpecificLogicalTypeMatcher class matches only a single specified LogicalOperatorType. More...

class	SpecificTypeMatcher
	The SpecificTypeMatcher class matches only a single specified type. More...

struct	SplitFun

class	SQLIdentifier

class	SQLStatement
	SQLStatement is the base class of any type of SQL statement. More...

class	SQLString

class	StableExpressionMatcher
	The stable expression matcher matches only stable expressions (non-volatile) More...

class	StackChecker

class	StackTrace

class	StandardEntry
	A StandardEntry is a catalog entry that is a member of a schema. More...

class	StarExpression
	Represents a * expression in the SELECT clause. More...

struct	StatementProperties
	A struct containing various properties of a SQL statement. More...

class	StatementVerifier

class	StateWithBlockableTasks

struct	StaticFunctionDefinition

class	StatisticsPropagator

class	StdOutLogStorage

struct	Storage

struct	StorageBlockPrefetchSetting

class	StorageCommitState

struct	StorageCompatibilityVersionSetting

struct	StorageIndex

class	StorageLock

class	StorageLockKey

class	StorageManager
	StorageManager is responsible for managing the physical storage of a persistent database. More...

struct	StorageOptions

struct	StoredDatabasePath

struct	StreamData

struct	StreamingBufferSizeSetting

class	StreamQueryResult

struct	StreamWrapper

struct	StrfTimeFormat

class	String

struct	string_t

struct	StringCastFromDecimal

struct	StringCIEquality

struct	StringCIHash

struct	StringDictionaryContainer

struct	StringEquality

struct	StringHash

class	StringHeap

class	StringResultRenderer

struct	StringScanState

struct	StringSplitFun

struct	StringSplitRegexFun

struct	StringStats

struct	StringStatsData

struct	StringToArrayFun

struct	StringType

struct	StringTypeInfo

struct	StringUncompressed

class	StringUtil

struct	StringValue

struct	StringVector

struct	StripAccentsFun

struct	StrlenFun

struct	StrpTimeFormat

struct	StrSplitFun

struct	StrSplitRegexFun

struct	StrTimeFormat

struct	StructConcatFun

struct	StructContainsFun

struct	StructExtractAtFun

struct	StructExtractFun

class	StructFilter

struct	StructHasFun

struct	StructIndexofFun

struct	StructMappingInfo

struct	StructPackFun

struct	StructPositionFun

struct	StructType

struct	StructTypeInfo

struct	StructValue

struct	StructVector

struct	Subgraph2Denominator

struct	SubstrFun

struct	SubstringFun

struct	SubstringGraphemeFun

struct	SubtractOperator

struct	SubtractOperatorOverflowCheck

struct	SubtractTimeOperator

struct	SuffixFun

class	SyntaxException

struct	TableBinding

class	TableCatalogEntry
	A table catalog entry. More...

struct	TableColumn

class	TableDescription

struct	TableDescriptionWrapper

class	TableFilter
	TableFilter represents a filter pushed down into the table scan. More...

class	TableFilterSet

struct	TableFilterState
	Thread-local state for executing a table filter. More...

class	TableFunction

struct	TableFunctionBindInput

class	TableFunctionCatalogEntry
	A table function in the catalog. More...

struct	TableFunctionData

struct	TableFunctionDynamicToStringInput

struct	TableFunctionGetPartitionInput

struct	TableFunctionGetStatisticsInput

struct	TableFunctionInfo

struct	TableFunctionInitInput

struct	TableFunctionInput

struct	TableFunctionPartitionInput

class	TableFunctionSet

struct	TableFunctionToStringInput

class	TableIndexIterationHelper

class	TableIndexList

class	TableIOManager

class	TableMacroCatalogEntry
	A macro function in the catalog. More...

class	TableMacroFunction

class	TableRef
	Represents a generic expression that returns a table. More...

struct	TableScanBindData

struct	TableScanFunction
	The table scan function represents a sequential or index scan over one of DuckDB's base tables. More...

struct	TableScanOptions

class	TableScanState

class	TableStatistics

class	TableStatisticsLock

class	TableStorageInfo
	Table storage information. More...

class	Task
	Generic parallel task. More...

class	TaskErrorManager

class	TaskScheduler
	The TaskScheduler is responsible for managing tasks and threads. More...

struct	TempBufferPoolReservation

struct	TempDirectorySetting

struct	TempFileEncryptionSetting

struct	TemplatedMapGetter
	A helper functor so we can template functions to use either a perfect map or a fixed size map. More...

struct	TemplatedUniqueIf

struct	TemplatedUniqueIf< DATA_TYPE[N]>

struct	TemplatedValidityData

struct	TemplatedValidityMask
	Type used for validity masks. More...

struct	TemplateType

struct	TemplateTypeInfo

class	TemporaryDirectoryHandle

class	TemporaryFileCompressionAdaptivity

class	TemporaryFileHandle

struct	TemporaryFileIdentifier

struct	TemporaryFileIndex

struct	TemporaryFileInformation

class	TemporaryFileManager

class	TemporaryFileMap

struct	TernaryExecutor

struct	TernaryLambdaWrapper

struct	TernaryLambdaWrapperWithNulls

struct	TernaryStandardOperatorWrapper

class	ThreadContext
	The ThreadContext holds thread-local info for parallel usage. More...

class	ThreadLocalLogger

class	ThreadSafeLogger

struct	ThreadsSetting

struct	ThreadUtil

class	Time

class	Timestamp
	The static Timestamp class holds helper functions for the timestamp types. More...

struct	timestamp_ms_t
	Type used to represent TIMESTAMP_MS. timestamp_ms_t holds the milliseconds since 1970-01-01. More...

struct	timestamp_ns_t
	Type used to represent TIMESTAMP_NS. timestamp_ns_t holds the nanoseconds since 1970-01-01. More...

struct	timestamp_sec_t
	Type used to represent TIMESTAMP_S. timestamp_sec_t holds the seconds since 1970-01-01. More...

struct	timestamp_t
	Type used to represent a TIMESTAMP. timestamp_t holds the microseconds since 1970-01-01. More...

struct	timestamp_tz_t

struct	TimestampComponents

struct	TimestampMSValue

struct	TimestampNSValue

struct	TimestampSValue

struct	TimestampTZValue

struct	TimestampValue

struct	TimeToStringCast

struct	TimeValue

struct	TinyIntValue

struct	ToStringOptions
	Options for ToString printing functions. More...

class	Transaction

class	TransactionContext

struct	TransactionData

class	TransactionException

struct	TransactionInfo

class	TransactionLogType

class	TransactionManager

struct	TransactionReference

class	TransformToDeprecatedState
	State for TransformToDeprecated operations. More...

struct	TryAddOperator

struct	TryCast

struct	TryCastBlobToUUID

struct	TryCastErrorMessage

struct	TryCastErrorMessageCommaSeparated

struct	TryCastFromDecimal

struct	TryCastToBignum

struct	TryCastToBit

struct	TryCastToBlob

struct	TryCastToDecimal

struct	TryCastToDecimalCommaSeparated

struct	TryCastToGeometry

struct	TryCastToTimeNS

struct	TryCastToTimestampMS

struct	TryCastToTimestampNS

struct	TryCastToTimestampSec

struct	TryCastToUUID

struct	TryDecimalAdd

struct	TryDecimalMultiply

struct	TryDecimalSubtract

struct	TryMultiplyOperator

struct	TrySubtractOperator

class	TupleDataAllocator

struct	TupleDataAppendState

struct	TupleDataBlock

struct	TupleDataChunk

struct	TupleDataChunkPart

struct	TupleDataChunkState

class	TupleDataCollection

struct	TupleDataGatherFunction

class	TupleDataLayout

struct	TupleDataParallelScanState

struct	TupleDataPinState

struct	TupleDataScanState

struct	TupleDataScatterFunction

struct	TupleDataSegment

struct	TupleDataVectorFormat

class	TypeArgument

class	TypeCatalogEntry
	A type catalog entry. More...

class	TypeExpression

struct	TypeInfo

class	TypeManager

class	TypeMatcher
	The TypeMatcher class contains a set of matchers that can be used to pattern match TypeIds for Rules. More...

class	TypeMismatchException

struct	TypeValue

struct	TypeVisitor

struct	UBigIntValue

struct	UcaseFun

struct	UDFWrapper

class	Uhugeint
	The uhugeint class contains static operations for the UINT128 type. More...

struct	uhugeint_t

struct	UhugeintToStringCast

struct	UhugeIntValue

struct	UIntegerValue

struct	UnaryExecutor

struct	UnaryLambdaWrapper

struct	UnaryLambdaWrapperWithNulls

struct	UnaryOperatorWrapper

struct	UnaryStringOperator

class	UnboundIndex

struct	UnboundType

struct	UnboundTypeInfo

struct	UncompressedFunctions

struct	UncompressedStringStorage

class	UndoBuffer

struct	UndoBufferAllocator

struct	UndoBufferEntry

struct	UndoBufferPointer

struct	UndoBufferProperties

struct	UndoBufferReference

struct	UnifiedVariantVector

struct	UnifiedVariantVectorData

struct	UnifiedVectorFormat

struct	UninitializedRegion
	Regions that require zero-initialization to avoid leaking memory. More...

struct	UnionType

struct	UnionValue

struct	UnionVector

class	unique_ptr

class	unique_ptr< DATA_TYPE[], DELETER, SAFE >

class	unique_ptr< DATA_TYPE[], DELETER, true >

class	UniqueConstraint

struct	UnixFileHandle

class	UpdateSetInfo

class	UpdateStatement

struct	UpperFun

struct	UsernameSetting

struct	UserSettingsMap

struct	UsingColumnSet

struct	USmallIntValue

class	Utf8Proc

struct	UTinyIntValue

class	UUID
	The UUIDv4 class contains static operations for the UUIDv4 type. More...

class	UUIDv7
	The UUIDv7 class contains static operations for the UUIDv7 type. More...

struct	VacuumRebuildIndexesSetting

struct	ValidateExternalFileCacheSetting

class	ValidChecker

struct	ValidityArray

struct	ValidityData

struct	ValidityMask

struct	ValidityUncompressed

class	Value

struct	ValueOperations

struct	VariableReturnBindData

struct	VariableSortKey

struct	Variant

struct	VariantCasts

struct	VariantDecimalData

struct	VariantMinimumShreddingSizeSetting

struct	VariantNestedData

struct	VariantPathComponent

class	VariantPersistentColumnData

struct	VariantShreddedStats

struct	VariantStats

struct	VariantStatsData

struct	VariantValue

struct	VariantVector

struct	VariantVectorData

class	vector

class	Vector
	Vector of values of a specified PhysicalType. More...

class	VectorArrayBuffer

struct	VectorAuxiliaryData

class	VectorBuffer
	The VectorBuffer is a class used by the vector to hold its data. More...

class	VectorCache

class	VectorChildBuffer
	The VectorChildBuffer holds a child Vector. More...

class	VectorFSSTStringBuffer

class	VectorListBuffer

struct	VectorOperations

class	VectorStringBuffer

class	VectorStructBuffer

struct	VersioningUtils

struct	VertexXY

struct	VertexXYM

struct	VertexXYZ

struct	VertexXYZM

class	ViewCatalogEntry
	A view catalog entry. More...

struct	ViewColumnInfo

struct	WalAutocheckpointEntriesSetting

struct	WarningsAsErrorsSetting

class	weak_ptr

class	WindowExpression

struct	WindowFunctionDefinition

class	WindowMergeSortTree

class	WindowMergeSortTreeLocalState

struct	WindowPartitionInput

class	WriteAheadLog

struct	WriteBufferRowGroupCountSetting

class	WriteStream

struct	ZstdMinStringLengthSetting

Typedefs
using	qualified_column_set_t = unordered_set< QualifiedColumnName, QualifiedColumnHashFunction, QualifiedColumnEquality >

template<class T >
using	qualified_column_map_t = unordered_map< QualifiedColumnName, T, QualifiedColumnHashFunction, QualifiedColumnEquality >

using	catalog_entry_callback_t = std::function< void(CatalogEntry &)>

template<typename T >
using	logical_index_map_t = unordered_map< LogicalIndex, T, LogicalIndexHashFunction >

using	logical_index_set_t = unordered_set< LogicalIndex, LogicalIndexHashFunction >

template<typename T >
using	physical_index_map_t = unordered_map< PhysicalIndex, T, PhysicalIndexHashFunction >

using	physical_index_set_t = unordered_set< PhysicalIndex, PhysicalIndexHashFunction >

using	thread_id = std::thread::id

typedef ParserExtensionParseResult(*	parse_function_t) (ParserExtensionInfo *info, const string &query)

typedef ParserExtensionPlanResult(*	plan_function_t) (ParserExtensionInfo *info, ClientContext &context, unique_ptr< ParserExtensionParseData > parse_data)

typedef ParserOverrideResult(*	parser_override_function_t) (ParserExtensionInfo *info, const string &query, ParserOptions &options)

typedef ScalarFunction(*	get_scalar_function_t) ()

typedef ScalarFunctionSet(*	get_scalar_function_set_t) ()

typedef AggregateFunction(*	get_aggregate_function_t) ()

typedef AggregateFunctionSet(*	get_aggregate_function_set_t) ()

typedef unique_ptr< ArrowArrayStreamWrapper >(*	stream_factory_produce_t) (uintptr_t stream_factory_ptr, ArrowStreamParameters &parameters)

typedef void(*	stream_factory_get_schema_t) (ArrowArrayStream *stream_factory_ptr, ArrowSchema &schema)

using	bitstring_t = duckdb::string_t

typedef void(*	initialize_t) (ArrowAppendData &result, const LogicalType &type, idx_t capacity)

typedef void(*	append_vector_t) (ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size)

typedef void(*	finalize_t) (ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result)

using	batch_map_t = map< idx_t, unique_ptr< ColumnDataCollection > >

using	batch_iterator_t = typename batch_map_t::iterator

using	digit_t = uint32_t

using	twodigit_t = uint64_t

using	CipherType = EncryptionTypes::CipherType

using	Version = EncryptionTypes::EncryptionVersion

template<class T >
using	arena_vector = vector< T, true, arena_stl_allocator< T > >

template<class T >
using	unsafe_arena_vector = vector< T, false, arena_stl_allocator< T > >

using	TupleDataLocalScanState = TupleDataScanState

typedef void(*	tuple_data_scatter_function_t) (const Vector &source, const TupleDataVectorFormat &source_format, const SelectionVector &append_sel, const idx_t append_count, const TupleDataLayout &layout, const Vector &row_locations, Vector &heap_locations, const idx_t col_idx, const UnifiedVectorFormat &list_format, const vector< TupleDataScatterFunction > &child_functions)

typedef void(*	tuple_data_gather_function_t) (const TupleDataLayout &layout, Vector &row_locations, const idx_t col_idx, const SelectionVector &scan_sel, const idx_t scan_count, Vector &target, const SelectionVector &target_sel, optional_ptr< Vector > list_vector, const vector< TupleDataGatherFunction > &child_functions)

using	InMemoryBlockIteratorState = BlockIteratorState< BlockIteratorStateType::IN_MEMORY >

using	ExternalBlockIteratorState = BlockIteratorState< BlockIteratorStateType::EXTERNAL >

template<class T >
using	column_index_map = unordered_map< ColumnIndex, T, ColumnIndexHashFunction, ColumnIndexEquality >

using	column_index_set = unordered_set< ColumnIndex, ColumnIndexHashFunction, ColumnIndexEquality >

template<typename T >
using	string_map_t = unordered_map< string_t, T, StringHash, StringEquality >

using	string_set_t = unordered_set< string_t, StringHash, StringEquality >

template<typename T >
using	case_insensitive_string_map_t = unordered_map< string_t, T, StringCIHash, StringCIEquality >

using	case_insensitive_string_set_t = unordered_set< string_t, StringCIHash, StringCIEquality >

typedef unordered_map< block_id_t, BufferHandle >	buffer_handle_set_t

typedef basic_stringstream< char >	stringstream

typedef uint64_t	idx_t
	a saner size_t for loop indices etc

typedef int64_t	row_t
	The type used for row identifiers.

typedef uint64_t	hash_t
	The type used for hashes.

typedef uint8_t	data_t
	data pointers

typedef data_t *	data_ptr_t

typedef const data_t *	const_data_ptr_t

typedef uint32_t	sel_t
	Type used for the selection vector.

typedef idx_t	transaction_t
	Type used for transaction timestamps.

typedef idx_t	connection_t
	Type used to identify connections.

typedef idx_t	column_t
	Type used for column identifiers.

typedef idx_t	storage_t
	Type used for storage (column) identifiers.

template<typename T >
using	unique_array = unique_ptr< T[], std::default_delete< T[]>, true >

template<typename T >
using	unsafe_unique_array = unique_ptr< T[], std::default_delete< T[]>, false >

template<typename T >
using	unsafe_unique_ptr = unique_ptr< T, std::default_delete< T >, false >

template<typename T >
using	unsafe_shared_ptr = shared_ptr< T, false >

template<typename T >
using	unsafe_weak_ptr = weak_ptr< T, false >

template<typename T >
using	reference = std::reference_wrapper< T >

template<typename T >
using	const_reference = std::reference_wrapper< const T >

template<typename T >
using	unsafe_vector = vector< T, false >

template<typename T >
using	unsafe_optional_ptr = optional_ptr< T, false >

template<class T >
using	child_list_t = vector< std::pair< std::string, T > >

template<class T >
using	buffer_ptr = shared_ptr< T >
	FIXME: this should be a single_thread_ptr.

using	union_tag_t = uint8_t

template<typename T >
using	case_insensitive_map_t = unordered_map< string, T, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality >

using	case_insensitive_set_t = unordered_set< string, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality >

template<typename T >
using	case_insensitive_tree_t = map< string, T, CaseInsensitiveStringCompare >

template<typename T , typename TGT >
using	reference_map_t = unordered_map< reference< T >, TGT, ReferenceHashFunction< T >, ReferenceEquality< T > >

template<typename T >
using	reference_set_t = unordered_set< reference< T >, ReferenceHashFunction< T >, ReferenceEquality< T > >

typedef data_ptr_t(*	allocate_function_ptr_t) (PrivateAllocatorData *private_data, idx_t size)

typedef void(*	free_function_ptr_t) (PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size)

typedef data_ptr_t(*	reallocate_function_ptr_t) (PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size, idx_t size)

using	validity_t = uint64_t

template<class T >
using	arena_ptr = unique_ptr< T, arena_deleter< T > >

template<class T >
using	unsafe_arena_ptr = unique_ptr< T, arena_deleter< T >, false >

using	block_id_t = int64_t

using	named_parameter_type_map_t = case_insensitive_map_t< LogicalType >

using	named_parameter_map_t = case_insensitive_map_t< Value >

using	dependency_scan_t = std::function< void(const string &name, shared_ptr< DependencyItem > item)>

template<typename T >
using	unsafe_array_ptr = array_ptr< T, false >

typedef std::function< void(DataChunk &, ExpressionState &, Vector &)>	scalar_function_t
	The scalar function type.

typedef unique_ptr< FunctionData >(*	bind_scalar_function_t) (ClientContext &context, ScalarFunction &bound_function, vector< unique_ptr< Expression > > &arguments)
	The type to bind the scalar function and to create the function data.

typedef unique_ptr< FunctionData >(*	bind_scalar_function_extended_t) (ScalarFunctionBindInput &bind_input, ScalarFunction &bound_function, vector< unique_ptr< Expression > > &arguments)

typedef unique_ptr< FunctionLocalState >(*	init_local_state_t) (ExpressionState &state, const BoundFunctionExpression &expr, FunctionData *bind_data)
	The type to initialize a thread local state for the scalar function.

typedef unique_ptr< BaseStatistics >(*	function_statistics_t) (ClientContext &context, FunctionStatisticsInput &input)
	The type to propagate statistics for this scalar function.

typedef LogicalType(*	bind_lambda_function_t) (ClientContext &context, const vector< LogicalType > &function_child_types, idx_t parameter_idx)
	The type to bind lambda-specific parameter types.

typedef void(*	get_modified_databases_t) (ClientContext &context, FunctionModifiedDatabasesInput &input)
	The type to bind lambda-specific parameter types.

typedef void(*	function_serialize_t) (Serializer &serializer, const optional_ptr< FunctionData > bind_data, const ScalarFunction &function)

typedef unique_ptr< FunctionData >(*	function_deserialize_t) (Deserializer &deserializer, ScalarFunction &function)

typedef unique_ptr< Expression >(*	function_bind_expression_t) (FunctionBindExpressionInput &input)
	The type to bind lambda-specific parameter types.

using	SubFrames = vector< FrameBounds >

using	GroupingSet = set< idx_t >

using	FrameStats = array< FrameDelta, 2 >
	The half-open ranges of frame boundary values relative to the current row.

typedef idx_t(*	aggregate_size_t) (const AggregateFunction &function)
	The type used for sizing hashed aggregate function states.

typedef void(*	aggregate_initialize_t) (const AggregateFunction &function, data_ptr_t state)
	The type used for initializing hashed aggregate function states.

typedef void(*	aggregate_update_t) (Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &state, idx_t count)
	The type used for updating hashed aggregate functions.

typedef void(*	aggregate_combine_t) (Vector &state, Vector &combined, AggregateInputData &aggr_input_data, idx_t count)
	The type used for combining hashed aggregate states.

typedef void(*	aggregate_finalize_t) (Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count, idx_t offset)
	The type used for finalizing hashed aggregate function payloads.

typedef unique_ptr< BaseStatistics >(*	aggregate_statistics_t) (ClientContext &context, BoundAggregateExpression &expr, AggregateStatisticsInput &input)
	The type used for propagating statistics in aggregate functions (optional)

typedef unique_ptr< FunctionData >(*	bind_aggregate_function_t) (ClientContext &context, AggregateFunction &function, vector< unique_ptr< Expression > > &arguments)
	Binds the scalar function and creates the function data.

typedef void(*	aggregate_destructor_t) (Vector &state, AggregateInputData &aggr_input_data, idx_t count)
	The type used for the aggregate destructor method. NOTE: this method is used in destructors and MAY NOT throw.

typedef void(*	aggregate_simple_update_t) (Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state, idx_t count)
	The type used for updating simple (non-grouped) aggregate functions.

typedef void(*	aggregate_window_t) (AggregateInputData &aggr_input_data, const WindowPartitionInput &partition, const_data_ptr_t g_state, data_ptr_t l_state, const SubFrames &subframes, Vector &result, idx_t rid)
	The type used for computing complex/custom windowed aggregate functions (optional)

typedef void(*	aggregate_wininit_t) (AggregateInputData &aggr_input_data, const WindowPartitionInput &partition, data_ptr_t g_state)
	The type used for initializing shared complex/custom windowed aggregate state (optional)

typedef void(*	aggregate_serialize_t) (Serializer &serializer, const optional_ptr< FunctionData > bind_data, const AggregateFunction &function)

typedef unique_ptr< FunctionData >(*	aggregate_deserialize_t) (Deserializer &deserializer, AggregateFunction &function)

template<typename T >
using	column_binding_map_t = unordered_map< ColumnBinding, T, ColumnBindingHashFunction, ColumnBindingEquality >

using	column_binding_set_t = unordered_set< ColumnBinding, ColumnBindingHashFunction, ColumnBindingEquality >

template<typename T >
using	expression_map_t = unordered_map< reference< Expression >, T, ExpressionHashFunction< Expression >, ExpressionEquality< Expression > >

using	expression_set_t = unordered_set< reference< Expression >, ExpressionHashFunction< Expression >, ExpressionEquality< Expression > >

template<typename T >
using	parsed_expression_map_t = unordered_map< reference< ParsedExpression >, T, ExpressionHashFunction< ParsedExpression >, ExpressionEquality< ParsedExpression > >

using	parsed_expression_set_t = unordered_set< reference< ParsedExpression >, ExpressionHashFunction< ParsedExpression >, ExpressionEquality< ParsedExpression > >

using	virtual_column_map_t = unordered_map< column_t, TableColumn >

typedef unique_ptr< FunctionData >(*	table_function_bind_t) (ClientContext &context, TableFunctionBindInput &input, vector< LogicalType > &return_types, vector< string > &names)

typedef unique_ptr< TableRef >(*	table_function_bind_replace_t) (ClientContext &context, TableFunctionBindInput &input)

typedef unique_ptr< LogicalOperator >(*	table_function_bind_operator_t) (ClientContext &context, TableFunctionBindInput &input, idx_t bind_index, vector< string > &return_names)

typedef unique_ptr< GlobalTableFunctionState >(*	table_function_init_global_t) (ClientContext &context, TableFunctionInitInput &input)

typedef unique_ptr< LocalTableFunctionState >(*	table_function_init_local_t) (ExecutionContext &context, TableFunctionInitInput &input, GlobalTableFunctionState *global_state)

typedef unique_ptr< BaseStatistics >(*	table_statistics_t) (ClientContext &context, const FunctionData *bind_data, column_t column_index)

typedef unique_ptr< BaseStatistics >(*	table_statistics_extended_t) (ClientContext &context, TableFunctionGetStatisticsInput &input)

typedef void(*	table_function_t) (ClientContext &context, TableFunctionInput &data, DataChunk &output)

typedef OperatorResultType(*	table_in_out_function_t) (ExecutionContext &context, TableFunctionInput &data, DataChunk &input, DataChunk &output)

typedef OperatorFinalizeResultType(*	table_in_out_function_final_t) (ExecutionContext &context, TableFunctionInput &data, DataChunk &output)

typedef OperatorPartitionData(*	table_function_get_partition_data_t) (ClientContext &context, TableFunctionGetPartitionInput &input)

typedef BindInfo(*	table_function_get_bind_info_t) (const optional_ptr< FunctionData > bind_data)

typedef unique_ptr< MultiFileReader >(*	table_function_get_multi_file_reader_t) (const TableFunction &)

typedef bool(*	table_function_supports_pushdown_type_t) (const FunctionData &bind_data, idx_t col_idx)

typedef bool(*	table_function_supports_pushdown_extract_t) (const FunctionData &bind_data, const LogicalIndex &col_idx)

typedef double(*	table_function_progress_t) (ClientContext &context, const FunctionData bind_data, const GlobalTableFunctionState global_state)

typedef void(*	table_function_dependency_t) (LogicalDependencyList &dependencies, const FunctionData *bind_data)

typedef unique_ptr< NodeStatistics >(*	table_function_cardinality_t) (ClientContext &context, const FunctionData *bind_data)

typedef idx_t(*	table_function_rows_scanned_t) (GlobalTableFunctionState &global_state, LocalTableFunctionState &local_state)

typedef void(*	table_function_pushdown_complex_filter_t) (ClientContext &context, LogicalGet &get, FunctionData *bind_data, vector< unique_ptr< Expression > > &filters)

typedef bool(*	table_function_pushdown_expression_t) (ClientContext &context, const LogicalGet &get, Expression &expr)

typedef InsertionOrderPreservingMap< string >(*	table_function_to_string_t) (TableFunctionToStringInput &input)

typedef InsertionOrderPreservingMap< string >(*	table_function_dynamic_to_string_t) (TableFunctionDynamicToStringInput &input)

typedef void(*	table_function_serialize_t) (Serializer &serializer, const optional_ptr< FunctionData > bind_data, const TableFunction &function)

typedef unique_ptr< FunctionData >(*	table_function_deserialize_t) (Deserializer &deserializer, TableFunction &function)

typedef void(*	table_function_type_pushdown_t) (ClientContext &context, optional_ptr< FunctionData > bind_data, const unordered_map< idx_t, LogicalType > &new_column_types)

typedef TablePartitionInfo(*	table_function_get_partition_info_t) (ClientContext &context, TableFunctionPartitionInput &input)

typedef vector< PartitionStatistics >(*	table_function_get_partition_stats_t) (ClientContext &context, GetPartitionStatsInput &input)

typedef virtual_column_map_t(*	table_function_get_virtual_columns_t) (ClientContext &context, optional_ptr< FunctionData > bind_data)

typedef vector< column_t >(*	table_function_get_row_id_columns) (ClientContext &context, optional_ptr< FunctionData > bind_data)

typedef void(*	table_function_set_scan_order) (unique_ptr< RowGroupOrderOptions > order_options, optional_ptr< FunctionData > bind_data)

using	catalog_entry_set_t = unordered_set< reference< CatalogEntry >, CatalogEntryHashFunction, CatalogEntryEquality >

template<typename T >
using	catalog_entry_map_t = unordered_map< reference< CatalogEntry >, T, CatalogEntryHashFunction, CatalogEntryEquality >

using	catalog_entry_vector_t = vector< reference< CatalogEntry > >

using	dependency_set_t = unordered_set< Dependency, DependencyHashFunction, DependencyEquality >

template<typename T >
using	unsafe_deque = deque< T, false >

using	Profiler = BaseProfiler< steady_clock >

typedef std::function< unique_ptr< ProgressBarDisplay >()>	progress_bar_display_create_func_t

typedef unordered_set< MetricType, MetricTypeHashFunction >	profiler_settings_t

typedef unordered_map< MetricType, Value, MetricTypeHashFunction >	profiler_metrics_t

typedef void(*	set_callback_t) (SettingCallbackInfo &info, Value &parameter)

typedef void(*	set_global_function_t) (DatabaseInstance *db, DBConfig &config, const Value &parameter)

typedef void(*	set_local_function_t) (ClientContext &context, const Value &parameter)

typedef void(*	reset_global_function_t) (DatabaseInstance *db, DBConfig &config)

typedef void(*	reset_local_function_t) (ClientContext &context)

typedef Value(*	get_setting_function_t) (const ClientContext &context)

typedef void(*	set_option_callback_t) (ClientContext &context, SetScope scope, Value &parameter)

typedef std::function< unique_ptr< PhysicalOperator >(ClientContext &context, PreparedStatementData &data)>	get_result_collector_t

typedef void(*	cast_arrow_duck_t) (ClientContext &context, Vector &source, Vector &result, idx_t count)

typedef void(*	cast_duck_arrow_t) (ClientContext &context, Vector &source, Vector &result, idx_t count)

using	arrow_column_map_t = unordered_map< idx_t, shared_ptr< ArrowType > >

typedef void(*	populate_arrow_schema_t) (DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type, ClientContext &context, const ArrowTypeExtension &extension)

typedef unique_ptr< ArrowType >(*	get_type_t) (ClientContext &context, const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata)

typedef unique_ptr< IndexBuildBindData >(*	index_build_bind_t) (IndexBuildBindInput &input)

typedef bool(*	index_build_sort_t) (IndexBuildSortInput &input)

typedef unique_ptr< IndexBuildGlobalState >(*	index_build_global_init_t) (IndexBuildInitGlobalStateInput &input)

typedef unique_ptr< IndexBuildLocalState >(*	index_build_local_init_t) (IndexBuildInitLocalStateInput &input)

typedef void(*	index_build_sink_t) (IndexBuildSinkInput &input, DataChunk &key_chunk, DataChunk &row_chunk)

typedef void(*	index_build_combine_t) (IndexBuildCombineInput &input)

typedef unique_ptr< BoundIndex >(*	index_build_finalize_t) (IndexBuildFinalizeInput &input)

typedef unique_ptr< BoundIndex >(*	index_create_function_t) (CreateIndexInput &input)

typedef PhysicalOperator &(*	index_build_plan_t) (PlanIndexInput &input)

typedef bool(*	cast_function_t) (Vector &source, Vector &result, idx_t count, CastParameters &parameters)

typedef unique_ptr< FunctionLocalState >(*	init_cast_local_state_t) (CastLocalStateParameters &parameters)

typedef unique_ptr< TableRef >(*	replacement_scan_t) (ClientContext &context, ReplacementScanInput &input, optional_ptr< ReplacementScanData > data)

typedef void(*	encode_t) (CSVEncoderBuffer &encoded_buffer, char decoded_buffer, idx_t &decoded_buffer_current_position, const idx_t decoded_buffer_size, char remaining_bytes_buffer, idx_t &remaining_bytes_size, EncodingFunction *encoding_function)
	Decode function, basically takes information about the decoded and the encoded buffers.

template<typename T , typename Container = std::deque<T>>
using	unsafe_queue = queue< T, Container, false >

typedef void(*	line_printer_f) (OutputStream stream, const string &str)

typedef void(*	warning_callback_t) (std::string)

typedef BoundCastInfo(*	bind_cast_function_t) (BindCastInput &input, const LogicalType &source, const LogicalType &target)

typedef int64_t(*	implicit_cast_cost_t) (const LogicalType &from, const LogicalType &to)

typedef string(*	pragma_query_t) (ClientContext &context, const FunctionParameters &parameters)
	Return a substitute query to execute instead of this pragma statement.

typedef void(*	pragma_function_t) (ClientContext &context, const FunctionParameters &parameters)
	Execute the main pragma function.

using	bound_parameter_map_t = case_insensitive_map_t< shared_ptr< BoundParameterData > >

typedef uint16_t	field_id_t

template<class... >
using	void_t = void

using	BlockLock = unique_lock< mutex >

template<typename T >
using	perfect_map_t = unordered_map< idx_t, T, PerfectHash, PerfectEquality >

using	perfect_set_t = unordered_set< idx_t, PerfectHash, PerfectEquality >

typedef unique_ptr< AnalyzeState >(*	compression_init_analyze_t) (ColumnData &col_data, PhysicalType type)
	The system then decides which compression function to use based on the analyzed score (returned from final_analyze)

typedef bool(*	compression_analyze_t) (AnalyzeState &state, Vector &input, idx_t count)

typedef idx_t(*	compression_final_analyze_t) (AnalyzeState &state)

typedef unique_ptr< CompressionState >(*	compression_init_compression_t) (ColumnDataCheckpointData &checkpoint_data, unique_ptr< AnalyzeState > state)

typedef void(*	compression_compress_data_t) (CompressionState &state, Vector &scan_vector, idx_t count)

typedef void(*	compression_compress_finalize_t) (CompressionState &state)

typedef void(*	compression_init_prefetch_t) (ColumnSegment &segment, PrefetchState &prefetch_state)

typedef unique_ptr< SegmentScanState >(*	compression_init_segment_scan_t) (const QueryContext &context, ColumnSegment &segment)

typedef void(*	compression_scan_vector_t) (ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result)
	Function prototype used for reading an entire vector (STANDARD_VECTOR_SIZE)

typedef void(*	compression_scan_partial_t) (ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset)
	Function prototype used for reading an arbitrary ('scan_count') number of values.

typedef void(*	compression_select_t) (ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result, const SelectionVector &sel, idx_t sel_count)
	Function prototype used for reading a subset of the values of a vector indicated by a selection vector.

typedef void(*	compression_filter_t) (ColumnSegment &segment, ColumnScanState &state, idx_t vector_count, Vector &result, SelectionVector &sel, idx_t &sel_count, const TableFilter &filter, TableFilterState &filter_state)
	Function prototype used for applying a filter to a vector while scanning that vector.

typedef void(*	compression_fetch_row_t) (ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx)
	Function prototype used for reading a single value.

typedef void(*	compression_skip_t) (ColumnSegment &segment, ColumnScanState &state, idx_t skip_count)

typedef unique_ptr< CompressedSegmentState >(*	compression_init_segment_t) (ColumnSegment &segment, block_id_t block_id, optional_ptr< ColumnSegmentState > segment_state)

typedef unique_ptr< CompressionAppendState >(*	compression_init_append_t) (ColumnSegment &segment)

typedef idx_t(*	compression_append_t) (CompressionAppendState &append_state, ColumnSegment &segment, SegmentStatistics &stats, UnifiedVectorFormat &data, idx_t offset, idx_t count)

typedef idx_t(*	compression_finalize_append_t) (ColumnSegment &segment, SegmentStatistics &stats)

typedef void(*	compression_revert_append_t) (ColumnSegment &segment, idx_t new_count)

typedef unique_ptr< ColumnSegmentState >(*	compression_serialize_state_t) (ColumnSegment &segment)
	Function prototype for serializing the segment state.

typedef unique_ptr< ColumnSegmentState >(*	compression_deserialize_state_t) (Deserializer &deserializer)
	Function prototype for deserializing the segment state.

typedef void(*	compression_visit_block_ids_t) (const ColumnSegment &segment, BlockIdVisitor &visitor)
	Function prototype for cleaning up the segment state when the column data is dropped.

typedef InsertionOrderPreservingMap< string >(*	compression_get_segment_info_t) (QueryContext context, ColumnSegment &segment)
	Function prototype for retrieving segment information straight from the column segment.

template<typename T >
using	unsafe_atomic_ptr = atomic_ptr< T, false >

using	column_segment_vector_t = vector< SegmentNode< ColumnSegment > >

typedef unordered_map< HivePartitionKey, idx_t, HivePartitionKey::Hash, HivePartitionKey::Equality >	hive_partition_map_t
	Maps hive partitions to partition_ids.

typedef unique_ptr< BaseSecret >(*	secret_deserializer_t) (Deserializer &deserializer, BaseSecret base_secret)

typedef unique_ptr< BaseSecret >(*	create_secret_function_t) (ClientContext &context, CreateSecretInput &input)

typedef LogicalType(*	bind_logical_type_function_t) (BindLogicalTypeInput &input)
	The type to bind type modifiers to a type.

using	UUIDv4 = UUID

typedef BoundStatement(*	copy_to_plan_t) (Binder &binder, CopyStatement &stmt)

typedef void(*	copy_options_t) (ClientContext &context, CopyOptionsInput &input)

typedef unique_ptr< FunctionData >(*	copy_to_bind_t) (ClientContext &context, CopyFunctionBindInput &input, const vector< string > &names, const vector< LogicalType > &sql_types)

typedef unique_ptr< LocalFunctionData >(*	copy_to_initialize_local_t) (ExecutionContext &context, FunctionData &bind_data)

typedef unique_ptr< GlobalFunctionData >(*	copy_to_initialize_global_t) (ClientContext &context, FunctionData &bind_data, const string &file_path)

typedef void(*	copy_to_sink_t) (ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate, LocalFunctionData &lstate, DataChunk &input)

typedef void(*	copy_to_combine_t) (ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate, LocalFunctionData &lstate)

typedef void(*	copy_to_finalize_t) (ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate)

typedef void(*	copy_to_serialize_t) (Serializer &serializer, const FunctionData &bind_data, const CopyFunction &function)

typedef unique_ptr< FunctionData >(*	copy_to_deserialize_t) (Deserializer &deserializer, CopyFunction &function)

typedef unique_ptr< FunctionData >(*	copy_from_bind_t) (ClientContext &context, CopyFromFunctionBindInput &info, vector< string > &expected_names, vector< LogicalType > &expected_types)

typedef CopyFunctionExecutionMode(*	copy_to_execution_mode_t) (bool preserve_insertion_order, bool supports_batch_index)

typedef unique_ptr< PreparedBatchData >(*	copy_prepare_batch_t) (ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate, unique_ptr< ColumnDataCollection > collection)

typedef void(*	copy_flush_batch_t) (ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate, PreparedBatchData &batch)

typedef idx_t(*	copy_desired_batch_size_t) (ClientContext &context, FunctionData &bind_data)

typedef bool(*	copy_rotate_files_t) (FunctionData &bind_data, const optional_idx &file_size_bytes)

typedef bool(*	copy_rotate_next_file_t) (GlobalFunctionData &gstate, FunctionData &bind_data, const optional_idx &file_size_bytes)

typedef void(*	copy_to_get_written_statistics_t) (ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate, CopyFunctionFileStatistics &statistics)

typedef vector< unique_ptr< Expression > >(*	copy_to_select_t) (CopyToSelectInput &input)

typedef void(*	copy_to_initialize_operator_t) (GlobalFunctionData &gstate, const PhysicalOperator &op)

Enumerations
enum class	CatalogSetPathType { SET_SCHEMA , SET_SCHEMAS , SET_DIRECTLY }

enum class	CollationType { ALL_COLLATIONS , COMBINABLE_COLLATIONS }

enum class	BindingType { BASE , TABLE , DUMMY , CATALOG_ENTRY , CTE }

enum class	CTEType { CAN_BE_REFERENCED , CANNOT_BE_REFERENCED }

enum class	ColumnBindType { EXPAND_GENERATED_COLUMNS , DO_NOT_EXPAND_GENERATED_COLUMNS }

enum class	StarExpressionType : uint8_t { STAR , COLUMNS , UNPACKED , NONE }

enum class	BindingMode : uint8_t { STANDARD_BINDING , EXTRACT_NAMES , EXTRACT_REPLACEMENT_SCANS , EXTRACT_QUALIFIED_NAMES }

enum class	BinderType : uint8_t { REGULAR_BINDER , VIEW_BINDER }

enum class	MacroType : uint8_t { VOID_MACRO = 0 , TABLE_MACRO = 1 , SCALAR_MACRO = 2 }

enum class	ViewBindState { BOUND , BINDING , UNBOUND }

enum class	BindViewAction { BIND_IF_UNBOUND , FORCE_REBIND }

enum class	ExtensionLoadResult : uint8_t { LOADED_EXTENSION = 0 , EXTENSION_UNKNOWN = 1 , NOT_LOADED = 2 }

enum class	ExtensionUpdateResultTag : uint8_t { UNKNOWN = 0 , NO_UPDATE_AVAILABLE = 1 , NOT_A_REPOSITORY = 2 , NOT_INSTALLED = 3 , STATICALLY_LOADED = 4 , MISSING_INSTALL_INFO = 5 , REDOWNLOADED = 254 , UPDATED = 255 }

enum class	ExtraDropInfoType : uint8_t { INVALID = 0 , SECRET_INFO = 1 }

enum class	DependencyEntryType : uint8_t { SUBJECT , DEPENDENT }

enum class	UndoFlags : uint32_t { EMPTY_ENTRY = 0 , CATALOG_ENTRY = 1 , INSERT_TUPLE = 2 , DELETE_TUPLE = 3 , UPDATE_TUPLE = 4 , SEQUENCE_VALUE = 5 , ATTACHED_DATABASE = 6 }

enum class	ActiveTransactionState { UNSET , OTHER_TRANSACTIONS , NO_OTHER_TRANSACTIONS }

enum class	WALType : uint8_t { INVALID = 0 , CREATE_TABLE = 1 , DROP_TABLE = 2 , CREATE_SCHEMA = 3 , DROP_SCHEMA = 4 , CREATE_VIEW = 5 , DROP_VIEW = 6 , CREATE_SEQUENCE = 8 , DROP_SEQUENCE = 9 , SEQUENCE_VALUE = 10 , CREATE_MACRO = 11 , DROP_MACRO = 12 , CREATE_TYPE = 13 , DROP_TYPE = 14 , ALTER_INFO = 20 , CREATE_TABLE_MACRO = 21 , DROP_TABLE_MACRO = 22 , CREATE_INDEX = 23 , DROP_INDEX = 24 , USE_TABLE = 25 , INSERT_TUPLE = 26 , DELETE_TUPLE = 27 , UPDATE_TUPLE = 28 , ROW_GROUP_DATA = 29 , WAL_VERSION = 98 , CHECKPOINT = 99 , WAL_FLUSH = 100 }

enum class	WALInitState { NO_WAL , UNINITIALIZED , UNINITIALIZED_REQUIRES_TRUNCATE , INITIALIZED }

enum class	CompressInMemory { AUTOMATIC , COMPRESS , DO_NOT_COMPRESS }

enum class	PartialBlockType { FULL_CHECKPOINT , APPEND_TO_TABLE , IN_MEMORY_CHECKPOINT }

enum class	NType : uint8_t { PREFIX = 1 , LEAF = 2 , NODE_4 = 3 , NODE_16 = 4 , NODE_48 = 5 , NODE_256 = 6 , LEAF_INLINED = 7 , NODE_7_LEAF = 8 , NODE_15_LEAF = 9 , NODE_256_LEAF = 10 }

enum class	GateStatus : uint8_t { GATE_NOT_SET = 0 , GATE_SET = 1 }

enum class	VerifyExistenceType : uint8_t { APPEND = 0 , APPEND_FK = 1 , DELETE_FK = 2 }

enum class	ARTConflictType : uint8_t { NO_CONFLICT = 0 , CONSTRAINT = 1 , TRANSACTION = 2 }

enum class	ARTHandlingResult : uint8_t { CONTINUE = 0 , SKIP = 1 , YIELD = 2 , NONE = 3 }

enum class	AlterScalarFunctionType : uint8_t { INVALID = 0 , ADD_FUNCTION_OVERLOADS = 1 }

enum class	CoordinateReferenceSystemType : uint8_t { INVALID = 0 , SRID = 1 , AUTH_CODE = 2 , PROJJSON = 3 , WKT2_2019 = 4 }

enum class	ExtraTypeInfoType : uint8_t { INVALID_TYPE_INFO = 0 , GENERIC_TYPE_INFO = 1 , DECIMAL_TYPE_INFO = 2 , STRING_TYPE_INFO = 3 , LIST_TYPE_INFO = 4 , STRUCT_TYPE_INFO = 5 , ENUM_TYPE_INFO = 6 , UNBOUND_TYPE_INFO = 7 , AGGREGATE_STATE_TYPE_INFO = 8 , ARRAY_TYPE_INFO = 9 , ANY_TYPE_INFO = 10 , INTEGER_LITERAL_TYPE_INFO = 11 , TEMPLATE_TYPE_INFO = 12 , GEO_TYPE_INFO = 13 }
	Extra Type Info Type. More...

enum	EnumDictType : uint8_t { INVALID = 0 , VECTOR_DICT = 1 }

enum class	AlterTableFunctionType : uint8_t { INVALID = 0 , ADD_FUNCTION_OVERLOADS = 1 }

enum class	AllowParserOverride : uint8_t { DEFAULT_OVERRIDE , FALLBACK_OVERRIDE , STRICT_OVERRIDE }

enum class	ParserExtensionResultType : uint8_t { PARSE_SUCCESSFUL , DISPLAY_ORIGINAL_ERROR , DISPLAY_EXTENSION_ERROR }

enum class	ValueRenderAlignment { LEFT , MIDDLE , RIGHT }

enum class	RenderMode : uint8_t { ROWS , COLUMNS }

enum class	ResultRenderType { LAYOUT , COLUMN_NAME , COLUMN_TYPE , VALUE , NULL_VALUE , FOOTER , STRING_LITERAL }

enum class	LargeNumberRendering { NONE = 0 , FOOTER = 1 , ALL = 2 }

enum	AbsoluteNumberComparison : uint8_t { EQUAL = 0 , GREATER = 1 , SMALLER = 2 }

enum class	UnicodeType { INVALID , ASCII , UTF8 }

enum class	UnicodeInvalidReason { BYTE_MISMATCH , INVALID_UNICODE }

enum class	RenderRowType { ROW_VALUES , SEPARATOR , DIVIDER , FOOTER }

enum class	JSONFormattingMode { STANDARD , COMPACT_VERTICAL , COMPACT_HORIZONTAL }

enum class	JSONComponentType { BRACKET_OPEN , BRACKET_CLOSE , LITERAL , COLON , COMMA , NULL_VALUE }

enum class	JSONFormattingResult { SUCCESS , TOO_MANY_ROWS , TOO_WIDE }

enum class	CSVNewLineMode { WRITE_BEFORE = 0 , WRITE_AFTER = 1 }

enum class	AggregateHandling : uint8_t { STANDARD_HANDLING , NO_AGGREGATES_ALLOWED , FORCE_AGGREGATES }

enum class	CheckpointAbort : uint8_t { NO_ABORT = 0 , DEBUG_ABORT_BEFORE_TRUNCATE = 1 , DEBUG_ABORT_BEFORE_HEADER = 2 , DEBUG_ABORT_AFTER_FREE_LIST_WRITE = 3 , DEBUG_ABORT_BEFORE_WAL_FINISH = 4 , DEBUG_ABORT_BEFORE_MOVING_RECOVERY = 5 , DEBUG_ABORT_BEFORE_DELETING_CHECKPOINT_WAL = 6 }

enum class	CopyOverwriteMode : uint8_t { COPY_ERROR_ON_CONFLICT = 0 , COPY_OVERWRITE = 1 , COPY_OVERWRITE_OR_IGNORE = 2 , COPY_APPEND = 3 }

enum class	DatePartSpecifier : uint8_t { YEAR , MONTH , DAY , DECADE , CENTURY , MILLENNIUM , MICROSECONDS , MILLISECONDS , SECOND , MINUTE , HOUR , DOW , ISODOW , WEEK , ISOYEAR , QUARTER , DOY , YEARWEEK , ERA , TIMEZONE , TIMEZONE_HOUR , TIMEZONE_MINUTE , EPOCH , JULIAN_DAY , INVALID , BEGIN_BIGINT = YEAR , BEGIN_DOUBLE = EPOCH , BEGIN_INVALID = INVALID }

enum class	DeprecatedUsingKeySyntax : uint8_t { DEFAULT = 0 , UNION_AS_UNION_ALL = 1 }

enum class	HTTPStatusCode : uint16_t { INVALID = 0 , Continue_100 = 100 , SwitchingProtocol_101 = 101 , Processing_102 = 102 , EarlyHints_103 = 103 , OK_200 = 200 , Created_201 = 201 , Accepted_202 = 202 , NonAuthoritativeInformation_203 = 203 , NoContent_204 = 204 , ResetContent_205 = 205 , PartialContent_206 = 206 , MultiStatus_207 = 207 , AlreadyReported_208 = 208 , IMUsed_226 = 226 , MultipleChoices_300 = 300 , MovedPermanently_301 = 301 , Found_302 = 302 , SeeOther_303 = 303 , NotModified_304 = 304 , UseProxy_305 = 305 , unused_306 = 306 , TemporaryRedirect_307 = 307 , PermanentRedirect_308 = 308 , BadRequest_400 = 400 , Unauthorized_401 = 401 , PaymentRequired_402 = 402 , Forbidden_403 = 403 , NotFound_404 = 404 , MethodNotAllowed_405 = 405 , NotAcceptable_406 = 406 , ProxyAuthenticationRequired_407 = 407 , RequestTimeout_408 = 408 , Conflict_409 = 409 , Gone_410 = 410 , LengthRequired_411 = 411 , PreconditionFailed_412 = 412 , PayloadTooLarge_413 = 413 , UriTooLong_414 = 414 , UnsupportedMediaType_415 = 415 , RangeNotSatisfiable_416 = 416 , ExpectationFailed_417 = 417 , ImATeapot_418 = 418 , MisdirectedRequest_421 = 421 , UnprocessableContent_422 = 422 , Locked_423 = 423 , FailedDependency_424 = 424 , TooEarly_425 = 425 , UpgradeRequired_426 = 426 , PreconditionRequired_428 = 428 , TooManyRequests_429 = 429 , RequestHeaderFieldsTooLarge_431 = 431 , UnavailableForLegalReasons_451 = 451 , InternalServerError_500 = 500 , NotImplemented_501 = 501 , BadGateway_502 = 502 , ServiceUnavailable_503 = 503 , GatewayTimeout_504 = 504 , HttpVersionNotSupported_505 = 505 , VariantAlsoNegotiates_506 = 506 , InsufficientStorage_507 = 507 , LoopDetected_508 = 508 , NotExtended_510 = 510 , NetworkAuthenticationRequired_511 = 511 }

enum class	MergeActionType : uint8_t { MERGE_UPDATE , MERGE_DELETE , MERGE_INSERT , MERGE_DO_NOTHING , MERGE_ERROR }

enum class	MergeActionCondition : uint8_t { WHEN_MATCHED , WHEN_NOT_MATCHED_BY_SOURCE , WHEN_NOT_MATCHED_BY_TARGET }

enum class	OrdinalityType : uint8_t { WITHOUT_ORDINALITY = 0 , WITH_ORDINALITY = 1 }

enum class	PreserveOrderType : uint8_t { AUTOMATIC = 0 , PRESERVE_ORDER = 1 , DONT_PRESERVE_ORDER = 2 }

enum class	QuantileSerializationType : uint8_t { NON_DECIMAL = 0 , DECIMAL_DISCRETE , DECIMAL_DISCRETE_LIST , DECIMAL_CONTINUOUS , DECIMAL_CONTINUOUS_LIST }

enum class	SetType : uint8_t { SET = 0 , RESET = 1 }

enum class	StorageBlockPrefetch : uint8_t { REMOTE_ONLY = 0 , NEVER = 1 , ALWAYS_PREFETCH = 2 , DEBUG_FORCE_ALWAYS = 3 }

enum class	SubqueryType : uint8_t { INVALID = 0 , SCALAR = 1 , EXISTS = 2 , NOT_EXISTS = 3 , ANY = 4 }

enum class	TupleDataValidityType : uint8_t { CAN_HAVE_NULL_VALUES = 0 , CANNOT_HAVE_NULL_VALUES = 1 }

enum class	TupleDataNestednessType : uint8_t { TOP_LEVEL_LAYOUT = 0 , NESTED_STRUCT_LAYOUT = 1 }

enum class	WindowAggregationMode : uint32_t { WINDOW = 0 , COMBINE , SEPARATE }

enum class	FileNameSegmentType : uint8_t { LITERAL , UUID_V4 , UUID_V7 , OFFSET }

enum class	RequestType : uint8_t { GET_REQUEST , PUT_REQUEST , HEAD_REQUEST , DELETE_REQUEST , POST_REQUEST }

enum class	MultiFileFileState : uint8_t { UNOPENED , OPENING , OPEN , SKIPPED , CLOSED }

enum class	FileExpandResult : uint8_t { NO_FILES , SINGLE_FILE , MULTIPLE_FILES }

enum class	MultiFileListScanType { ALWAYS_FETCH , FETCH_IF_AVAILABLE }

enum class	FileExpansionType { ALL_FILES_EXPANDED , NOT_ALL_FILES_KNOWN }

enum class	ExponentType : uint8_t { NONE , POSITIVE , NEGATIVE }

enum class	SortKeyType : uint8_t { INVALID = 0 , NO_PAYLOAD_FIXED_8 = 1 , NO_PAYLOAD_FIXED_16 = 2 , NO_PAYLOAD_FIXED_24 = 3 , NO_PAYLOAD_FIXED_32 = 4 , NO_PAYLOAD_VARIABLE_32 = 5 , PAYLOAD_FIXED_16 = 6 , PAYLOAD_FIXED_24 = 7 , PAYLOAD_FIXED_32 = 8 , PAYLOAD_VARIABLE_32 = 9 }

enum class	ConflictManagerMode : uint8_t { SCAN , THROW }

enum class	LookupResultType : uint8_t { LOOKUP_MISS , LOOKUP_HIT , LOOKUP_NULL }

enum class	TupleDataPinProperties : uint8_t { INVALID , KEEP_EVERYTHING_PINNED , UNPIN_AFTER_DONE , DESTROY_AFTER_DONE , ALREADY_PINNED }

enum class	BlockIteratorStateType : int8_t { IN_MEMORY , EXTERNAL }

enum class	PartitionedTupleDataType : uint8_t { INVALID , RADIX }

enum class	VariantValueType : uint8_t { PRIMITIVE , OBJECT , ARRAY , MISSING }

enum class	ARTScanHandling : uint8_t { EMPLACE , POP }

enum class	ARTScanResult : uint8_t { COMPLETED = 0 , PAUSED = 1 }

enum class	CSVState : uint8_t { STANDARD = 0 , DELIMITER = 1 , DELIMITER_FIRST_BYTE = 2 , DELIMITER_SECOND_BYTE = 3 , DELIMITER_THIRD_BYTE = 4 , RECORD_SEPARATOR = 5 , CARRIAGE_RETURN = 6 , QUOTED = 7 , UNQUOTED = 8 , ESCAPE = 9 , INVALID = 10 , NOT_SET = 11 , QUOTED_NEW_LINE = 12 , EMPTY_SPACE = 13 , COMMENT = 14 , STANDARD_NEWLINE = 15 , UNQUOTED_ESCAPE = 16 , ESCAPED_RETURN = 17 , MAYBE_QUOTED = 18 }
	All States of CSV parsing. More...

enum class	PhysicalTableScanExecutionStrategy : uint8_t { DEFAULT , TASK_EXECUTOR , SYNCHRONOUS , TASK_EXECUTOR_BUT_FORCE_SYNC_CHECKS }

enum class	CompressedMaterializationDirection : uint8_t { INVALID = 0 , COMPRESS = 1 , DECOMPRESS = 2 }
	Needed for (de)serialization without binding. More...

enum class	WindowMergeSortStage : uint8_t { INIT , COMBINE , FINALIZE , SORTED , FINISHED }

enum class	ErrorType : uint16_t { UNSIGNED_EXTENSION = 0 , INVALIDATED_TRANSACTION = 1 , INVALIDATED_DATABASE = 2 , ERROR_COUNT , INVALID = 65535 }

enum class	PushdownExtractSupport : uint8_t { UNCHECKED , DISABLED , ENABLED }

enum class	BaseColumnPrunerMode : uint8_t { DEFAULT , DISABLE_PUSHDOWN_EXTRACT }

enum class	MetaPipelineType : uint8_t { REGULAR = 0 , JOIN_BUILD = 1 }

enum class	PreparedParamType : uint8_t { AUTO_INCREMENT , POSITIONAL , NAMED , INVALID }

enum class	WindowBoundary : uint8_t { INVALID = 0 , UNBOUNDED_PRECEDING = 1 , UNBOUNDED_FOLLOWING = 2 , CURRENT_ROW_RANGE = 3 , CURRENT_ROW_ROWS = 4 , EXPR_PRECEDING_ROWS = 5 , EXPR_FOLLOWING_ROWS = 6 , EXPR_PRECEDING_RANGE = 7 , EXPR_FOLLOWING_RANGE = 8 , CURRENT_ROW_GROUPS = 9 , EXPR_PRECEDING_GROUPS = 10 , EXPR_FOLLOWING_GROUPS = 11 }

enum class	WindowExcludeMode : uint8_t { NO_OTHER = 0 , CURRENT_ROW = 1 , GROUP = 2 , TIES = 3 }
	Represents the window exclusion mode. More...

enum class	AlterDatabaseType : uint8_t { RENAME_DATABASE = 0 }

enum class	LoadType : uint8_t { LOAD , INSTALL , FORCE_INSTALL }

enum class	OnConflictAction : uint8_t { THROW , NOTHING , UPDATE , REPLACE }

enum class	InsertColumnOrder : uint8_t { INSERT_BY_POSITION = 0 , INSERT_BY_NAME = 1 }

enum class	ShowType : uint8_t { SUMMARY , DESCRIBE , SHOW_FROM , SHOW_UNQUALIFIED }

enum class	DataFileType : uint8_t { FILE_DOES_NOT_EXIST , DUCKDB_FILE , SQLITE_FILE , PARQUET_FILE , UNKNOWN_FILE }

enum class	TemporaryBufferSize : uint64_t { INVALID = 0 , S32K = 32768 , S64K = 65536 , S96K = 98304 , S128K = 131072 , S160K = 163840 , S192K = 196608 , S224K = 229376 , DEFAULT = DEFAULT_BLOCK_ALLOC_SIZE }

enum class	TemporaryCompressionLevel : int { ZSTD_MINUS_FIVE = -5 , ZSTD_MINUS_THREE = -3 , ZSTD_MINUS_ONE = -1 , UNCOMPRESSED = 0 , ZSTD_ONE = 1 , ZSTD_THREE = 3 , ZSTD_FIVE = 5 }

enum class	VerificationType : uint8_t { ORIGINAL , COPIED , DESERIALIZED , PARSED , UNOPTIMIZED , NO_OPERATOR_CACHING , PREPARED , EXTERNAL , EXPLAIN , FETCH_ROW_AS_SCAN , INVALID }

enum class	FetchType { TRANSACTIONAL_FETCH , FORCE_FETCH }

enum class	MiniZStreamType { MINIZ_TYPE_NONE , MINIZ_TYPE_INFLATE , MINIZ_TYPE_DEFLATE }

enum class	ReaderInitializeType { INITIALIZED , SKIP_READING_FILE }

enum class	ExceptionFormatValueType : uint8_t { FORMAT_VALUE_TYPE_DOUBLE , FORMAT_VALUE_TYPE_INTEGER , FORMAT_VALUE_TYPE_STRING }

enum class	ExceptionType : uint8_t { INVALID = 0 , OUT_OF_RANGE = 1 , CONVERSION = 2 , UNKNOWN_TYPE = 3 , DECIMAL = 4 , MISMATCH_TYPE = 5 , DIVIDE_BY_ZERO = 6 , OBJECT_SIZE = 7 , INVALID_TYPE = 8 , SERIALIZATION = 9 , TRANSACTION = 10 , NOT_IMPLEMENTED = 11 , EXPRESSION = 12 , CATALOG = 13 , PARSER = 14 , PLANNER = 15 , SCHEDULER = 16 , EXECUTOR = 17 , CONSTRAINT = 18 , INDEX = 19 , STAT = 20 , CONNECTION = 21 , SYNTAX = 22 , SETTINGS = 23 , BINDER = 24 , NETWORK = 25 , OPTIMIZER = 26 , NULL_POINTER = 27 , IO = 28 , INTERRUPT = 29 , FATAL = 30 , INTERNAL = 31 , INVALID_INPUT = 32 , OUT_OF_MEMORY = 33 , PERMISSION = 34 , PARAMETER_NOT_RESOLVED = 35 , PARAMETER_NOT_ALLOWED = 36 , DEPENDENCY = 37 , HTTP = 38 , MISSING_EXTENSION = 39 , AUTOLOAD = 40 , SEQUENCE = 41 , INVALID_CONFIGURATION }

enum class	ProfilerPrintFormat : uint8_t { QUERY_TREE , JSON , QUERY_TREE_OPTIMIZER , NO_OUTPUT , HTML , GRAPHVIZ , MERMAID }

enum class	CatalogType : uint8_t { INVALID = 0 , TABLE_ENTRY = 1 , SCHEMA_ENTRY = 2 , VIEW_ENTRY = 3 , INDEX_ENTRY = 4 , PREPARED_STATEMENT = 5 , SEQUENCE_ENTRY = 6 , COLLATION_ENTRY = 7 , TYPE_ENTRY = 8 , DATABASE_ENTRY = 9 , COORDINATE_SYSTEM_ENTRY = 10 , TABLE_FUNCTION_ENTRY = 25 , SCALAR_FUNCTION_ENTRY = 26 , AGGREGATE_FUNCTION_ENTRY = 27 , PRAGMA_FUNCTION_ENTRY = 28 , COPY_FUNCTION_ENTRY = 29 , MACRO_ENTRY = 30 , TABLE_MACRO_ENTRY = 31 , DELETED_ENTRY = 51 , RENAMED_ENTRY = 52 , SECRET_ENTRY = 71 , SECRET_TYPE_ENTRY = 72 , SECRET_FUNCTION_ENTRY = 73 , DEPENDENCY_ENTRY = 100 }

enum class	PhysicalType : uint8_t { BOOL = 1 , UINT8 = 2 , INT8 = 3 , UINT16 = 4 , INT16 = 5 , UINT32 = 6 , INT32 = 7 , UINT64 = 8 , INT64 = 9 , FLOAT = 11 , DOUBLE = 12 , INTERVAL = 21 , LIST = 23 , STRUCT = 24 , ARRAY = 29 , VARCHAR = 200 , UINT128 = 203 , INT128 = 204 , UNKNOWN = 205 , BIT = 206 , INVALID = 255 }

enum class	LogicalTypeId : uint8_t { INVALID = 0 , SQLNULL = 1 , UNKNOWN = 2 , ANY = 3 , UNBOUND = 4 , TEMPLATE = 5 , TYPE = 6 , BOOLEAN = 10 , TINYINT = 11 , SMALLINT = 12 , INTEGER = 13 , BIGINT = 14 , DATE = 15 , TIME = 16 , TIMESTAMP_SEC = 17 , TIMESTAMP_MS = 18 , TIMESTAMP = 19 , TIMESTAMP_NS = 20 , DECIMAL = 21 , FLOAT = 22 , DOUBLE = 23 , CHAR = 24 , VARCHAR = 25 , BLOB = 26 , INTERVAL = 27 , UTINYINT = 28 , USMALLINT = 29 , UINTEGER = 30 , UBIGINT = 31 , TIMESTAMP_TZ = 32 , TIME_TZ = 34 , TIME_NS = 35 , BIT = 36 , STRING_LITERAL = 37 , INTEGER_LITERAL = 38 , BIGNUM = 39 , UHUGEINT = 49 , HUGEINT = 50 , POINTER = 51 , VALIDITY = 53 , UUID = 54 , GEOMETRY = 60 , STRUCT = 100 , LIST = 101 , MAP = 102 , TABLE = 103 , ENUM = 104 , AGGREGATE_STATE = 105 , LAMBDA = 106 , UNION = 107 , ARRAY = 108 , VARIANT = 109 }

enum class	ComplexJSONType : uint8_t { VALUE = 0 , OBJECT = 1 , ARRAY = 2 }

enum class	TimestampCastResult : uint8_t { SUCCESS , ERROR_INCORRECT_FORMAT , ERROR_NON_UTC_TIMEZONE , ERROR_RANGE , STRICT_UTC }

enum class	DateCastResult : uint8_t { SUCCESS , ERROR_INCORRECT_FORMAT , ERROR_RANGE }

enum class	CatalogLookupBehavior : uint8_t { STANDARD = 0 , LOWER_PRIORITY = 1 , NEVER_LOOKUP = 2 }
	Enum used for indicating lookup behavior of specific catalog types. More...

enum class	OnEntryNotFound : uint8_t { THROW_EXCEPTION = 0 , RETURN_NULL = 1 }

enum class	FileCompressionType : uint8_t { AUTO_DETECT = 0 , UNCOMPRESSED = 1 , GZIP = 2 , ZSTD = 3 }

enum class	FileGlobOptions : uint8_t { DISALLOW_EMPTY = 0 , ALLOW_EMPTY = 1 , FALLBACK_GLOB = 2 }

enum class	DebugInitialize : uint8_t { NO_INITIALIZE = 0 , DEBUG_ZERO_INITIALIZE = 1 , DEBUG_ONE_INITIALIZE = 2 }

enum class	FileBufferType : uint8_t { BLOCK = 1 , MANAGED_BUFFER = 2 , TINY_BUFFER = 3 , EXTERNAL_FILE = 4 }

enum class	CachingMode : uint8_t { ALWAYS_CACHE = 0 , CACHE_REMOTE_ONLY = 1 , NO_CACHING = 2 }

enum class	FileLockType : uint8_t { NO_LOCK = 0 , READ_LOCK = 1 , WRITE_LOCK = 2 }

enum class	FileType { FILE_TYPE_REGULAR , FILE_TYPE_DIR , FILE_TYPE_FIFO , FILE_TYPE_SOCKET , FILE_TYPE_LINK , FILE_TYPE_BLOCKDEV , FILE_TYPE_CHARDEV , FILE_TYPE_INVALID }

enum class	VectorType : uint8_t { FLAT_VECTOR , FSST_VECTOR , CONSTANT_VECTOR , DICTIONARY_VECTOR , SEQUENCE_VECTOR }

enum class	AllocatorFreeType { REQUIRES_FREE , DOES_NOT_REQUIRE_FREE }

enum class	VectorBufferType : uint8_t { STANDARD_BUFFER , DICTIONARY_BUFFER , VECTOR_CHILD_BUFFER , STRING_BUFFER , FSST_BUFFER , STRUCT_BUFFER , LIST_BUFFER , MANAGED_BUFFER , OPAQUE_BUFFER , ARRAY_BUFFER }

enum class	VectorAuxiliaryDataType : uint8_t { ARROW_AUXILIARY }

enum class	MapInvalidReason : uint8_t { VALID , NULL_KEY , DUPLICATE_KEY , NOT_ALIGNED , INVALID_PARAMS }

enum class	UnionInvalidReason : uint8_t { VALID , TAG_OUT_OF_RANGE , NO_MEMBERS , VALIDITY_OVERLAP , TAG_MISMATCH , NULL_TAG }

enum class	FunctionErrors : uint8_t { CANNOT_ERROR = 0 , CAN_THROW_RUNTIME_ERROR = 1 }
	Whether or not a function can throw an error or not. More...

enum class	ExpressionType : uint8_t { INVALID = 0 , OPERATOR_CAST = 12 , OPERATOR_NOT = 13 , OPERATOR_IS_NULL = 14 , OPERATOR_IS_NOT_NULL = 15 , OPERATOR_UNPACK = 16 , COMPARE_EQUAL = 25 , COMPARE_BOUNDARY_START = COMPARE_EQUAL , COMPARE_NOTEQUAL = 26 , COMPARE_LESSTHAN = 27 , COMPARE_GREATERTHAN = 28 , COMPARE_LESSTHANOREQUALTO = 29 , COMPARE_GREATERTHANOREQUALTO = 30 , COMPARE_IN = 35 , COMPARE_NOT_IN = 36 , COMPARE_DISTINCT_FROM = 37 , COMPARE_BETWEEN = 38 , COMPARE_NOT_BETWEEN = 39 , COMPARE_NOT_DISTINCT_FROM = 40 , COMPARE_BOUNDARY_END = COMPARE_NOT_DISTINCT_FROM , CONJUNCTION_AND = 50 , CONJUNCTION_OR = 51 , VALUE_CONSTANT = 75 , VALUE_PARAMETER = 76 , VALUE_TUPLE = 77 , VALUE_TUPLE_ADDRESS = 78 , VALUE_NULL = 79 , VALUE_VECTOR = 80 , VALUE_SCALAR = 81 , VALUE_DEFAULT = 82 , AGGREGATE = 100 , BOUND_AGGREGATE = 101 , GROUPING_FUNCTION = 102 , WINDOW_AGGREGATE = 110 , WINDOW_RANK = 120 , WINDOW_RANK_DENSE = 121 , WINDOW_NTILE = 122 , WINDOW_PERCENT_RANK = 123 , WINDOW_CUME_DIST = 124 , WINDOW_ROW_NUMBER = 125 , WINDOW_FIRST_VALUE = 130 , WINDOW_LAST_VALUE = 131 , WINDOW_LEAD = 132 , WINDOW_LAG = 133 , WINDOW_NTH_VALUE = 134 , WINDOW_FILL = 135 , FUNCTION = 140 , BOUND_FUNCTION = 141 , CASE_EXPR = 150 , OPERATOR_NULLIF = 151 , OPERATOR_COALESCE = 152 , ARRAY_EXTRACT = 153 , ARRAY_SLICE = 154 , STRUCT_EXTRACT = 155 , ARRAY_CONSTRUCTOR = 156 , ARROW = 157 , OPERATOR_TRY = 158 , SUBQUERY = 175 , STAR = 200 , TABLE_STAR = 201 , PLACEHOLDER = 202 , COLUMN_REF = 203 , FUNCTION_REF = 204 , TABLE_REF = 205 , LAMBDA_REF = 206 , TYPE = 207 , CAST = 225 , BOUND_REF = 227 , BOUND_COLUMN_REF = 228 , BOUND_UNNEST = 229 , COLLATE = 230 , LAMBDA = 231 , POSITIONAL_REFERENCE = 232 , BOUND_LAMBDA_REF = 233 , BOUND_EXPANDED = 234 }

enum class	ExpressionClass : uint8_t { INVALID = 0 , AGGREGATE = 1 , CASE = 2 , CAST = 3 , COLUMN_REF = 4 , COMPARISON = 5 , CONJUNCTION = 6 , CONSTANT = 7 , DEFAULT = 8 , FUNCTION = 9 , OPERATOR = 10 , STAR = 11 , SUBQUERY = 13 , WINDOW = 14 , PARAMETER = 15 , COLLATE = 16 , LAMBDA = 17 , POSITIONAL_REFERENCE = 18 , BETWEEN = 19 , LAMBDA_REF = 20 , TYPE = 21 , BOUND_AGGREGATE = 25 , BOUND_CASE = 26 , BOUND_CAST = 27 , BOUND_COLUMN_REF = 28 , BOUND_COMPARISON = 29 , BOUND_CONJUNCTION = 30 , BOUND_CONSTANT = 31 , BOUND_DEFAULT = 32 , BOUND_FUNCTION = 33 , BOUND_OPERATOR = 34 , BOUND_PARAMETER = 35 , BOUND_REF = 36 , BOUND_SUBQUERY = 37 , BOUND_WINDOW = 38 , BOUND_BETWEEN = 39 , BOUND_UNNEST = 40 , BOUND_LAMBDA = 41 , BOUND_LAMBDA_REF = 42 , BOUND_EXPRESSION = 50 , BOUND_EXPANDED = 51 }

enum class	SimplifiedTokenType : uint8_t { SIMPLIFIED_TOKEN_IDENTIFIER , SIMPLIFIED_TOKEN_NUMERIC_CONSTANT , SIMPLIFIED_TOKEN_STRING_CONSTANT , SIMPLIFIED_TOKEN_OPERATOR , SIMPLIFIED_TOKEN_KEYWORD , SIMPLIFIED_TOKEN_COMMENT , SIMPLIFIED_TOKEN_ERROR , SIMPLIFIED_TOKEN_ERROR_EMPHASIS , SIMPLIFIED_TOKEN_ERROR_SUGGESTION }

enum class	KeywordCategory : uint8_t { KEYWORD_RESERVED , KEYWORD_UNRESERVED , KEYWORD_TYPE_FUNC , KEYWORD_COL_NAME , KEYWORD_NONE }

enum class	CompressionType : uint8_t { COMPRESSION_AUTO = 0 , COMPRESSION_UNCOMPRESSED = 1 , COMPRESSION_CONSTANT = 2 , COMPRESSION_RLE = 3 , COMPRESSION_DICTIONARY = 4 , COMPRESSION_PFOR_DELTA = 5 , COMPRESSION_BITPACKING = 6 , COMPRESSION_FSST = 7 , COMPRESSION_CHIMP = 8 , COMPRESSION_PATAS = 9 , COMPRESSION_ALP = 10 , COMPRESSION_ALPRD = 11 , COMPRESSION_ZSTD = 12 , COMPRESSION_ROARING = 13 , COMPRESSION_EMPTY = 14 , COMPRESSION_DICT_FSST = 15 , COMPRESSION_COUNT }

enum class	TableColumnType : uint8_t { STANDARD = 0 , GENERATED = 1 }

enum class	FunctionNullHandling : uint8_t { DEFAULT_NULL_HANDLING = 0 , SPECIAL_HANDLING = 1 }
	The default null handling is NULL in, NULL out. More...

enum class	FunctionStability : uint8_t { CONSISTENT = 0 , VOLATILE = 1 , CONSISTENT_WITHIN_QUERY = 2 }

enum class	FunctionCollationHandling : uint8_t { PROPAGATE_COLLATIONS = 0 , PUSH_COMBINABLE_COLLATIONS = 1 , IGNORE_COLLATIONS = 2 }

enum class	ColumnIndexType : uint8_t { INVALID , FULL_READ , PUSHDOWN_EXTRACT }

enum class	StorageIndexType : uint8_t { FULL_READ , PUSHDOWN_EXTRACT }

enum class	FilterPropagateResult : uint8_t { NO_PRUNING_POSSIBLE = 0 , FILTER_ALWAYS_TRUE = 1 , FILTER_ALWAYS_FALSE = 2 , FILTER_TRUE_OR_NULL = 3 , FILTER_FALSE_OR_NULL = 4 }

enum class	GeometryType : uint8_t { INVALID = 0 , POINT = 1 , LINESTRING = 2 , POLYGON = 3 , MULTIPOINT = 4 , MULTILINESTRING = 5 , MULTIPOLYGON = 6 , GEOMETRYCOLLECTION = 7 }

enum class	VertexType : uint8_t { XY = 0 , XYZ = 1 , XYM = 2 , XYZM = 3 }

enum class	GeometryStorageType : uint8_t { SPATIAL = 0 , WKB = 1 , POINT_XY = 17 , LINESTRING_XY = 18 , POLYGON_XY = 19 , MULTIPOINT_XY = 20 , MULTILINESTRING_XY = 21 , MULTIPOLYGON_XY = 22 , POINT_XYZ = 33 , LINESTRING_XYZ = 34 , POLYGON_XYZ = 35 , MULTIPOINT_XYZ = 36 , MULTILINESTRING_XYZ = 37 , MULTIPOLYGON_XYZ = 38 , POINT_XYM = 65 , LINESTRING_XYM = 66 , POLYGON_XYM = 67 , MULTIPOINT_XYM = 68 , MULTILINESTRING_XYM = 69 , MULTIPOLYGON_XYM = 70 , POINT_XYZM = 97 , LINESTRING_XYZM = 98 , POLYGON_XYZM = 99 , MULTIPOINT_XYZM = 100 , MULTILINESTRING_XYZM = 101 , MULTIPOLYGON_XYZM = 102 }

enum class	VariantChildLookupMode : uint8_t { INVALID , BY_KEY , BY_INDEX }

enum class	VariantLogicalType : uint8_t { VARIANT_NULL = 0 , BOOL_TRUE = 1 , BOOL_FALSE = 2 , INT8 = 3 , INT16 = 4 , INT32 = 5 , INT64 = 6 , INT128 = 7 , UINT8 = 8 , UINT16 = 9 , UINT32 = 10 , UINT64 = 11 , UINT128 = 12 , FLOAT = 13 , DOUBLE = 14 , DECIMAL = 15 , VARCHAR = 16 , BLOB = 17 , UUID = 18 , DATE = 19 , TIME_MICROS = 20 , TIME_NANOS = 21 , TIMESTAMP_SEC = 22 , TIMESTAMP_MILIS = 23 , TIMESTAMP_MICROS = 24 , TIMESTAMP_NANOS = 25 , TIME_MICROS_TZ = 26 , TIMESTAMP_MICROS_TZ = 27 , INTERVAL = 28 , OBJECT = 29 , ARRAY = 30 , BIGNUM = 31 , BITSTRING = 32 , GEOMETRY = 33 , ENUM_SIZE }

enum class	VariantStatsShreddingState : uint8_t { UNINITIALIZED , NOT_SHREDDED , SHREDDED , INCONSISTENT }

enum class	StatsInfo : uint8_t { CAN_HAVE_NULL_VALUES = 0 , CANNOT_HAVE_NULL_VALUES = 1 , CAN_HAVE_VALID_VALUES = 2 , CANNOT_HAVE_VALID_VALUES = 3 , CAN_HAVE_NULL_AND_VALID_VALUES = 4 }

enum class	StatisticsType : uint8_t { NUMERIC_STATS , STRING_STATS , LIST_STATS , STRUCT_STATS , BASE_STATS , ARRAY_STATS , GEOMETRY_STATS , VARIANT_STATS }

enum class	AggregateType : uint8_t { NON_DISTINCT = 1 , DISTINCT = 2 }

enum class	AggregateOrderDependent : uint8_t { ORDER_DEPENDENT = 1 , NOT_ORDER_DEPENDENT = 2 }
	Whether or not the input order influences the result of the aggregate. More...

enum class	AggregateDistinctDependent : uint8_t { DISTINCT_DEPENDENT = 1 , NOT_DISTINCT_DEPENDENT = 2 }
	Whether or not the input distinctness influences the result of the aggregate. More...

enum class	AggregateCombineType : uint8_t { PRESERVE_INPUT = 1 , ALLOW_DESTRUCTIVE = 2 }
	Whether or not the combiner needs to preserve the source. More...

enum class	OrderType : uint8_t { INVALID = 0 , ORDER_DEFAULT = 1 , ASCENDING = 2 , DESCENDING = 3 }

enum class	OrderByNullType : uint8_t { INVALID = 0 , ORDER_DEFAULT = 1 , NULLS_FIRST = 2 , NULLS_LAST = 3 }

enum class	DefaultOrderByNullType : uint8_t { INVALID = 0 , NULLS_FIRST = 2 , NULLS_LAST = 3 , NULLS_FIRST_ON_ASC_LAST_ON_DESC = 4 , NULLS_LAST_ON_ASC_FIRST_ON_DESC = 5 }

enum class	ResultModifierType : uint8_t { LIMIT_MODIFIER = 1 , ORDER_MODIFIER = 2 , DISTINCT_MODIFIER = 3 , LIMIT_PERCENT_MODIFIER = 4 }

enum class	SetOperationType : uint8_t { NONE = 0 , UNION = 1 , EXCEPT = 2 , INTERSECT = 3 , UNION_BY_NAME = 4 }

enum class	LimitNodeType : uint8_t { UNSET = 0 , CONSTANT_VALUE = 1 , CONSTANT_PERCENTAGE = 2 , EXPRESSION_VALUE = 3 , EXPRESSION_PERCENTAGE = 4 }

enum class	DistinctType : uint8_t { DISTINCT = 0 , DISTINCT_ON = 1 }

enum class	AggregateDestructorType { STANDARD , LEGACY }

enum class	ColumnDataAllocatorType : uint8_t { BUFFER_MANAGER_ALLOCATOR , IN_MEMORY_ALLOCATOR , HYBRID }

enum class	ColumnDataScanProperties : uint8_t { INVALID , ALLOW_ZERO_COPY , DISALLOW_ZERO_COPY }

enum class	ColumnDataCollectionLifetime { REGULAR , THROW_ERROR_AFTER_DATABASE_CLOSES }

enum class	QueryResultOutputType : uint8_t { FORCE_MATERIALIZED , ALLOW_STREAMING }

enum class	QueryResultMemoryType : uint8_t { IN_MEMORY , BUFFER_MANAGED }

enum class	StatementType : uint8_t { INVALID_STATEMENT , SELECT_STATEMENT , INSERT_STATEMENT , UPDATE_STATEMENT , CREATE_STATEMENT , DELETE_STATEMENT , PREPARE_STATEMENT , EXECUTE_STATEMENT , ALTER_STATEMENT , TRANSACTION_STATEMENT , COPY_STATEMENT , ANALYZE_STATEMENT , VARIABLE_SET_STATEMENT , CREATE_FUNC_STATEMENT , EXPLAIN_STATEMENT , DROP_STATEMENT , EXPORT_STATEMENT , PRAGMA_STATEMENT , VACUUM_STATEMENT , CALL_STATEMENT , SET_STATEMENT , LOAD_STATEMENT , RELATION_STATEMENT , EXTENSION_STATEMENT , LOGICAL_PLAN_STATEMENT , ATTACH_STATEMENT , DETACH_STATEMENT , MULTI_STATEMENT , COPY_DATABASE_STATEMENT , UPDATE_EXTENSIONS_STATEMENT , MERGE_INTO_STATEMENT }

enum class	StatementReturnType : uint8_t { QUERY_RESULT , CHANGED_ROWS , NOTHING }

enum class	ArrowOffsetSize : uint8_t { REGULAR , LARGE }

enum class	ArrowFormatVersion : uint8_t { V1_0 = 10 , V1_1 = 11 , V1_2 = 12 , V1_3 = 13 , V1_4 = 14 , V1_5 = 15 }

enum class	QueryResultType : uint8_t { MATERIALIZED_RESULT , STREAM_RESULT , PENDING_RESULT , ARROW_RESULT }

enum class	PendingExecutionResult : uint8_t { RESULT_READY , RESULT_NOT_READY , EXECUTION_ERROR , BLOCKED , NO_TASKS_AVAILABLE , EXECUTION_FINISHED }

enum class	ExplainFormat : uint8_t { DEFAULT , TEXT , JSON , HTML , GRAPHVIZ , YAML , MERMAID }

enum class	OperatorResultType : uint8_t { NEED_MORE_INPUT , HAVE_MORE_OUTPUT , FINISHED , BLOCKED }

enum class	OperatorFinalizeResultType : uint8_t { HAVE_MORE_OUTPUT , FINISHED }

enum class	OperatorFinalResultType : uint8_t { FINISHED , BLOCKED }
	OperatorFinalResultType is used for the final call. More...

enum class	SourceResultType : uint8_t { HAVE_MORE_OUTPUT , FINISHED , BLOCKED }

enum class	AsyncResultType : uint8_t { INVALID , IMPLICIT , HAVE_MORE_OUTPUT , FINISHED , BLOCKED }
	AsyncResultType is used to indicate the result of a AsyncResult, in the context of a wider operation being executed. More...

enum class	SinkResultType : uint8_t { NEED_MORE_INPUT , FINISHED , BLOCKED }

enum class	SinkCombineResultType : uint8_t { FINISHED , BLOCKED }

enum class	SinkFinalizeType : uint8_t { READY , NO_OUTPUT_POSSIBLE , BLOCKED }

enum class	SinkNextBatchType : uint8_t { READY , BLOCKED }

enum class	OrderPreservationType : uint8_t { NO_ORDER , INSERTION_ORDER , FIXED_ORDER }

enum class	PhysicalOperatorType : uint8_t { INVALID , ORDER_BY , LIMIT , STREAMING_LIMIT , LIMIT_PERCENT , TOP_N , WINDOW , UNNEST , UNGROUPED_AGGREGATE , HASH_GROUP_BY , PERFECT_HASH_GROUP_BY , PARTITIONED_AGGREGATE , FILTER , PROJECTION , COPY_TO_FILE , BATCH_COPY_TO_FILE , RESERVOIR_SAMPLE , STREAMING_SAMPLE , STREAMING_WINDOW , PIVOT , COPY_DATABASE , TABLE_SCAN , DUMMY_SCAN , COLUMN_DATA_SCAN , CHUNK_SCAN , RECURSIVE_CTE_SCAN , RECURSIVE_RECURRING_CTE_SCAN , CTE_SCAN , DELIM_SCAN , EXPRESSION_SCAN , POSITIONAL_SCAN , BLOCKWISE_NL_JOIN , NESTED_LOOP_JOIN , HASH_JOIN , CROSS_PRODUCT , PIECEWISE_MERGE_JOIN , IE_JOIN , LEFT_DELIM_JOIN , RIGHT_DELIM_JOIN , POSITIONAL_JOIN , ASOF_JOIN , UNION , RECURSIVE_CTE , RECURSIVE_KEY_CTE , CTE , INSERT , BATCH_INSERT , DELETE_OPERATOR , UPDATE , MERGE_INTO , CREATE_TABLE , CREATE_TABLE_AS , BATCH_CREATE_TABLE_AS , CREATE_INDEX , ALTER , CREATE_SEQUENCE , CREATE_VIEW , CREATE_SCHEMA , CREATE_MACRO , DROP , PRAGMA , TRANSACTION , CREATE_TYPE , ATTACH , DETACH , EXPLAIN , EXPLAIN_ANALYZE , EMPTY_RESULT , EXECUTE , PREPARE , VACUUM , EXPORT , SET , SET_VARIABLE , LOAD , INOUT_FUNCTION , RESULT_COLLECTOR , RESET , EXTENSION , VERIFY_VECTOR , UPDATE_EXTENSIONS , CREATE_SECRET }

enum class	PartitionInfo { NONE , REQUIRES_BATCH_INDEX }

enum class	TableFilterType : uint8_t { CONSTANT_COMPARISON = 0 , IS_NULL = 1 , IS_NOT_NULL = 2 , CONJUNCTION_OR = 3 , CONJUNCTION_AND = 4 , STRUCT_EXTRACT = 5 , OPTIONAL_FILTER = 6 , IN_FILTER = 7 , DYNAMIC_FILTER = 8 , EXPRESSION_FILTER = 9 , BLOOM_FILTER = 10 }

enum class	LogicalOperatorType : uint8_t { LOGICAL_INVALID = 0 , LOGICAL_PROJECTION = 1 , LOGICAL_FILTER = 2 , LOGICAL_AGGREGATE_AND_GROUP_BY = 3 , LOGICAL_WINDOW = 4 , LOGICAL_UNNEST = 5 , LOGICAL_LIMIT = 6 , LOGICAL_ORDER_BY = 7 , LOGICAL_TOP_N = 8 , LOGICAL_COPY_TO_FILE = 10 , LOGICAL_DISTINCT = 11 , LOGICAL_SAMPLE = 12 , LOGICAL_PIVOT = 14 , LOGICAL_COPY_DATABASE = 15 , LOGICAL_GET = 25 , LOGICAL_CHUNK_GET = 26 , LOGICAL_DELIM_GET = 27 , LOGICAL_EXPRESSION_GET = 28 , LOGICAL_DUMMY_SCAN = 29 , LOGICAL_EMPTY_RESULT = 30 , LOGICAL_CTE_REF = 31 , LOGICAL_JOIN = 50 , LOGICAL_DELIM_JOIN = 51 , LOGICAL_COMPARISON_JOIN = 52 , LOGICAL_ANY_JOIN = 53 , LOGICAL_CROSS_PRODUCT = 54 , LOGICAL_POSITIONAL_JOIN = 55 , LOGICAL_ASOF_JOIN = 56 , LOGICAL_DEPENDENT_JOIN = 57 , LOGICAL_UNION = 75 , LOGICAL_EXCEPT = 76 , LOGICAL_INTERSECT = 77 , LOGICAL_RECURSIVE_CTE = 78 , LOGICAL_MATERIALIZED_CTE = 79 , LOGICAL_INSERT = 100 , LOGICAL_DELETE = 101 , LOGICAL_UPDATE = 102 , LOGICAL_MERGE_INTO = 103 , LOGICAL_ALTER = 125 , LOGICAL_CREATE_TABLE = 126 , LOGICAL_CREATE_INDEX = 127 , LOGICAL_CREATE_SEQUENCE = 128 , LOGICAL_CREATE_VIEW = 129 , LOGICAL_CREATE_SCHEMA = 130 , LOGICAL_CREATE_MACRO = 131 , LOGICAL_DROP = 132 , LOGICAL_PRAGMA = 133 , LOGICAL_TRANSACTION = 134 , LOGICAL_CREATE_TYPE = 135 , LOGICAL_ATTACH = 136 , LOGICAL_DETACH = 137 , LOGICAL_EXPLAIN = 150 , LOGICAL_PREPARE = 175 , LOGICAL_EXECUTE = 176 , LOGICAL_EXPORT = 177 , LOGICAL_VACUUM = 178 , LOGICAL_SET = 179 , LOGICAL_LOAD = 180 , LOGICAL_RESET = 181 , LOGICAL_UPDATE_EXTENSIONS = 182 , LOGICAL_CREATE_SECRET = 190 , LOGICAL_EXTENSION_OPERATOR = 255 }

enum class	TaskExecutionMode : uint8_t { PROCESS_ALL , PROCESS_PARTIAL }

enum class	TaskExecutionResult : uint8_t { TASK_FINISHED , TASK_NOT_FINISHED , TASK_ERROR , TASK_BLOCKED }

enum class	InterruptMode : uint8_t { NO_INTERRUPTS , TASK , BLOCKING }

enum class	OperatorCachingMode : uint8_t { NONE , PARTITIONED , ORDERED , UNORDERED }

enum class	TablePartitionInfo : uint8_t { NOT_PARTITIONED , SINGLE_VALUE_PARTITIONS , OVERLAPPING_PARTITIONS , DISJOINT_PARTITIONS }
	How a table is partitioned by a given set of columns. More...

enum class	CountType { COUNT_EXACT , COUNT_APPROXIMATE }

enum class	InsertedScanType { STANDARD , ALL_ROWS }

enum class	DeletedScanType { STANDARD , INCLUDE_ALL_DELETED , OMIT_COMMITTED_DELETES }

enum class	UpdateScanType { STANDARD , DISALLOW_UPDATES }

enum class	TableScanType { TABLE_SCAN_ALL_ROWS = 1 , TABLE_SCAN_OMIT_PERMANENTLY_DELETED = 2 , TABLE_SCAN_COMMITTED_ROWS = 3 }

enum class	ChunkInfoType : uint8_t { CONSTANT_INFO , VECTOR_INFO , EMPTY_INFO }

enum class	CheckpointWALAction { DELETE_WAL , DONT_DELETE_WAL }

enum class	CheckpointAction { CHECKPOINT_IF_REQUIRED , ALWAYS_CHECKPOINT }

enum class	CheckpointType { FULL_CHECKPOINT , CONCURRENT_CHECKPOINT , VACUUM_ONLY }

enum class	StorageLockType { SHARED = 0 , EXCLUSIVE = 1 }

enum class	OrderByStatistics : uint8_t { MIN , MAX }

enum class	OrderByColumnType : uint8_t { NUMERIC , STRING }

enum class	AsyncResultsExecutionMode : uint8_t { SYNCHRONOUS , TASK_EXECUTOR }

enum class	ScanType : uint8_t { TABLE , PARQUET , EXTERNAL }

enum class	TableFunctionInitialization { INITIALIZE_ON_EXECUTE , INITIALIZE_ON_SCHEDULE }
	When to call init_global to initialize the table function. More...

enum class	JoinType : uint8_t { INVALID = 0 , LEFT = 1 , RIGHT = 2 , INNER = 3 , OUTER = 4 , SEMI = 5 , ANTI = 6 , MARK = 7 , SINGLE = 8 , RIGHT_SEMI = 9 , RIGHT_ANTI = 10 }

enum class	RelationType : uint8_t { INVALID_RELATION , TABLE_RELATION , PROJECTION_RELATION , FILTER_RELATION , EXPLAIN_RELATION , CROSS_PRODUCT_RELATION , JOIN_RELATION , AGGREGATE_RELATION , SET_OPERATION_RELATION , DISTINCT_RELATION , LIMIT_RELATION , ORDER_RELATION , CREATE_VIEW_RELATION , CREATE_TABLE_RELATION , INSERT_RELATION , VALUE_LIST_RELATION , MATERIALIZED_RELATION , DELETE_RELATION , UPDATE_RELATION , WRITE_CSV_RELATION , WRITE_PARQUET_RELATION , READ_CSV_RELATION , SUBQUERY_RELATION , TABLE_FUNCTION_RELATION , VIEW_RELATION , QUERY_RELATION , DELIM_JOIN_RELATION , DELIM_GET_RELATION , EXTENSION_RELATION = 255 }

enum class	JoinRefType : uint8_t { REGULAR , NATURAL , CROSS , POSITIONAL , ASOF , DEPENDENT }

enum class	ParseInfoType : uint8_t { ALTER_INFO , ATTACH_INFO , COPY_INFO , CREATE_INFO , CREATE_SECRET_INFO , DETACH_INFO , DROP_INFO , BOUND_EXPORT_DATA , LOAD_INFO , PRAGMA_INFO , SHOW_SELECT_INFO , TRANSACTION_INFO , VACUUM_INFO , COMMENT_ON_INFO , COMMENT_ON_COLUMN_INFO , COPY_DATABASE_INFO , UPDATE_EXTENSIONS_INFO }

enum class	OnCreateConflict : uint8_t { ERROR_ON_CONFLICT , IGNORE_ON_CONFLICT , REPLACE_ON_CONFLICT , ALTER_ON_CONFLICT }

enum class	SequenceInfo : uint8_t { SEQ_START , SEQ_INC , SEQ_MIN , SEQ_MAX , SEQ_CYCLE , SEQ_OWN }

enum class	AlterType : uint8_t { INVALID = 0 , ALTER_TABLE = 1 , ALTER_VIEW = 2 , ALTER_SEQUENCE = 3 , CHANGE_OWNERSHIP = 4 , ALTER_SCALAR_FUNCTION = 5 , ALTER_TABLE_FUNCTION = 6 , SET_COMMENT = 7 , SET_COLUMN_COMMENT = 8 , ALTER_DATABASE = 9 }

enum class	ConstraintType : uint8_t { INVALID = 0 , NOT_NULL = 1 , CHECK = 2 , UNIQUE = 3 , FOREIGN_KEY = 4 }

enum class	ForeignKeyType : uint8_t { FK_TYPE_PRIMARY_KEY_TABLE = 0 , FK_TYPE_FOREIGN_KEY_TABLE = 1 , FK_TYPE_SELF_REFERENCE_TABLE = 2 }

enum class	AlterForeignKeyType : uint8_t { AFT_ADD = 0 , AFT_DELETE = 1 }

enum class	AlterTableType : uint8_t { INVALID = 0 , RENAME_COLUMN = 1 , RENAME_TABLE = 2 , ADD_COLUMN = 3 , REMOVE_COLUMN = 4 , ALTER_COLUMN_TYPE = 5 , SET_DEFAULT = 6 , FOREIGN_KEY_CONSTRAINT = 7 , SET_NOT_NULL = 8 , DROP_NOT_NULL = 9 , SET_COLUMN_COMMENT = 10 , ADD_CONSTRAINT = 11 , SET_PARTITIONED_BY = 12 , SET_SORTED_BY = 13 , ADD_FIELD = 14 , REMOVE_FIELD = 15 , RENAME_FIELD = 16 , SET_TABLE_OPTIONS = 17 , RESET_TABLE_OPTIONS = 18 }

enum class	AlterViewType : uint8_t { INVALID = 0 , RENAME_VIEW = 1 }

enum class	PreparedStatementMode : uint8_t { PREPARE_ONLY , PREPARE_AND_EXECUTE }

enum class	ExplainOutputType : uint8_t { ALL = 0 , OPTIMIZED_ONLY = 1 , PHYSICAL_ONLY = 2 }

enum class	OptimizerType : uint32_t { INVALID = 0 , EXPRESSION_REWRITER = 1 , FILTER_PULLUP = 2 , FILTER_PUSHDOWN = 3 , EMPTY_RESULT_PULLUP = 4 , CTE_FILTER_PUSHER = 5 , REGEX_RANGE = 6 , IN_CLAUSE = 7 , JOIN_ORDER = 8 , DELIMINATOR = 9 , UNNEST_REWRITER = 10 , UNUSED_COLUMNS = 11 , STATISTICS_PROPAGATION = 12 , COMMON_SUBEXPRESSIONS = 13 , COMMON_AGGREGATE = 14 , COLUMN_LIFETIME = 15 , BUILD_SIDE_PROBE_SIDE = 16 , LIMIT_PUSHDOWN = 17 , TOP_N = 18 , COMPRESSED_MATERIALIZATION = 19 , DUPLICATE_GROUPS = 20 , REORDER_FILTER = 21 , SAMPLING_PUSHDOWN = 22 , JOIN_FILTER_PUSHDOWN = 23 , EXTENSION = 24 , MATERIALIZED_CTE = 25 , SUM_REWRITER = 26 , LATE_MATERIALIZATION = 27 , CTE_INLINING = 28 , ROW_GROUP_PRUNER = 29 , TOP_N_WINDOW_ELIMINATION = 30 , COMMON_SUBPLAN = 31 , JOIN_ELIMINATION = 32 , WINDOW_SELF_JOIN = 33 }

enum class	MetricGroup : uint8_t { ALL , CORE , DEFAULT , EXECUTION , FILE , OPERATOR , OPTIMIZER , PHASE_TIMING , INVALID }

enum class	MetricType : uint8_t { CPU_TIME = 2 , CUMULATIVE_CARDINALITY = 4 , CUMULATIVE_ROWS_SCANNED = 7 , EXTRA_INFO = 3 , LATENCY = 11 , QUERY_NAME = 0 , RESULT_SET_SIZE = 10 , ROWS_RETURNED = 12 , BLOCKED_THREAD_TIME = 1 , SYSTEM_PEAK_BUFFER_MEMORY = 14 , SYSTEM_PEAK_TEMP_DIR_SIZE = 15 , TOTAL_MEMORY_ALLOCATED = 91 , ATTACH_LOAD_STORAGE_LATENCY = 92 , ATTACH_REPLAY_WAL_LATENCY = 93 , CHECKPOINT_LATENCY = 94 , COMMIT_LOCAL_STORAGE_LATENCY = 95 , TOTAL_BYTES_READ = 16 , TOTAL_BYTES_WRITTEN = 17 , WAITING_TO_ATTACH_LATENCY = 96 , WAL_REPLAY_ENTRY_COUNT = 97 , WRITE_TO_WAL_LATENCY = 98 , OPERATOR_CARDINALITY = 6 , OPERATOR_NAME = 13 , OPERATOR_ROWS_SCANNED = 8 , OPERATOR_TIMING = 9 , OPERATOR_TYPE = 5 , OPTIMIZER_EXPRESSION_REWRITER = 26 , OPTIMIZER_FILTER_PULLUP = 27 , OPTIMIZER_FILTER_PUSHDOWN = 28 , OPTIMIZER_EMPTY_RESULT_PULLUP = 29 , OPTIMIZER_CTE_FILTER_PUSHER = 30 , OPTIMIZER_REGEX_RANGE = 31 , OPTIMIZER_IN_CLAUSE = 32 , OPTIMIZER_JOIN_ORDER = 33 , OPTIMIZER_DELIMINATOR = 34 , OPTIMIZER_UNNEST_REWRITER = 35 , OPTIMIZER_UNUSED_COLUMNS = 36 , OPTIMIZER_STATISTICS_PROPAGATION = 37 , OPTIMIZER_COMMON_SUBEXPRESSIONS = 38 , OPTIMIZER_COMMON_AGGREGATE = 39 , OPTIMIZER_COLUMN_LIFETIME = 40 , OPTIMIZER_BUILD_SIDE_PROBE_SIDE = 41 , OPTIMIZER_LIMIT_PUSHDOWN = 42 , OPTIMIZER_TOP_N = 43 , OPTIMIZER_COMPRESSED_MATERIALIZATION = 44 , OPTIMIZER_DUPLICATE_GROUPS = 45 , OPTIMIZER_REORDER_FILTER = 46 , OPTIMIZER_SAMPLING_PUSHDOWN = 47 , OPTIMIZER_JOIN_FILTER_PUSHDOWN = 48 , OPTIMIZER_EXTENSION = 49 , OPTIMIZER_MATERIALIZED_CTE = 50 , OPTIMIZER_SUM_REWRITER = 51 , OPTIMIZER_LATE_MATERIALIZATION = 52 , OPTIMIZER_CTE_INLINING = 53 , OPTIMIZER_ROW_GROUP_PRUNER = 54 , OPTIMIZER_TOP_N_WINDOW_ELIMINATION = 55 , OPTIMIZER_COMMON_SUBPLAN = 56 , OPTIMIZER_JOIN_ELIMINATION = 57 , OPTIMIZER_WINDOW_SELF_JOIN = 58 , ALL_OPTIMIZERS = 18 , CUMULATIVE_OPTIMIZER_TIMING = 19 , PHYSICAL_PLANNER = 22 , PHYSICAL_PLANNER_COLUMN_BINDING = 23 , PHYSICAL_PLANNER_CREATE_PLAN = 25 , PHYSICAL_PLANNER_RESOLVE_TYPES = 24 , PLANNER = 20 , PLANNER_BINDING = 21 }

enum class	ProfilingParameterNames : uint8_t { FORMAT , COVERAGE , SAVE_LOCATION , MODE , METRICS }

enum class	LambdaSyntax : uint8_t { DEFAULT = 0 , ENABLE_SINGLE_ARROW = 1 , DISABLE_SINGLE_ARROW = 2 }

enum class	LambdaSyntaxType : uint8_t { SINGLE_ARROW_STORAGE = 0 , SINGLE_ARROW = 1 , LAMBDA_KEYWORD = 2 }

enum class	ProfilingCoverage : uint8_t { SELECT = 0 , ALL = 1 }

enum class	SetScope : uint8_t { AUTOMATIC = 0 , LOCAL = 1 , SESSION = 2 , GLOBAL = 3 , VARIABLE = 4 }

enum class	SettingScope : uint8_t { GLOBAL , LOCAL , SECRET , INVALID }

enum class	SettingScopeTarget { INVALID , GLOBAL_ONLY , LOCAL_ONLY , GLOBAL_DEFAULT , LOCAL_DEFAULT }

enum class	ArrowTypeInfoType : uint8_t { LIST , STRUCT , DATE_TIME , STRING , ARRAY , DECIMAL }

enum class	ArrowDateTimeType : uint8_t { MILLISECONDS , MICROSECONDS , NANOSECONDS , SECONDS , DAYS , MONTHS , MONTH_DAY_NANO }

enum class	ArrowVariableSizeType : uint8_t { NORMAL , FIXED_SIZE , SUPER_SIZE , VIEW }

enum class	ArrowArrayPhysicalType : uint8_t { DICTIONARY_ENCODED , RUN_END_ENCODED , DEFAULT }

enum class	DecimalBitWidth : uint8_t { DECIMAL_32 , DECIMAL_64 , DECIMAL_128 , DECIMAL_256 }

enum class	AccessMode : uint8_t { UNDEFINED = 0 , AUTOMATIC = 1 , READ_ONLY = 2 , READ_WRITE = 3 }

enum class	CacheValidationMode : uint8_t { VALIDATE_ALL = 0 , VALIDATE_REMOTE = 1 , NO_VALIDATION = 2 }

enum class	ThreadPinMode : uint8_t { OFF = 0 , ON = 1 , AUTO = 2 }

enum class	BitpackingMode : uint8_t { INVALID , AUTO , CONSTANT , CONSTANT_DELTA , DELTA_FOR , FOR }

enum class	LogLevel : uint8_t { LOG_TRACE = 10 , LOG_DEBUG = 20 , LOG_INFO = 30 , LOG_WARNING = 40 , LOG_ERROR = 50 , LOG_FATAL = 60 }

enum class	LogContextScope : uint8_t { DATABASE = 10 , CONNECTION = 20 , THREAD = 30 }

enum class	LogMode : uint8_t { LEVEL_ONLY = 0 , DISABLE_SELECTED = 1 , ENABLE_SELECTED = 2 }

enum class	LoggingTargetTable : uint8_t { ALL_LOGS , LOG_ENTRIES , LOG_CONTEXTS }

enum class	AttachedDatabaseType { READ_WRITE_DATABASE , READ_ONLY_DATABASE , SYSTEM_DATABASE , TEMP_DATABASE }

enum class	AttachVisibility { SHOWN , HIDDEN }

enum class	RecoveryMode : uint8_t { DEFAULT = 0 , NO_WAL_WRITES = 1 }

enum class	DatabaseCloseAction { CHECKPOINT , TRY_CHECKPOINT }

enum class	TransactionState { UNCOMMITTED , COMMITTED , ROLLED_BACK }

enum class	InsertDatabasePathResult { SUCCESS , ALREADY_EXISTS }

enum class	RebindQueryInfo { DO_NOT_REBIND , ATTEMPT_TO_REBIND }

enum class	StreamExecutionResult : uint8_t { CHUNK_READY , CHUNK_NOT_READY , EXECUTION_ERROR , EXECUTION_CANCELLED , BLOCKED , NO_TASKS_AVAILABLE , EXECUTION_FINISHED }

enum class	TransactionType : uint8_t { INVALID , BEGIN_TRANSACTION , COMMIT , ROLLBACK }

enum class	TransactionModifierType : uint8_t { TRANSACTION_DEFAULT_MODIFIER , TRANSACTION_READ_ONLY , TRANSACTION_READ_WRITE }

enum class	TransactionInvalidationPolicy : uint8_t { STANDARD_POLICY , ALL_ERRORS_INVALIDATE_TRANSACTION }

enum class	OutputStream : uint8_t { STREAM_STDOUT = 1 , STREAM_STDERR = 2 }

enum class	ExplainType : uint8_t { EXPLAIN_STANDARD , EXPLAIN_ANALYZE }

enum class	ExtensionABIType : uint8_t { UNKNOWN = 0 , CPP = 1 , C_STRUCT = 2 , C_STRUCT_UNSTABLE = 3 }

enum class	PragmaType : uint8_t { PRAGMA_STATEMENT , PRAGMA_CALL }

enum class	MemoryTag : uint8_t { BASE_TABLE = 0 , HASH_TABLE = 1 , PARQUET_READER = 2 , CSV_READER = 3 , ORDER_BY = 4 , ART_INDEX = 5 , COLUMN_DATA = 6 , METADATA = 7 , OVERFLOW_STRINGS = 8 , IN_MEMORY_TABLE = 9 , ALLOCATOR = 10 , EXTENSION = 11 , TRANSACTION = 12 , EXTERNAL_FILE_CACHE = 13 , WINDOW = 14 , OBJECT_CACHE = 15 , UNKNOWN = 16 }

enum class	ConvertToPersistentMode { DESTRUCTIVE , THREAD_SAFE }

enum class	DestroyBufferUpon : uint8_t { BLOCK = 0 , EVICTION = 1 , UNPIN = 2 }

enum class	BlockState : uint8_t { BLOCK_UNLOADED = 0 , BLOCK_LOADED = 1 }

enum class	StrTimeSpecifier : uint8_t { ABBREVIATED_WEEKDAY_NAME = 0 , FULL_WEEKDAY_NAME = 1 , WEEKDAY_DECIMAL = 2 , DAY_OF_MONTH_PADDED = 3 , DAY_OF_MONTH = 4 , ABBREVIATED_MONTH_NAME = 5 , FULL_MONTH_NAME = 6 , MONTH_DECIMAL_PADDED = 7 , MONTH_DECIMAL = 8 , YEAR_WITHOUT_CENTURY_PADDED = 9 , YEAR_WITHOUT_CENTURY = 10 , YEAR_DECIMAL = 11 , HOUR_24_PADDED = 12 , HOUR_24_DECIMAL = 13 , HOUR_12_PADDED = 14 , HOUR_12_DECIMAL = 15 , AM_PM = 16 , MINUTE_PADDED = 17 , MINUTE_DECIMAL = 18 , SECOND_PADDED = 19 , SECOND_DECIMAL = 20 , MICROSECOND_PADDED = 21 , MILLISECOND_PADDED = 22 , UTC_OFFSET = 23 , TZ_NAME = 24 , DAY_OF_YEAR_PADDED = 25 , DAY_OF_YEAR_DECIMAL = 26 , WEEK_NUMBER_PADDED_SUN_FIRST , WEEK_NUMBER_PADDED_MON_FIRST , LOCALE_APPROPRIATE_DATE_AND_TIME , LOCALE_APPROPRIATE_DATE = 30 , LOCALE_APPROPRIATE_TIME = 31 , NANOSECOND_PADDED = 32 , YEAR_ISO , WEEKDAY_ISO = 34 , WEEK_NUMBER_ISO = 35 }

enum class	NewLineIdentifier : uint8_t { SINGLE_N = 1 , CARRY_ON = 2 , NOT_SET = 3 , SINGLE_R = 4 }

enum class	PartitionedColumnDataType : uint8_t { INVALID , RADIX , HIVE }

enum class	DebugVectorVerification : uint8_t { NONE , DICTIONARY_EXPRESSION , DICTIONARY_OPERATOR , CONSTANT_OPERATOR , SEQUENCE_OPERATOR , NESTED_SHUFFLE , VARIANT_VECTOR }

enum class	IndexConstraintType : uint8_t { NONE = 0 , UNIQUE = 1 , PRIMARY = 2 , FOREIGN = 3 }

enum class	DeprecatedIndexType : uint8_t { INVALID = 0 , ART = 1 , EXTENSION = 100 }

enum class	SampleType : uint8_t { BLOCKING_SAMPLE = 0 , RESERVOIR_SAMPLE = 1 , RESERVOIR_PERCENTAGE_SAMPLE = 2 }

enum class	SamplingState : uint8_t { RANDOM = 0 , RESERVOIR = 1 }

enum class	HLLStorageType : uint8_t { HLL_V1 = 1 , HLL_V2 = 2 }

enum class	ScanVectorType { SCAN_ENTIRE_VECTOR , SCAN_FLAT_VECTOR }

enum class	CompressionValidity : uint8_t { REQUIRES_VALIDITY , NO_VALIDITY_REQUIRED }

enum class	ColumnSegmentType : uint8_t { TRANSIENT , PERSISTENT }

enum class	ColumnDataType { MAIN_TABLE , INITIAL_TRANSACTION_LOCAL , TRANSACTION_LOCAL , CHECKPOINT_TARGET }

enum class	ExtraPersistentColumnDataType : uint8_t { INVALID = 0 , VARIANT = 1 , GEOMETRY = 2 }

enum class	BufferedIndexReplay : uint8_t { INSERT_ENTRY = 0 , DEL_ENTRY = 1 }

enum class	IndexAppendMode : uint8_t { DEFAULT = 0 , IGNORE_DUPLICATES = 1 , INSERT_DUPLICATES = 2 }

enum class	DeltaIndexType { NONE , LOCAL_APPEND , LOCAL_DELETE , ADDED_DURING_CHECKPOINT , REMOVED_DURING_CHECKPOINT , DELETED_ROWS_IN_USE }

enum class	IndexBindState : uint8_t { UNBOUND , BINDING , BOUND }
	IndexBindState to transition index binding phases preventing lock order inversion. More...

enum class	IndexRemovalType { MAIN_INDEX , MAIN_INDEX_ONLY , REVERT_MAIN_INDEX , REVERT_MAIN_INDEX_ONLY , DELETED_ROWS_IN_USE }

enum class	OptimisticWritePartialManagers { PER_COLUMN , GLOBAL }

enum class	DataTableVersion { MAIN_TABLE , ALTERED , DROPPED }

enum class	ValueComparisonResult { PRUNE_LEFT , PRUNE_RIGHT , UNSATISFIABLE_CONDITION , PRUNE_NOTHING }

enum class	FilterResult { UNSATISFIABLE , SUCCESS , UNSUPPORTED }

enum class	FilterPushdownResult { NO_PUSHDOWN , PUSHED_DOWN_PARTIALLY , PUSHED_DOWN_FULLY }

enum class	MultiFileColumnMappingMode : uint8_t { BY_NAME , BY_FIELD_ID }

enum class	SecretPersistType : uint8_t { DEFAULT , TEMPORARY , PERSISTENT }
	Whether a secret is persistent or temporary. More...

enum class	SecretDisplayType : uint8_t { REDACTED , UNREDACTED }
	Determines whether the secrets are allowed to be shown. More...

enum class	SecretSerializationType : uint8_t { CUSTOM = 0 , KEY_VALUE_SECRET = 1 }

enum class	CTEMaterialize : uint8_t { CTE_MATERIALIZE_DEFAULT = 1 , CTE_MATERIALIZE_ALWAYS = 2 , CTE_MATERIALIZE_NEVER = 3 }

enum class	QueryNodeType : uint8_t { SELECT_NODE = 1 , SET_OPERATION_NODE = 2 , BOUND_SUBQUERY_NODE = 3 , RECURSIVE_CTE_NODE = 4 , CTE_NODE = 5 , STATEMENT_NODE = 6 }

enum class	TableReferenceType : uint8_t { INVALID = 0 , BASE_TABLE = 1 , SUBQUERY = 2 , JOIN = 3 , TABLE_FUNCTION = 5 , EXPRESSION_LIST = 6 , CTE = 7 , EMPTY_FROM = 8 , PIVOT = 9 , SHOW_REF = 10 , COLUMN_DATA = 11 , DELIM_GET = 12 , BOUND_TABLE_REF = 13 }

enum class	SampleMethod : uint8_t { SYSTEM_SAMPLE = 0 , BERNOULLI_SAMPLE = 1 , RESERVOIR_SAMPLE = 2 , INVALID = 255 }

enum class	ExtensionInstallMode : uint8_t { UNKNOWN = 0 , REPOSITORY = 1 , CUSTOM_PATH = 2 , STATICALLY_LINKED = 3 , NOT_INSTALLED = 4 }

enum class	AppenderType : uint8_t { LOGICAL , PHYSICAL }

enum class	CacheBehavior { AUTOMATIC , ALWAYS_CACHE , NEVER_CACHE }

enum class	CAPIResultSetType : uint8_t { CAPI_RESULT_TYPE_NONE = 0 , CAPI_RESULT_TYPE_MATERIALIZED , CAPI_RESULT_TYPE_STREAMING , CAPI_RESULT_TYPE_DEPRECATED }

enum class	CopyToType : uint8_t { COPY_TO_FILE , EXPORT_DATABASE }

enum class	CopyOptionMode { WRITE_ONLY , READ_ONLY , READ_WRITE }

enum class	CopyFunctionExecutionMode { REGULAR_COPY_TO_FILE , PARALLEL_COPY_TO_FILE , BATCH_COPY_TO_FILE }

enum class	CopyFunctionReturnType : uint8_t { CHANGED_ROWS = 0 , CHANGED_ROWS_AND_FILE_LIST = 1 , WRITTEN_FILE_STATISTICS = 2 }

Functions
const string &	GetDefaultCatalog (CatalogEntryRetriever &retriever)

vector< CatalogSearchEntry >	GetCatalogEntries (CatalogEntryRetriever &retriever, const string &catalog, const string &schema)

void	FindMinimalQualification (CatalogEntryRetriever &retriever, const string &catalog_name, const string &schema_name, bool &qualify_database, bool &qualify_schema)

static bool	IsAutoloadableFunction (CatalogType type)

bool	IsTableFunction (CatalogType type)

bool	IsScalarFunction (CatalogType type)

static bool	CompareCatalogTypes (CatalogType type_a, CatalogType type_b)

static void	ThrowDefaultTableAmbiguityException (CatalogEntryLookup &base_lookup, CatalogEntryLookup &default_table, const string &name)

static void	FindForeignKeyInformation (TableCatalogEntry &table, AlterForeignKeyType alter_fk_type, vector< unique_ptr< AlterForeignKeyInfo > > &fk_arrays)

IndexStorageInfo	GetIndexInfo (const IndexConstraintType type, const bool v1_0_0_storage, unique_ptr< CreateInfo > &info, const idx_t id)

static void	CheckTypeIsSupported (const LogicalType &logical_type, AttachedDatabase &db)

static void	RenameExpression (ParsedExpression &root_expr, RenameColumnInfo &info)

unique_ptr< ParsedExpression >	PackExpression (unique_ptr< ParsedExpression > expr, string name)

static child_list_t< LogicalType >	GetChildList (const LogicalType &type)

static LogicalType	ConstructNewType (const LogicalType &original_type, child_list_t< LogicalType > new_child_types)

Value	ConstructMapping (const string &name, const LogicalType &type)

StructMappingInfo	AddFieldToStruct (const LogicalType &type, const vector< string > &column_path, const ColumnDefinition &new_field, idx_t depth=0)

DroppedFieldMapping	DropFieldFromStruct (const LogicalType &type, const vector< string > &column_path, idx_t depth)

DroppedFieldMapping	RenameFieldFromStruct (const LogicalType &type, const vector< string > &column_path, const string &new_name, idx_t depth)

static bool	IsDependencyEntry (CatalogEntry &entry)

static bool	DefaultFunctionMatches (const DefaultMacro &macro, const string &schema, const string &name)

static unique_ptr< CreateFunctionInfo >	GetDefaultFunction (const string &input_schema, const string &input_name)

static unique_ptr< CreateFunctionInfo >	GetDefaultTableFunction (const string &input_schema, const string &input_name)

static unique_ptr< CreateViewInfo >	GetDefaultView (ClientContext &context, const string &input_schema, const string &input_name)

static string	GetSchema (CatalogEntry &entry)

static void	AssertMangledName (const string &mangled_name, idx_t expected_null_bytes)

static bool	CascadeDrop (bool cascade, const DependencyDependentFlags &flags)

static string	EntryToString (CatalogEntryInfo &info)

static string	FormatString (const MangledEntryName &mangled)

template<class T >
T	NullValue ()
	Placeholder to insert in Vectors or to use for hashing NULLs.

template<>
const char *	NullValue ()

template<>
string_t	NullValue ()

template<>
char *	NullValue ()

template<>
string	NullValue ()

template<>
interval_t	NullValue ()

template<>
hugeint_t	NullValue ()

template<>
float	NullValue ()

template<>
double	NullValue ()

template<class SRC , class DST >
static string	CastExceptionText (SRC input)

static bool	TryCastStringBool (const char *input_data, idx_t input_size, bool &result, bool strict)

static void	MallocTrim (idx_t pad)

template<class OP >
static void	InitializeAppenderForType (ArrowAppendData &append_data)

static void	InitializeFunctionPointers (ArrowAppendData &append_data, const LogicalType &type)

unsafe_unique_array< char >	AddName (const string &name)

static void	ReleaseDuckDBArrowSchema (ArrowSchema *schema)

void	InitializeChild (ArrowSchema &child, DuckDBArrowSchemaHolder &root_holder, const string &name="")

void	SetArrowFormat (DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type, ClientProperties &options, ClientContext &context)

void	SetArrowStructFormat (DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type, ClientProperties &options, ClientContext &context, bool map_is_parent=false)

void	SetArrowMapFormat (DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type, ClientProperties &options, ClientContext &context)

bool	SetArrowExtension (DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type, ClientContext &context)

void	FastMemcpy (void dest, const void src, const size_t size)

int	FastMemcmp (const void str1, const void str2, const size_t size)

void	FastMemset (void *ptr, int value, size_t size)

ArrowTypeExtension	GetArrowExtensionInternal (unordered_map< ArrowExtensionMetadata, ArrowTypeExtension, HashArrowTypeExtension > &type_extensions, ArrowExtensionMetadata info)

void	DuckDBAssertInternal (bool condition, const char condition_name, const char file, int linenr)

void	PrintBits (const char value)

void	BignumAddition (data_ptr_t result, int64_t result_end, bool is_target_absolute_bigger, const BignumIntermediate &lhs, const BignumIntermediate &rhs)

string	ProduceOverUnderFlowError (bool is_result_negative, idx_t actual_start, idx_t data_size)

Value	ConvertVectorToValue (vector< Value > set)

vector< bool >	ParseColumnList (const vector< Value > &set, vector< string > &names, const string &option_name)

vector< bool >	ParseColumnList (const Value &value, vector< string > &names, const string &option_name)

vector< idx_t >	ParseColumnsOrdered (const vector< Value > &set, vector< string > &names, const string &loption)

vector< idx_t >	ParseColumnsOrdered (const Value &value, vector< string > &names, const string &loption)

bool	IsWhitespaceEscape (const char c)

uint64_t	Checksum (uint8_t *buffer, size_t size)
	Compute a checksum over a buffer of size size.

hash_t	Checksum (uint64_t x)

hash_t	ChecksumRemainder (void *ptr, size_t len) noexcept

bool	IsPowerOfTwo (uint64_t v)

uint64_t	NextPowerOfTwo (uint64_t v)

uint64_t	PreviousPowerOfTwo (uint64_t v)

bool	IsInvalidSchema (const string &str)

bool	IsInvalidCatalog (const string &str)

bool	IsRowIdColumnId (column_t column_id)

bool	IsVirtualColumn (column_t column_id)

static void	ByteReverse (unsigned char *buf, unsigned longs)

static void	MD5Transform (uint32_t buf[4], const uint32_t in[16])

static string	TransformNewLine (string new_line)

static idx_t	GetFileSize (unique_ptr< BufferedFileWriter > &file_writer, idx_t &bytes_written)

static void	DecryptBuffer (EncryptionState &encryption_state, const_data_ptr_t temp_key, data_ptr_t buffer, idx_t buffer_size, data_ptr_t metadata)

const char *	ToString (AggregateHandling value)

bool	IsBigintDatepart (DatePartSpecifier part_code)

DUCKDB_API bool	TryGetDatePartSpecifier (const string &specifier, DatePartSpecifier &result)

DUCKDB_API DatePartSpecifier	GetDatePartSpecifier (const string &specifier)

template<class T , bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation, char decimal_separator = '.'>
static bool	IntegerCastLoop (const char *buf, idx_t len, T &result, bool strict)

template<class T , bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation>
static bool	IntegerHexCastLoop (const char *buf, idx_t len, T &result, bool strict)

template<class T , bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation>
static bool	IntegerBinaryCastLoop (const char *buf, idx_t len, T &result, bool strict)

template<class T , bool IS_SIGNED = true, bool ALLOW_EXPONENT = true, class OP = IntegerCastOperation, bool ZERO_INITIALIZE = true, char decimal_separator = '.'>
static bool	TryIntegerCast (const char *buf, idx_t len, T &result, bool strict)

template<typename T , bool IS_SIGNED = true>
static bool	TrySimpleIntegerCast (const char *buf, idx_t len, T &result, bool strict)

template<class T , char decimal_separator = '.'>
bool	TryDecimalStringCast (string_t input, T &result, CastParameters &parameters, uint8_t width, uint8_t scale)

template<class T , char decimal_separator = '.'>
bool	TryDecimalStringCast (const char *string_ptr, idx_t string_size, T &result, CastParameters &parameters, uint8_t width, uint8_t scale)

template<class T , char decimal_separator = '.'>
bool	TryDecimalStringCast (const char *string_ptr, idx_t string_size, T &result, uint8_t width, uint8_t scale)

template<idx_t REMAINING>
static bool	SortKeyLessThan (const uint64_t const &lhs, const uint64_t const &rhs)

template<>
bool	SortKeyLessThan< 1 > (const uint64_t const &lhs, const uint64_t const &rhs)

const char *	ToString (WindowBoundary value)

const StringUtil::EnumStringLiteral *	GetARTConflictTypeValues ()

const StringUtil::EnumStringLiteral *	GetARTHandlingResultValues ()

const StringUtil::EnumStringLiteral *	GetARTScanHandlingValues ()

const StringUtil::EnumStringLiteral *	GetARTScanResultValues ()

const StringUtil::EnumStringLiteral *	GetAccessModeValues ()

const StringUtil::EnumStringLiteral *	GetAggregateCombineTypeValues ()

const StringUtil::EnumStringLiteral *	GetAggregateDistinctDependentValues ()

const StringUtil::EnumStringLiteral *	GetAggregateHandlingValues ()

const StringUtil::EnumStringLiteral *	GetAggregateOrderDependentValues ()

const StringUtil::EnumStringLiteral *	GetAggregateTypeValues ()

const StringUtil::EnumStringLiteral *	GetAllowParserOverrideValues ()

const StringUtil::EnumStringLiteral *	GetAlterDatabaseTypeValues ()

const StringUtil::EnumStringLiteral *	GetAlterForeignKeyTypeValues ()

const StringUtil::EnumStringLiteral *	GetAlterScalarFunctionTypeValues ()

const StringUtil::EnumStringLiteral *	GetAlterTableFunctionTypeValues ()

const StringUtil::EnumStringLiteral *	GetAlterTableTypeValues ()

const StringUtil::EnumStringLiteral *	GetAlterTypeValues ()

const StringUtil::EnumStringLiteral *	GetAlterViewTypeValues ()

const StringUtil::EnumStringLiteral *	GetAppenderTypeValues ()

const StringUtil::EnumStringLiteral *	GetArrowArrayPhysicalTypeValues ()

const StringUtil::EnumStringLiteral *	GetArrowDateTimeTypeValues ()

const StringUtil::EnumStringLiteral *	GetArrowFormatVersionValues ()

const StringUtil::EnumStringLiteral *	GetArrowOffsetSizeValues ()

const StringUtil::EnumStringLiteral *	GetArrowTypeInfoTypeValues ()

const StringUtil::EnumStringLiteral *	GetArrowVariableSizeTypeValues ()

const StringUtil::EnumStringLiteral *	GetAsyncResultTypeValues ()

const StringUtil::EnumStringLiteral *	GetAsyncResultsExecutionModeValues ()

const StringUtil::EnumStringLiteral *	GetBaseColumnPrunerModeValues ()

const StringUtil::EnumStringLiteral *	GetBinderTypeValues ()

const StringUtil::EnumStringLiteral *	GetBindingModeValues ()

const StringUtil::EnumStringLiteral *	GetBitpackingModeValues ()

const StringUtil::EnumStringLiteral *	GetBlockIteratorStateTypeValues ()

const StringUtil::EnumStringLiteral *	GetBlockStateValues ()

const StringUtil::EnumStringLiteral *	GetBufferedIndexReplayValues ()

const StringUtil::EnumStringLiteral *	GetCAPIResultSetTypeValues ()

const StringUtil::EnumStringLiteral *	GetCSVStateValues ()

const StringUtil::EnumStringLiteral *	GetCTEMaterializeValues ()

const StringUtil::EnumStringLiteral *	GetCacheValidationModeValues ()

const StringUtil::EnumStringLiteral *	GetCachingModeValues ()

const StringUtil::EnumStringLiteral *	GetCatalogLookupBehaviorValues ()

const StringUtil::EnumStringLiteral *	GetCatalogTypeValues ()

const StringUtil::EnumStringLiteral *	GetCheckpointAbortValues ()

const StringUtil::EnumStringLiteral *	GetChunkInfoTypeValues ()

const StringUtil::EnumStringLiteral *	GetColumnDataAllocatorTypeValues ()

const StringUtil::EnumStringLiteral *	GetColumnDataScanPropertiesValues ()

const StringUtil::EnumStringLiteral *	GetColumnIndexTypeValues ()

const StringUtil::EnumStringLiteral *	GetColumnSegmentTypeValues ()

const StringUtil::EnumStringLiteral *	GetCompressedMaterializationDirectionValues ()

const StringUtil::EnumStringLiteral *	GetCompressionTypeValues ()

const StringUtil::EnumStringLiteral *	GetCompressionValidityValues ()

const StringUtil::EnumStringLiteral *	GetConflictManagerModeValues ()

const StringUtil::EnumStringLiteral *	GetConstraintTypeValues ()

const StringUtil::EnumStringLiteral *	GetCoordinateReferenceSystemTypeValues ()

const StringUtil::EnumStringLiteral *	GetCopyFunctionReturnTypeValues ()

const StringUtil::EnumStringLiteral *	GetCopyOverwriteModeValues ()

const StringUtil::EnumStringLiteral *	GetCopyToTypeValues ()

const StringUtil::EnumStringLiteral *	GetDataFileTypeValues ()

const StringUtil::EnumStringLiteral *	GetDateCastResultValues ()

const StringUtil::EnumStringLiteral *	GetDatePartSpecifierValues ()

const StringUtil::EnumStringLiteral *	GetDebugInitializeValues ()

const StringUtil::EnumStringLiteral *	GetDebugVectorVerificationValues ()

const StringUtil::EnumStringLiteral *	GetDecimalBitWidthValues ()

const StringUtil::EnumStringLiteral *	GetDefaultOrderByNullTypeValues ()

const StringUtil::EnumStringLiteral *	GetDependencyEntryTypeValues ()

const StringUtil::EnumStringLiteral *	GetDeprecatedIndexTypeValues ()

const StringUtil::EnumStringLiteral *	GetDeprecatedUsingKeySyntaxValues ()

const StringUtil::EnumStringLiteral *	GetDestroyBufferUponValues ()

const StringUtil::EnumStringLiteral *	GetDistinctTypeValues ()

const StringUtil::EnumStringLiteral *	GetErrorTypeValues ()

const StringUtil::EnumStringLiteral *	GetExceptionFormatValueTypeValues ()

const StringUtil::EnumStringLiteral *	GetExceptionTypeValues ()

const StringUtil::EnumStringLiteral *	GetExplainFormatValues ()

const StringUtil::EnumStringLiteral *	GetExplainOutputTypeValues ()

const StringUtil::EnumStringLiteral *	GetExplainTypeValues ()

const StringUtil::EnumStringLiteral *	GetExponentTypeValues ()

const StringUtil::EnumStringLiteral *	GetExpressionClassValues ()

const StringUtil::EnumStringLiteral *	GetExpressionTypeValues ()

const StringUtil::EnumStringLiteral *	GetExtensionABITypeValues ()

const StringUtil::EnumStringLiteral *	GetExtensionInstallModeValues ()

const StringUtil::EnumStringLiteral *	GetExtensionLoadResultValues ()

const StringUtil::EnumStringLiteral *	GetExtensionUpdateResultTagValues ()

const StringUtil::EnumStringLiteral *	GetExtraDropInfoTypeValues ()

const StringUtil::EnumStringLiteral *	GetExtraPersistentColumnDataTypeValues ()

const StringUtil::EnumStringLiteral *	GetExtraTypeInfoTypeValues ()

const StringUtil::EnumStringLiteral *	GetFileBufferTypeValues ()

const StringUtil::EnumStringLiteral *	GetFileCompressionTypeValues ()

const StringUtil::EnumStringLiteral *	GetFileExpandResultValues ()

const StringUtil::EnumStringLiteral *	GetFileGlobOptionsValues ()

const StringUtil::EnumStringLiteral *	GetFileLockTypeValues ()

const StringUtil::EnumStringLiteral *	GetFileNameSegmentTypeValues ()

const StringUtil::EnumStringLiteral *	GetFilterPropagateResultValues ()

const StringUtil::EnumStringLiteral *	GetForeignKeyTypeValues ()

const StringUtil::EnumStringLiteral *	GetFunctionCollationHandlingValues ()

const StringUtil::EnumStringLiteral *	GetFunctionErrorsValues ()

const StringUtil::EnumStringLiteral *	GetFunctionNullHandlingValues ()

const StringUtil::EnumStringLiteral *	GetFunctionStabilityValues ()

const StringUtil::EnumStringLiteral *	GetGateStatusValues ()

const StringUtil::EnumStringLiteral *	GetGeometryStorageTypeValues ()

const StringUtil::EnumStringLiteral *	GetGeometryTypeValues ()

const StringUtil::EnumStringLiteral *	GetHLLStorageTypeValues ()

const StringUtil::EnumStringLiteral *	GetHTTPStatusCodeValues ()

const StringUtil::EnumStringLiteral *	GetIndexAppendModeValues ()

const StringUtil::EnumStringLiteral *	GetIndexBindStateValues ()

const StringUtil::EnumStringLiteral *	GetIndexConstraintTypeValues ()

const StringUtil::EnumStringLiteral *	GetInsertColumnOrderValues ()

const StringUtil::EnumStringLiteral *	GetInterruptModeValues ()

const StringUtil::EnumStringLiteral *	GetJoinRefTypeValues ()

const StringUtil::EnumStringLiteral *	GetJoinTypeValues ()

const StringUtil::EnumStringLiteral *	GetKeywordCategoryValues ()

const StringUtil::EnumStringLiteral *	GetLambdaSyntaxValues ()

const StringUtil::EnumStringLiteral *	GetLambdaSyntaxTypeValues ()

const StringUtil::EnumStringLiteral *	GetLimitNodeTypeValues ()

const StringUtil::EnumStringLiteral *	GetLoadTypeValues ()

const StringUtil::EnumStringLiteral *	GetLogContextScopeValues ()

const StringUtil::EnumStringLiteral *	GetLogLevelValues ()

const StringUtil::EnumStringLiteral *	GetLogModeValues ()

const StringUtil::EnumStringLiteral *	GetLoggingTargetTableValues ()

const StringUtil::EnumStringLiteral *	GetLogicalOperatorTypeValues ()

const StringUtil::EnumStringLiteral *	GetLogicalTypeIdValues ()

const StringUtil::EnumStringLiteral *	GetLookupResultTypeValues ()

const StringUtil::EnumStringLiteral *	GetMacroTypeValues ()

const StringUtil::EnumStringLiteral *	GetMapInvalidReasonValues ()

const StringUtil::EnumStringLiteral *	GetMemoryTagValues ()

const StringUtil::EnumStringLiteral *	GetMergeActionConditionValues ()

const StringUtil::EnumStringLiteral *	GetMergeActionTypeValues ()

const StringUtil::EnumStringLiteral *	GetMetaPipelineTypeValues ()

const StringUtil::EnumStringLiteral *	GetMetricGroupValues ()

const StringUtil::EnumStringLiteral *	GetMetricTypeValues ()

const StringUtil::EnumStringLiteral *	GetMultiFileColumnMappingModeValues ()

const StringUtil::EnumStringLiteral *	GetMultiFileFileStateValues ()

const StringUtil::EnumStringLiteral *	GetNTypeValues ()

const StringUtil::EnumStringLiteral *	GetNewLineIdentifierValues ()

const StringUtil::EnumStringLiteral *	GetOnConflictActionValues ()

const StringUtil::EnumStringLiteral *	GetOnCreateConflictValues ()

const StringUtil::EnumStringLiteral *	GetOnEntryNotFoundValues ()

const StringUtil::EnumStringLiteral *	GetOperatorCachingModeValues ()

const StringUtil::EnumStringLiteral *	GetOperatorFinalResultTypeValues ()

const StringUtil::EnumStringLiteral *	GetOperatorFinalizeResultTypeValues ()

const StringUtil::EnumStringLiteral *	GetOperatorResultTypeValues ()

const StringUtil::EnumStringLiteral *	GetOptimizerTypeValues ()

const StringUtil::EnumStringLiteral *	GetOrderByColumnTypeValues ()

const StringUtil::EnumStringLiteral *	GetOrderByNullTypeValues ()

const StringUtil::EnumStringLiteral *	GetOrderByStatisticsValues ()

const StringUtil::EnumStringLiteral *	GetOrderPreservationTypeValues ()

const StringUtil::EnumStringLiteral *	GetOrderTypeValues ()

const StringUtil::EnumStringLiteral *	GetOrdinalityTypeValues ()

const StringUtil::EnumStringLiteral *	GetOutputStreamValues ()

const StringUtil::EnumStringLiteral *	GetParseInfoTypeValues ()

const StringUtil::EnumStringLiteral *	GetParserExtensionResultTypeValues ()

const StringUtil::EnumStringLiteral *	GetPartitionedColumnDataTypeValues ()

const StringUtil::EnumStringLiteral *	GetPartitionedTupleDataTypeValues ()

const StringUtil::EnumStringLiteral *	GetPendingExecutionResultValues ()

const StringUtil::EnumStringLiteral *	GetPhysicalOperatorTypeValues ()

const StringUtil::EnumStringLiteral *	GetPhysicalTableScanExecutionStrategyValues ()

const StringUtil::EnumStringLiteral *	GetPhysicalTypeValues ()

const StringUtil::EnumStringLiteral *	GetPragmaTypeValues ()

const StringUtil::EnumStringLiteral *	GetPreparedParamTypeValues ()

const StringUtil::EnumStringLiteral *	GetPreparedStatementModeValues ()

const StringUtil::EnumStringLiteral *	GetPreserveOrderTypeValues ()

const StringUtil::EnumStringLiteral *	GetProfilerPrintFormatValues ()

const StringUtil::EnumStringLiteral *	GetProfilingCoverageValues ()

const StringUtil::EnumStringLiteral *	GetProfilingParameterNamesValues ()

const StringUtil::EnumStringLiteral *	GetPushdownExtractSupportValues ()

const StringUtil::EnumStringLiteral *	GetQuantileSerializationTypeValues ()

const StringUtil::EnumStringLiteral *	GetQueryNodeTypeValues ()

const StringUtil::EnumStringLiteral *	GetQueryResultMemoryTypeValues ()

const StringUtil::EnumStringLiteral *	GetQueryResultOutputTypeValues ()

const StringUtil::EnumStringLiteral *	GetQueryResultTypeValues ()

const StringUtil::EnumStringLiteral *	GetRecoveryModeValues ()

const StringUtil::EnumStringLiteral *	GetRelationTypeValues ()

const StringUtil::EnumStringLiteral *	GetRenderModeValues ()

const StringUtil::EnumStringLiteral *	GetRequestTypeValues ()

const StringUtil::EnumStringLiteral *	GetResultModifierTypeValues ()

const StringUtil::EnumStringLiteral *	GetSampleMethodValues ()

const StringUtil::EnumStringLiteral *	GetSampleTypeValues ()

const StringUtil::EnumStringLiteral *	GetSamplingStateValues ()

const StringUtil::EnumStringLiteral *	GetScanTypeValues ()

const StringUtil::EnumStringLiteral *	GetSecretDisplayTypeValues ()

const StringUtil::EnumStringLiteral *	GetSecretPersistTypeValues ()

const StringUtil::EnumStringLiteral *	GetSecretSerializationTypeValues ()

const StringUtil::EnumStringLiteral *	GetSequenceInfoValues ()

const StringUtil::EnumStringLiteral *	GetSetOperationTypeValues ()

const StringUtil::EnumStringLiteral *	GetSetScopeValues ()

const StringUtil::EnumStringLiteral *	GetSetTypeValues ()

const StringUtil::EnumStringLiteral *	GetSettingScopeValues ()

const StringUtil::EnumStringLiteral *	GetShowTypeValues ()

const StringUtil::EnumStringLiteral *	GetSimplifiedTokenTypeValues ()

const StringUtil::EnumStringLiteral *	GetSinkCombineResultTypeValues ()

const StringUtil::EnumStringLiteral *	GetSinkFinalizeTypeValues ()

const StringUtil::EnumStringLiteral *	GetSinkNextBatchTypeValues ()

const StringUtil::EnumStringLiteral *	GetSinkResultTypeValues ()

const StringUtil::EnumStringLiteral *	GetSortKeyTypeValues ()

const StringUtil::EnumStringLiteral *	GetSourceResultTypeValues ()

const StringUtil::EnumStringLiteral *	GetStarExpressionTypeValues ()

const StringUtil::EnumStringLiteral *	GetStatementReturnTypeValues ()

const StringUtil::EnumStringLiteral *	GetStatementTypeValues ()

const StringUtil::EnumStringLiteral *	GetStatisticsTypeValues ()

const StringUtil::EnumStringLiteral *	GetStatsInfoValues ()

const StringUtil::EnumStringLiteral *	GetStorageBlockPrefetchValues ()

const StringUtil::EnumStringLiteral *	GetStorageIndexTypeValues ()

const StringUtil::EnumStringLiteral *	GetStrTimeSpecifierValues ()

const StringUtil::EnumStringLiteral *	GetStreamExecutionResultValues ()

const StringUtil::EnumStringLiteral *	GetSubqueryTypeValues ()

const StringUtil::EnumStringLiteral *	GetTableColumnTypeValues ()

const StringUtil::EnumStringLiteral *	GetTableFilterTypeValues ()

const StringUtil::EnumStringLiteral *	GetTablePartitionInfoValues ()

const StringUtil::EnumStringLiteral *	GetTableReferenceTypeValues ()

const StringUtil::EnumStringLiteral *	GetTaskExecutionModeValues ()

const StringUtil::EnumStringLiteral *	GetTaskExecutionResultValues ()

const StringUtil::EnumStringLiteral *	GetTemporaryBufferSizeValues ()

const StringUtil::EnumStringLiteral *	GetTemporaryCompressionLevelValues ()

const StringUtil::EnumStringLiteral *	GetThreadPinModeValues ()

const StringUtil::EnumStringLiteral *	GetTimestampCastResultValues ()

const StringUtil::EnumStringLiteral *	GetTransactionInvalidationPolicyValues ()

const StringUtil::EnumStringLiteral *	GetTransactionModifierTypeValues ()

const StringUtil::EnumStringLiteral *	GetTransactionTypeValues ()

const StringUtil::EnumStringLiteral *	GetTupleDataNestednessTypeValues ()

const StringUtil::EnumStringLiteral *	GetTupleDataPinPropertiesValues ()

const StringUtil::EnumStringLiteral *	GetTupleDataValidityTypeValues ()

const StringUtil::EnumStringLiteral *	GetUndoFlagsValues ()

const StringUtil::EnumStringLiteral *	GetUnionInvalidReasonValues ()

const StringUtil::EnumStringLiteral *	GetVariantChildLookupModeValues ()

const StringUtil::EnumStringLiteral *	GetVariantLogicalTypeValues ()

const StringUtil::EnumStringLiteral *	GetVariantStatsShreddingStateValues ()

const StringUtil::EnumStringLiteral *	GetVariantValueTypeValues ()

const StringUtil::EnumStringLiteral *	GetVectorAuxiliaryDataTypeValues ()

const StringUtil::EnumStringLiteral *	GetVectorBufferTypeValues ()

const StringUtil::EnumStringLiteral *	GetVectorTypeValues ()

const StringUtil::EnumStringLiteral *	GetVerificationTypeValues ()

const StringUtil::EnumStringLiteral *	GetVerifyExistenceTypeValues ()

const StringUtil::EnumStringLiteral *	GetVertexTypeValues ()

const StringUtil::EnumStringLiteral *	GetWALTypeValues ()

const StringUtil::EnumStringLiteral *	GetWindowAggregationModeValues ()

const StringUtil::EnumStringLiteral *	GetWindowBoundaryValues ()

const StringUtil::EnumStringLiteral *	GetWindowExcludeModeValues ()

const StringUtil::EnumStringLiteral *	GetWindowMergeSortStageValues ()

string	CatalogTypeToString (CatalogType type)

CatalogType	CatalogTypeFromString (const string &type)

vector< string >	ListCompressionTypes (void)

CompressionAvailabilityResult	CompressionTypeIsAvailable (CompressionType compression_type, optional_ptr< StorageManager > storage_manager)

string	CompressionTypeToString (CompressionType type)

string	ExpressionTypeToString (ExpressionType type)

string	ExpressionClassToString (ExpressionClass type)

string	ExpressionTypeToOperator (ExpressionType type)

ExpressionType	NegateComparisonExpression (ExpressionType type)
	Negate a comparison expression, turning e.g. = into !=, or < into >=.

ExpressionType	FlipComparisonExpression (ExpressionType type)
	Flip a comparison expression, turning e.g. < into >, or = into =.

ExpressionType	OperatorToExpressionType (const string &op)

FileCompressionType	FileCompressionTypeFromString (const string &input)

string	CompressionExtensionFromType (const FileCompressionType type)

bool	IsFileCompressed (string path, FileCompressionType type)

bool	IsLeftOuterJoin (JoinType type)
	True if join is left or full outer join.

bool	IsRightOuterJoin (JoinType type)
	True if join is rght or full outer join.

bool	PropagatesBuildSide (JoinType type)
	Whether the build side is propagated out of the join.

bool	HasInverseJoinType (JoinType type)
	Whether the JoinType has an inverse.

JoinType	InverseJoinType (JoinType type)
	Gets the inverse JoinType, e.g., LEFT -> RIGHT.

string	JoinTypeToString (JoinType type)

string	LogicalOperatorToString (LogicalOperatorType type)

string	OptimizerTypeToString (OptimizerType type)

vector< string >	ListAllOptimizers ()

OptimizerType	OptimizerTypeFromString (const string &str)

string	PhysicalOperatorToString (PhysicalOperatorType type)

string	RelationTypeToString (RelationType type)

string	StatementTypeToString (StatementType type)

string	StatementReturnTypeToString (StatementReturnType type)

template<class T >
int64_t	TemplatedGetPos (const string_map_t< T > &map, const string_t &key)

bool	PathMatched (const string &path, const string &sub_path)

static idx_t	GetFileUrlOffset (const string &path)

bool	SupportsLegacyFilenamePattern (const vector< FileNameSegment > &segments)

LegacyFilenamePattern	GetLegacyFilenamePattern (const vector< FileNameSegment > &segments)

static idx_t	GZipConsumeString (QueryContext context, FileHandle &input)

static unordered_map< column_t, PartitioningColumnValue >	GetKnownColumnValues (const string &filename, const HivePartitioningFilterInfo &filter_info)

static void	ConvertKnownColRefToConstants (ClientContext &context, unique_ptr< Expression > &expr, const unordered_map< column_t, PartitioningColumnValue > &known_column_values, idx_t table_index)

template<class T >
static Value	GetHiveKeyValue (const T &val)

template<class T >
static Value	GetHiveKeyValue (const T &val, const LogicalType &type)

static Value	GetHiveKeyNullValue (const LogicalType &type)

template<class T >
static void	TemplatedGetHivePartitionValues (Vector &input, vector< HivePartitionKey > &keys, const idx_t col_idx, const idx_t count)

static void	GetNestedHivePartitionValues (Vector &input, vector< HivePartitionKey > &keys, const idx_t col_idx, const idx_t count)

static void	GetHivePartitionValuesTypeSwitch (Vector &input, vector< HivePartitionKey > &keys, const idx_t col_idx, const idx_t count)

bool	IsAscii (const char *input, idx_t n)

idx_t	LowerLength (const char *input_data, idx_t input_length)

void	LowerCase (const char input_data, idx_t input_length, char result_data)

idx_t	FindStrInStr (const string_t &haystack_s, const string_t &needle_s)

idx_t	FindStrInStr (const unsigned char haystack, idx_t haystack_size, const unsigned char needle, idx_t needle_size)

string_t	SubstringASCII (Vector &result, string_t input, int64_t offset, int64_t length)

string_t	SubstringUnicode (Vector &result, string_t input, int64_t offset, int64_t length)

string_t	SubstringGrapheme (Vector &result, string_t input, int64_t offset, int64_t length)

ScalarFunction	GetStringContains ()

DUCKDB_API bool	Glob (const char s, idx_t slen, const char pattern, idx_t plen, bool allow_question_mark=true)

static bool	IsCharacter (char c)

template<class TA , class TR >
static TR	Length (TA input)

template<class TA , class TR >
static TR	GraphemeCount (TA input)

static FileMetadata	StatsInternal (int fd, const string &path)

static string	AdditionalProcessInfo (FileSystem &fs, pid_t pid)

int	RemoveDirectoryRecursive (const char *path)

string	GetPosixVersionTag (struct stat s)

static bool	IsCrawl (const string &glob)

static bool	IsSymbolicLink (const string &path)

static bool	HasMultipleCrawl (const vector< PathSplit > &splits)

static void	CrawlDirectoryLevel (FileSystem &fs, const string &path, optional_ptr< vector< OpenFileInfo > > files, std::priority_queue< ExpandDirectory > &directories, idx_t split_index)

static void	GlobFilesInternal (FileSystem &fs, const string &path, const string &glob, bool match_directory, vector< OpenFileInfo > &result)

ScalarFunction	GetKeyExtractFunction ()

ScalarFunction	GetIndexExtractFunction ()

ScalarFunction	GetExtractAtFunction ()

template<class SRC >
data_ptr_t	data_ptr_cast (SRC *src)

template<class SRC >
const_data_ptr_t	const_data_ptr_cast (const SRC *src)

template<class SRC >
char *	char_ptr_cast (SRC *src)

template<class SRC >
const char *	const_char_ptr_cast (const SRC *src)

template<class SRC >
const unsigned char *	const_uchar_ptr_cast (const SRC *src)

template<class SRC >
uintptr_t	CastPointerToValue (SRC *src)

template<class SRC >
uint64_t	cast_pointer_to_uint64 (SRC *src)

template<class SRC = data_t>
SRC *	cast_uint64_to_pointer (uint64_t value)

void	AssertRestrictFunction (const void left_start, const void left_end, const void right_start, const void right_end, const char *fname, int linenr)

static int8_t	BSwap (const int8_t &x)

static uint8_t	BSwap (const uint8_t &x)

static uint16_t	BSwap (const uint16_t &x)

static int16_t	BSwap (const int16_t &x)

static uint32_t	BSwap (const uint32_t &x)

static int32_t	BSwap (const int32_t &x)

static uint64_t	BSwap (const uint64_t &x)

static int64_t	BSwap (const int64_t &x)

static uhugeint_t	BSwap (const uhugeint_t &x)

static hugeint_t	BSwap (const hugeint_t &x)

static float	BSwap (const float &x)

static double	BSwap (const double &x)

template<class T >
static T	BSwapIfLE (const T &x)

template<class T >
static T	BSwapIfBE (const T &x)

template<class DATA_TYPE , class... ARGS>
TemplatedUniqueIf< DATA_TYPE, true >::templated_unique_single_t	make_uniq (ARGS &&... args)

template<class DATA_TYPE , class... ARGS>
shared_ptr< DATA_TYPE >	make_shared_ptr (ARGS &&... args)

template<class DATA_TYPE , class... ARGS>
TemplatedUniqueIf< DATA_TYPE, false >::templated_unique_single_t	make_unsafe_uniq (ARGS &&... args)

template<class DATA_TYPE >
unique_ptr< DATA_TYPE[], std::default_delete< DATA_TYPE[]>, true >	make_uniq_array (size_t n)

template<class DATA_TYPE >
unique_ptr< DATA_TYPE[], std::default_delete< DATA_TYPE[]>, true >	make_uniq_array_uninitialized (size_t n)

template<class DATA_TYPE >
unique_ptr< DATA_TYPE[], std::default_delete< DATA_TYPE[]>, false >	make_unsafe_uniq_array (size_t n)

template<class DATA_TYPE >
unique_ptr< DATA_TYPE[], std::default_delete< DATA_TYPE[]>, false >	make_unsafe_uniq_array_uninitialized (size_t n)

template<class DATA_TYPE , class... ARGS>
TemplatedUniqueIf< DATA_TYPE >::TemplatedUniqueArrayKnownBound	make_uniq (ARGS &&...)=delete

template<typename S , typename T , typename... ARGS>
unique_ptr< S >	make_uniq_base (ARGS &&... args)

template<typename SRC , typename TGT >
unique_ptr< TGT >	unique_ptr_cast (unique_ptr< SRC > src)

template<typename SRC , typename TGT >
shared_ptr< TGT >	shared_ptr_cast (shared_ptr< SRC > src)

template<class T , class... ARGS>
static duckdb::unique_ptr< T >	make_unique (ARGS &&... __args)

template<class T , class... ARGS>
static duckdb::shared_ptr< T >	make_shared (ARGS &&... __args)

template<typename T >
constexpr T	MaxValue (T a, T b)

template<typename T >
constexpr T	MinValue (T a, T b)

template<typename T >
constexpr T	ClampValue (T v, T min, T max)
	Like std::clamp (C++17), returns v if within bounds, else nearest bound.

template<typename T >
T	AbsValue (T a)

template<class T , T val = 8, typename = typename std::enable_if<!std::is_pointer<T>::value>::type>
static T	AlignValue (T n)
	Align value (ceiling) (not for pointer types)

template<class T >
static T	AlignValue (T n, T val)

template<uintptr_t alignment, class T >
T *	AlignPointer (T *addr)

template<class T , T val = 8>
constexpr T	AlignValueFloor (T n)

template<class T , T val = 8>
static bool	ValueIsAligned (T n)

template<typename T >
T	SignValue (T a)

template<typename T >
const T	Load (const_data_ptr_t ptr)

template<typename T >
const T	LoadLE (const_data_ptr_t ptr)

template<typename T >
void	Store (const T &val, data_ptr_t ptr)

template<class T >
void	AssignSharedPointer (shared_ptr< T > &target, const shared_ptr< T > &source)

template<class T >
bool	RefersToSameObject (const reference< T > &a, const reference< T > &b)
	Returns whether or not two reference wrappers refer to the same object.

template<class T >
bool	RefersToSameObject (const T &a, const T &b)

template<class T , class SRC >
void	DynamicCastCheck (const SRC *source)

template<class T , typename... ARGS>
buffer_ptr< T >	make_buffer (ARGS &&...args)

DUCKDB_API string	LogicalTypeIdToString (LogicalTypeId type)

DUCKDB_API LogicalTypeId	TransformStringToLogicalTypeId (const string &str)

DUCKDB_API LogicalType	TransformStringToLogicalType (const string &str, ClientContext &context)

DUCKDB_API string	TypeIdToString (PhysicalType type)

DUCKDB_API idx_t	GetTypeIdSize (PhysicalType type)

DUCKDB_API bool	TypeIsConstantSize (PhysicalType type)

DUCKDB_API bool	TypeIsIntegral (PhysicalType type)

DUCKDB_API bool	TypeIsNumeric (PhysicalType type)

DUCKDB_API bool	TypeIsInteger (PhysicalType type)

bool	ApproxEqual (float l, float r)

bool	ApproxEqual (double l, double r)

template<class TO , class FROM >
static void	ThrowNumericCastError (FROM in, TO minval, TO maxval)

template<class TO , class FROM , class = typename std::enable_if<(NumericLimits<TO>::IsIntegral() && NumericLimits<FROM>::IsIntegral()) \|\| std::is_same<TO, FROM>::value>::type>
TO	NumericCast (FROM val)

template<class TO , class FROM , class = typename std::enable_if<(NumericLimits<TO>::IsIntegral() && NumericLimits<FROM>::IsIntegral()) \|\| std::is_same<TO, FROM>::value>::type>
TO	UnsafeNumericCast (FROM in)

template<class TO , class FROM >
TO	LossyNumericCast (FROM val)

template<class TO >
TO	ExactNumericCast (double val)

template<class TO >
TO	ExactNumericCast (float val)

hash_t	CombineHash (hash_t left, hash_t right)
	Combine two hashes by XORing them.

hash_t	MurmurHash64 (uint64_t x)

hash_t	MurmurHash32 (uint32_t x)

template<class T >
hash_t	Hash (T value)

template<>
DUCKDB_API hash_t	Hash (uint64_t val)

template<>
DUCKDB_API hash_t	Hash (int64_t val)

template<>
DUCKDB_API hash_t	Hash (hugeint_t val)

template<>
DUCKDB_API hash_t	Hash (uhugeint_t val)

template<>
DUCKDB_API hash_t	Hash (float val)

template<>
DUCKDB_API hash_t	Hash (double val)

template<>
DUCKDB_API hash_t	Hash (const char *val)

template<>
DUCKDB_API hash_t	Hash (char *val)

template<>
DUCKDB_API hash_t	Hash (string_t val)

template<>
DUCKDB_API hash_t	Hash (interval_t val)

template<>
DUCKDB_API hash_t	Hash (dtime_tz_t val)

DUCKDB_API hash_t	Hash (const char *val, size_t size)

DUCKDB_API hash_t	Hash (uint8_t *val, size_t size)

bool	operator== (const std::string &lhs, const String &rhs)

bool	operator== (const char *lhs, const String &rhs)

string	VectorTypeToString (VectorType type)

template<class T >
T *	AllocateArray (idx_t size)

template<class T >
void	DeleteArray (T *ptr, idx_t size)

template<typename T , typename... ARGS>
T *	AllocateObject (ARGS &&... args)

template<typename T >
void	DestroyObject (T *ptr)

string	GetDuckDBVersions (const idx_t version_number)

optional_idx	GetStorageVersion (const char *version_string)

string	GetStorageVersionName (const idx_t serialization_version, const bool add_suffix)

optional_idx	GetSerializationVersion (const char *version_string)

vector< string >	GetSerializationCandidates ()

template<class T >
PhysicalType	GetTypeId ()
	Returns the PhysicalType for the given type.

template<class T >
bool	StorageTypeCompatible (PhysicalType type)

template<class T >
bool	TypeIsNumber ()

template<class T >
bool	IsValidType ()

template<class T >
bool	IsIntegerType ()

const char *	ToString (ResultModifierType value)

ResultModifierType	ResultModifierFromString (const char *value)

bool	ExtractSourceResultType (AsyncResultType in, SourceResultType &out)

const char *	ToString (JoinRefType value)

static string	CreateRelationAlias (RelationType type, const string &alias)

string	SampleMethodToString (SampleMethod method)

duckdb_type	LogicalTypeIdToC (const LogicalTypeId type)

LogicalTypeId	LogicalTypeIdFromC (const duckdb_type type)

idx_t	GetCTypeSize (const duckdb_type type)

duckdb_statement_type	StatementTypeToC (const StatementType type)

duckdb_error_type	ErrorTypeToC (const ExceptionType type)

ExceptionType	ErrorTypeFromC (const duckdb_error_type type)

duckdb_state	DuckDBTranslateResult (unique_ptr< QueryResult > result, duckdb_result *out)

bool	DeprecatedMaterializeResult (duckdb_result *result)

vector< string >	GetCopyFunctionReturnNames (CopyFunctionReturnType return_type)

vector< LogicalType >	GetCopyFunctionReturnLogicalTypes (CopyFunctionReturnType return_type)

Variables
static constexpr ExtensionFunctionEntry	EXTENSION_FUNCTIONS []

static constexpr ExtensionFunctionOverloadEntry	EXTENSION_FUNCTION_OVERLOADS []

static constexpr ExtensionEntry	EXTENSION_SETTINGS []

static constexpr ExtensionEntry	EXTENSION_SECRET_TYPES []

static constexpr ExtensionEntry	EXTENSION_COPY_FUNCTIONS []

static constexpr ExtensionEntry	EXTENSION_TYPES []

static constexpr ExtensionEntry	EXTENSION_COLLATIONS []

static constexpr ExtensionEntry	EXTENSION_FILE_PREFIXES []

static constexpr ExtensionEntry	EXTENSION_FILE_POSTFIXES []

static constexpr ExtensionEntry	EXTENSION_FILE_CONTAINS []

static constexpr ExtensionEntry	EXTENSION_SECRET_PROVIDERS []

static constexpr const char *	AUTOLOADABLE_EXTENSIONS []

static const DefaultMacro	internal_macros []

static const DefaultSchema	internal_schemas [] = {{"information_schema"}, {"pg_catalog"}, {nullptr}}

static const DefaultTableMacro	internal_table_macros []

static const DefaultView	internal_views []

constexpr const char	str_nil [4] = {'\200', '\0', '\0', '\0'}
	This could be two bytes but then GCC gives a warning when it's copied.

const row_t	MAX_ROW_ID = 36028797018960000ULL
	The maximum row identifier used in tables.

const row_t	MAX_ROW_ID_LOCAL = 72057594037920000ULL
	Transaction-local row IDs start at MAX_ROW_ID.

const column_t	COLUMN_IDENTIFIER_ROW_ID = UINT64_C(18446744073709551615)
	Special value used to signify the ROW ID of a table.

const column_t	COLUMN_IDENTIFIER_EMPTY = UINT64_C(18446744073709551614)
	Special value used to signify an empty column (used for e.g. COUNT(*))

const column_t	VIRTUAL_COLUMN_START = UINT64_C(9223372036854775808)

const double	PI = 3.141592653589793

const transaction_t	TRANSACTION_ID_START = 4611686018427388000ULL

const transaction_t	MAX_TRANSACTION_ID = NumericLimits<transaction_t>::Maximum()

const transaction_t	NOT_DELETED_ID = NumericLimits<transaction_t>::Maximum() - 1

const transaction_t	MAXIMUM_QUERY_ID = NumericLimits<transaction_t>::Maximum()

static constexpr EncryptionTypes::EncryptionVersion	MAX_VERSION = EncryptionTypes::V0_1

static constexpr uint64_t	TEMPORARY_BUFFER_SIZE_GRANULARITY = 32ULL * 1024ULL

static const DefaultOptimizerType	internal_optimizer_types []

static constexpr ExceptionEntry	EXCEPTION_MAP []

static constexpr const uint8_t	GZIP_COMPRESSION_DEFLATE = 0x08

static constexpr const uint8_t	GZIP_FLAG_ASCII = 0x1

static constexpr const uint8_t	GZIP_FLAG_MULTIPART = 0x2

static constexpr const uint8_t	GZIP_FLAG_EXTRA = 0x4

static constexpr const uint8_t	GZIP_FLAG_NAME = 0x8

static constexpr const uint8_t	GZIP_FLAG_COMMENT = 0x10

static constexpr const uint8_t	GZIP_FLAG_ENCRYPT = 0x20

static constexpr const uint8_t	GZIP_HEADER_MINSIZE = 10

static constexpr const idx_t	GZIP_HEADER_MAXSIZE = 1u << 15

static constexpr const uint8_t	GZIP_FOOTER_SIZE = 8

static constexpr const unsigned char	GZIP_FLAG_UNSUPPORTED

const PhysicalType	ROW_TYPE
	The PhysicalType used by the row identifiers column.

static constexpr idx_t	FILE_BUFFER_TYPE_COUNT = 4

const uint64_t	VERSION_NUMBER
	The version number default, lower and upper bounds of the database storage format.

const uint64_t	VERSION_NUMBER_LOWER

const uint64_t	VERSION_NUMBER_UPPER

const field_id_t	MESSAGE_TERMINATOR_FIELD_ID = 0xFFFF

static constexpr const idx_t	MEMORY_TAG_COUNT = static_cast<idx_t>(MemoryTag::UNKNOWN)

Detailed Description

The SelectStatement of the view.

Here we have the internal duckdb classes that interact with Arrow's Internal Header (i.e., duckdb/commons/arrow.hpp)

Typedef Documentation

◆ compression_init_analyze_t

typedef unique_ptr< AnalyzeState >(* duckdb::compression_init_analyze_t) (ColumnData &col_data, PhysicalType type)

The system then decides which compression function to use based on the analyzed score (returned from final_analyze)

The analyze functions are used to determine whether or not to use this compression method The system first determines the potential compression methods to use based on the physical type of the column After that the following steps are taken:

The init_analyze is called to initialize the analyze state of every candidate compression method
The analyze method is called with all of the input data in the order in which it must be stored. analyze can return "false". In that case, the compression method is taken out of consideration early.
The final_analyze method is called, which should return a score for the compression method

◆ compression_skip_t

typedef void(* duckdb::compression_skip_t) (ColumnSegment &segment, ColumnScanState &state, idx_t skip_count)

Function prototype used for skipping 'skip_count' values, non-trivial if random-access is not supported for the compressed data.

Enumeration Type Documentation

◆ CatalogSetPathType

enum class duckdb::CatalogSetPathType

strong

50{ SET_SCHEMA, SET_SCHEMAS, SET_DIRECTLY };

◆ CollationType

enum class duckdb::CollationType

strong

1036{ ALL_COLLATIONS, COMBINABLE_COLLATIONS };

◆ BindingType

enum class duckdb::BindingType

strongprotected

1290{ BASE, TABLE, DUMMY, CATALOG_ENTRY, CTE };

◆ CTEType

enum class duckdb::CTEType

strongprotected

1421{ CAN_BE_REFERENCED, CANNOT_BE_REFERENCED };

◆ ColumnBindType

enum class duckdb::ColumnBindType

strongprivate

1479{ EXPAND_GENERATED_COLUMNS, DO_NOT_EXPAND_GENERATED_COLUMNS };

◆ StarExpressionType

enum class duckdb::StarExpressionType : uint8_t

strong

1694: uint8_t { STAR, COLUMNS, UNPACKED, NONE };

uint8_t

::uint8_t uint8_t

◆ BindingMode

enum class duckdb::BindingMode : uint8_t

strong

                       : uint8_t {
    STANDARD_BINDING,
    EXTRACT_NAMES,
    EXTRACT_REPLACEMENT_SCANS,
    EXTRACT_QUALIFIED_NAMES
};

8892: uint8_t { SUBJECT, DEPENDENT };

◆ UndoFlags

enum class duckdb::UndoFlags : uint32_t

strong

                     : uint32_t { // far too big but aligned (TM)
    EMPTY_ENTRY = 0,
    CATALOG_ENTRY = 1,
    INSERT_TUPLE = 2,
    DELETE_TUPLE = 3,
    UPDATE_TUPLE = 4,
    SEQUENCE_VALUE = 5,
    ATTACHED_DATABASE = 6
};

◆ ActiveTransactionState

enum class duckdb::ActiveTransactionState

strong

9971{ UNSET, OTHER_TRANSACTIONS, NO_OTHER_TRANSACTIONS };

◆ WALType

enum class duckdb::WALType : uint8_t

strong

                   : uint8_t {
    INVALID = 0,
    // -----------------------------
    // Catalog
    // -----------------------------
    CREATE_TABLE = 1,
    DROP_TABLE = 2,
 
    CREATE_SCHEMA = 3,
    DROP_SCHEMA = 4,
 
    CREATE_VIEW = 5,
    DROP_VIEW = 6,
 
    CREATE_SEQUENCE = 8,
    DROP_SEQUENCE = 9,
    SEQUENCE_VALUE = 10,
 
    CREATE_MACRO = 11,
    DROP_MACRO = 12,
 
    CREATE_TYPE = 13,
    DROP_TYPE = 14,
 
    ALTER_INFO = 20,
 
    CREATE_TABLE_MACRO = 21,
    DROP_TABLE_MACRO = 22,
 
    CREATE_INDEX = 23,
    DROP_INDEX = 24,
 
    // -----------------------------
    // Data
    // -----------------------------
    USE_TABLE = 25,
    INSERT_TUPLE = 26,
    DELETE_TUPLE = 27,
    UPDATE_TUPLE = 28,
    ROW_GROUP_DATA = 29,
    // -----------------------------
    // Flush
    // -----------------------------
    WAL_VERSION = 98,
    CHECKPOINT = 99,
    WAL_FLUSH = 100
};

                                         : uint8_t {
    INVALID = 0,
    SRID = 1,
    AUTH_CODE = 2,
    PROJJSON = 3,
    WKT2_2019 = 4,
};

◆ ExtraTypeInfoType

enum class duckdb::ExtraTypeInfoType : uint8_t

strongprivate

Extra Type Info Type.

                             : uint8_t {
    INVALID_TYPE_INFO = 0,
    GENERIC_TYPE_INFO = 1,
    DECIMAL_TYPE_INFO = 2,
    STRING_TYPE_INFO = 3,
    LIST_TYPE_INFO = 4,
    STRUCT_TYPE_INFO = 5,
    ENUM_TYPE_INFO = 6,
    UNBOUND_TYPE_INFO = 7,
    AGGREGATE_STATE_TYPE_INFO = 8,
    ARRAY_TYPE_INFO = 9,
    ANY_TYPE_INFO = 10,
    INTEGER_LITERAL_TYPE_INFO = 11,
    TEMPLATE_TYPE_INFO = 12,
    GEO_TYPE_INFO = 13,
};

◆ AbsoluteNumberComparison

enum duckdb::AbsoluteNumberComparison : uint8_t

                              : uint8_t {
    // If number is equal
    EQUAL = 0,
    // If compared number is greater
    GREATER = 1,
    // If compared number is smaller
    SMALLER = 2,
};

◆ CSVNewLineMode

enum class duckdb::CSVNewLineMode

strongprivate

Enumerator
WRITE_BEFORE	Newlines are written before writing out a new csv line. Ensures we don't write an empty line at the end of a csv file. Uses CSVWriterState::written_anything to keep track of when to insert newlines
WRITE_AFTER	Newlines are written after every line. This is cleanest in stdout, where lines are expected to end with a newline

                          {
    WRITE_BEFORE = 0,
    WRITE_AFTER = 1
};

◆ AggregateHandling

enum class duckdb::AggregateHandling : uint8_t

strong

                             : uint8_t {
    STANDARD_HANDLING,     // standard handling as in the SELECT clause
    NO_AGGREGATES_ALLOWED, // no aggregates allowed: any aggregates in this node will result in an error
    FORCE_AGGREGATES       // force aggregates: any non-aggregate select list entry will become a GROUP
};

◆ CheckpointAbort

enum class duckdb::CheckpointAbort : uint8_t

strong

                           : uint8_t {
    NO_ABORT = 0,
    DEBUG_ABORT_BEFORE_TRUNCATE = 1,
    DEBUG_ABORT_BEFORE_HEADER = 2,
    DEBUG_ABORT_AFTER_FREE_LIST_WRITE = 3,
    DEBUG_ABORT_BEFORE_WAL_FINISH = 4,
    DEBUG_ABORT_BEFORE_MOVING_RECOVERY = 5,
    DEBUG_ABORT_BEFORE_DELETING_CHECKPOINT_WAL = 6
};

◆ CopyOverwriteMode

enum class duckdb::CopyOverwriteMode : uint8_t

strong

                             : uint8_t {
    COPY_ERROR_ON_CONFLICT = 0,
    COPY_OVERWRITE = 1,
    COPY_OVERWRITE_OR_IGNORE = 2,
    COPY_APPEND = 3
};

◆ DatePartSpecifier

enum class duckdb::DatePartSpecifier : uint8_t

strong

                             : uint8_t {
    //  BIGINT values
    YEAR,
    MONTH,
    DAY,
    DECADE,
    CENTURY,
    MILLENNIUM,
    MICROSECONDS,
    MILLISECONDS,
    SECOND,
    MINUTE,
    HOUR,
    DOW,
    ISODOW,
    WEEK,
    ISOYEAR,
    QUARTER,
    DOY,
    YEARWEEK,
    ERA,
    TIMEZONE,
    TIMEZONE_HOUR,
    TIMEZONE_MINUTE,
 
    //  DOUBLE values
    EPOCH,
    JULIAN_DAY,
 
    //  Invalid
    INVALID,
 
    //  Type ranges
    BEGIN_BIGINT = YEAR,
    BEGIN_DOUBLE = EPOCH,
    BEGIN_INVALID = INVALID,
};

◆ DeprecatedUsingKeySyntax

enum class duckdb::DeprecatedUsingKeySyntax : uint8_t

strong

52649: uint8_t { DEFAULT = 0, UNION_AS_UNION_ALL = 1 };

◆ HTTPStatusCode

enum class duckdb::HTTPStatusCode : uint16_t

strong

                          : uint16_t {
    INVALID = 0,
    // Information responses
    Continue_100 = 100,
    SwitchingProtocol_101 = 101,
    Processing_102 = 102,
    EarlyHints_103 = 103,
 
    // Successful responses
    OK_200 = 200,
    Created_201 = 201,
    Accepted_202 = 202,
    NonAuthoritativeInformation_203 = 203,
    NoContent_204 = 204,
    ResetContent_205 = 205,
    PartialContent_206 = 206,
    MultiStatus_207 = 207,
    AlreadyReported_208 = 208,
    IMUsed_226 = 226,
 
    // Redirection messages
    MultipleChoices_300 = 300,
    MovedPermanently_301 = 301,
    Found_302 = 302,
    SeeOther_303 = 303,
    NotModified_304 = 304,
    UseProxy_305 = 305,
    unused_306 = 306,
    TemporaryRedirect_307 = 307,
    PermanentRedirect_308 = 308,
 
    // Client error responses
    BadRequest_400 = 400,
    Unauthorized_401 = 401,
    PaymentRequired_402 = 402,
    Forbidden_403 = 403,
    NotFound_404 = 404,
    MethodNotAllowed_405 = 405,
    NotAcceptable_406 = 406,
    ProxyAuthenticationRequired_407 = 407,
    RequestTimeout_408 = 408,
    Conflict_409 = 409,
    Gone_410 = 410,
    LengthRequired_411 = 411,
    PreconditionFailed_412 = 412,
    PayloadTooLarge_413 = 413,
    UriTooLong_414 = 414,
    UnsupportedMediaType_415 = 415,
    RangeNotSatisfiable_416 = 416,
    ExpectationFailed_417 = 417,
    ImATeapot_418 = 418,
    MisdirectedRequest_421 = 421,
    UnprocessableContent_422 = 422,
    Locked_423 = 423,
    FailedDependency_424 = 424,
    TooEarly_425 = 425,
    UpgradeRequired_426 = 426,
    PreconditionRequired_428 = 428,
    TooManyRequests_429 = 429,
    RequestHeaderFieldsTooLarge_431 = 431,
    UnavailableForLegalReasons_451 = 451,
 
    // Server error responses
    InternalServerError_500 = 500,
    NotImplemented_501 = 501,
    BadGateway_502 = 502,
    ServiceUnavailable_503 = 503,
    GatewayTimeout_504 = 504,
    HttpVersionNotSupported_505 = 505,
    VariantAlsoNegotiates_506 = 506,
    InsufficientStorage_507 = 507,
    LoopDetected_508 = 508,
    NotExtended_510 = 510,
    NetworkAuthenticationRequired_511 = 511,
};

◆ TupleDataValidityType

enum class duckdb::TupleDataValidityType : uint8_t

strong

                                 : uint8_t {
    CAN_HAVE_NULL_VALUES = 0,
    CANNOT_HAVE_NULL_VALUES = 1,
};

◆ TupleDataNestednessType

enum class duckdb::TupleDataNestednessType : uint8_t

strong

                                   : uint8_t {
    TOP_LEVEL_LAYOUT = 0,
    NESTED_STRUCT_LAYOUT = 1,
};

◆ WindowAggregationMode

enum class duckdb::WindowAggregationMode : uint32_t

strong

Enumerator
WINDOW	Use the window aggregate API if available.
COMBINE	Don't use window, but use combine if available.
SEPARATE	Don't use combine or window (compute each frame separately)

                                 : uint32_t {
    WINDOW = 0,
    COMBINE,
    SEPARATE
};

                       : uint8_t {
    INVALID = 0,
    NO_PAYLOAD_FIXED_8 = 1,
    NO_PAYLOAD_FIXED_16 = 2,
    NO_PAYLOAD_FIXED_24 = 3,
    NO_PAYLOAD_FIXED_32 = 4,
    NO_PAYLOAD_VARIABLE_32 = 5,
    PAYLOAD_FIXED_16 = 6,
    PAYLOAD_FIXED_24 = 7,
    PAYLOAD_FIXED_32 = 8,
    PAYLOAD_VARIABLE_32 = 9,
};

◆ ConflictManagerMode

enum class duckdb::ConflictManagerMode : uint8_t

strong

                               : uint8_t {
    SCAN, // Gather conflicts without throwing a constraint exception.
    THROW // Throw on the conflicts that were not found during the scan.
};

◆ LookupResultType

enum class duckdb::LookupResultType : uint8_t

strong

55787: uint8_t { LOOKUP_MISS, LOOKUP_HIT, LOOKUP_NULL };

◆ TupleDataPinProperties

enum class duckdb::TupleDataPinProperties : uint8_t

strong

Enumerator
KEEP_EVERYTHING_PINNED	Keeps all passed blocks pinned while scanning/iterating over the chunks (for both reading/writing)
UNPIN_AFTER_DONE	Unpins blocks after they are done (for both reading/writing)
DESTROY_AFTER_DONE	Destroys blocks after they are done (for reading only)
ALREADY_PINNED	Assumes all blocks are already pinned (for reading only)

                                  : uint8_t {
    INVALID,
    KEEP_EVERYTHING_PINNED,
    UNPIN_AFTER_DONE,
    DESTROY_AFTER_DONE,
    ALREADY_PINNED
};

◆ BlockIteratorStateType

enum class duckdb::BlockIteratorStateType : int8_t

strongprivate

Enumerator
IN_MEMORY	For InMemoryBlockIteratorState.
EXTERNAL	For ExternalBlockIteratorState.

                                  : int8_t {
    IN_MEMORY,
    EXTERNAL,
};

◆ PartitionedTupleDataType

enum class duckdb::PartitionedTupleDataType : uint8_t

strongprivate

Enumerator
RADIX	Radix partitioning on a hash column.

                                    : uint8_t {
    INVALID,
    RADIX
};

◆ VariantValueType

enum class duckdb::VariantValueType : uint8_t

strong

57764: uint8_t { PRIMITIVE, OBJECT, ARRAY, MISSING };

◆ ARTScanHandling

enum class duckdb::ARTScanHandling : uint8_t

strongprivate

                           : uint8_t {
    EMPLACE,
    POP,
};

◆ ARTScanResult

enum class duckdb::ARTScanResult : uint8_t

strong

Scanning state. The scanning output policies allow us to pass in a capacity while scanning, so that when the scan fills up the capacity, we can pause the scan state at that location, and resume scanning later.

59088: uint8_t { COMPLETED = 0, PAUSED = 1 };

◆ CSVState

enum class duckdb::CSVState : uint8_t

strong

All States of CSV parsing.

Enumerator
DELIMITER	Regular unquoted field state.
DELIMITER_FIRST_BYTE	----------— Multi-byte Delimiter States (up to 4 bytes) -------------------------------------------—!// State after encountering a field separator (e.g., ;) - This is always the last delimiter byte
DELIMITER_SECOND_BYTE	State when encountering the first delimiter byte of a multi-byte delimiter.
DELIMITER_THIRD_BYTE	State when encountering the second delimiter byte of a multi-byte delimiter.
RECORD_SEPARATOR	-----------------------------------------------------------------------------------------------------—!// State when encountering the third delimiter byte of a multi-byte delimiter
CARRIAGE_RETURN	State after encountering a record separator (i.e., )
QUOTED	State after encountering a carriage return(i.e., \r)
UNQUOTED	State when inside a quoted field.
ESCAPE	State when leaving a quoted field.
INVALID	State when encountering an escape character (e.g., )
NOT_SET	Got to an Invalid State, this should error.
QUOTED_NEW_LINE	If the state is not set, usually the first state before getting the first character.
EMPTY_SPACE	If we have a quoted newline.
COMMENT	If we have empty spaces in the beginning and end of value.
STANDARD_NEWLINE	If we are in a comment state, and hence have to skip the whole line.
UNQUOTED_ESCAPE	State used for figuring out a new line.
ESCAPED_RETURN	State when encountering an escape character (e.g., ) in an unquoted field.
MAYBE_QUOTED	State when the carriage return is preceded by an escape character (for '\r ' newline only)

                    : uint8_t {
    STANDARD = 0,  
    DELIMITER = 1, 
    DELIMITER_FIRST_BYTE = 2,  
    DELIMITER_SECOND_BYTE = 3, 
    DELIMITER_THIRD_BYTE = 4,  
    RECORD_SEPARATOR = 5,  
    CARRIAGE_RETURN = 6,   
    QUOTED = 7,            
    UNQUOTED = 8,          
    ESCAPE = 9,            
    INVALID = 10,          
    NOT_SET = 11,          
    QUOTED_NEW_LINE = 12,  
    EMPTY_SPACE = 13,      
    COMMENT = 14,          
    STANDARD_NEWLINE = 15, 
    UNQUOTED_ESCAPE = 16,  
    ESCAPED_RETURN = 17, 
    MAYBE_QUOTED = 18    
};

◆ PhysicalTableScanExecutionStrategy

enum class duckdb::PhysicalTableScanExecutionStrategy : uint8_t

strong

                                              : uint8_t {
    DEFAULT,
    TASK_EXECUTOR,
    SYNCHRONOUS,
    TASK_EXECUTOR_BUT_FORCE_SYNC_CHECKS
};

◆ CompressedMaterializationDirection

enum class duckdb::CompressedMaterializationDirection : uint8_t

strong

Needed for (de)serialization without binding.

59255: uint8_t { INVALID = 0, COMPRESS = 1, DECOMPRESS = 2 };

◆ WindowMergeSortStage

enum class duckdb::WindowMergeSortStage : uint8_t

strong

60164: uint8_t { INIT, COMBINE, FINALIZE, SORTED, FINISHED };

◆ ErrorType

enum class duckdb::ErrorType : uint16_t

strongprotected

                     : uint16_t {
    // error message types
    UNSIGNED_EXTENSION = 0,
    INVALIDATED_TRANSACTION = 1,
    INVALIDATED_DATABASE = 2,
 
    // this should always be the last value
    ERROR_COUNT,
    INVALID = 65535,
};

◆ PushdownExtractSupport

enum class duckdb::PushdownExtractSupport : uint8_t

strong

60492: uint8_t { UNCHECKED, DISABLED, ENABLED };

◆ BaseColumnPrunerMode

enum class duckdb::BaseColumnPrunerMode : uint8_t

strong

Enumerator
DISABLE_PUSHDOWN_EXTRACT	Any child reference disables PUSHDOWN_EXTRACT for the parent column.

                                : uint8_t {
    DEFAULT,
    DISABLE_PUSHDOWN_EXTRACT
};

◆ MetaPipelineType

enum class duckdb::MetaPipelineType : uint8_t

strong

Enumerator
JOIN_BUILD	The shared sink is regular.

                            : uint8_t {
    REGULAR = 0,   
    JOIN_BUILD = 1 
};

◆ PreparedParamType

enum class duckdb::PreparedParamType : uint8_t

strongprivate

60769: uint8_t { AUTO_INCREMENT, POSITIONAL, NAMED, INVALID };

◆ WindowBoundary

enum class duckdb::WindowBoundary : uint8_t

strong

                          : uint8_t {
    INVALID = 0,
    UNBOUNDED_PRECEDING = 1,
    UNBOUNDED_FOLLOWING = 2,
    CURRENT_ROW_RANGE = 3,
    CURRENT_ROW_ROWS = 4,
    EXPR_PRECEDING_ROWS = 5,
    EXPR_FOLLOWING_ROWS = 6,
    EXPR_PRECEDING_RANGE = 7,
    EXPR_FOLLOWING_RANGE = 8,
    CURRENT_ROW_GROUPS = 9,
    EXPR_PRECEDING_GROUPS = 10,
    EXPR_FOLLOWING_GROUPS = 11
};

◆ WindowExcludeMode

enum class duckdb::WindowExcludeMode : uint8_t

enum class duckdb::DataFileType : uint8_t

strong

                        : uint8_t {
    FILE_DOES_NOT_EXIST, // file does not exist
    DUCKDB_FILE,         // duckdb database file
    SQLITE_FILE,         // sqlite database file
    PARQUET_FILE,        // parquet file
    UNKNOWN_FILE         // unknown file type
};

◆ TemporaryBufferSize

enum class duckdb::TemporaryBufferSize : uint64_t

strong

                               : uint64_t {
    INVALID = 0,
    S32K = 32768,
    S64K = 65536,
    S96K = 98304,
    S128K = 131072,
    S160K = 163840,
    S192K = 196608,
    S224K = 229376,
    DEFAULT = DEFAULT_BLOCK_ALLOC_SIZE,
};

◆ TemporaryCompressionLevel

enum class duckdb::TemporaryCompressionLevel : int

strong

                                     : int {
    ZSTD_MINUS_FIVE = -5,
    ZSTD_MINUS_THREE = -3,
    ZSTD_MINUS_ONE = -1,
    UNCOMPRESSED = 0,
    ZSTD_ONE = 1,
    ZSTD_THREE = 3,
    ZSTD_FIVE = 5,
};

◆ VerificationType

enum class duckdb::VerificationType : uint8_t

strongprivate

                            : uint8_t {
    ORIGINAL,
    COPIED,
    DESERIALIZED,
    PARSED,
    UNOPTIMIZED,
    NO_OPERATOR_CACHING,
    PREPARED,
    EXTERNAL,
    EXPLAIN,
    FETCH_ROW_AS_SCAN,
 
    INVALID
};

◆ FetchType

enum class duckdb::FetchType

strong

Enumerator
TRANSACTIONAL_FETCH	Verify if each row is valid for the transaction prior to fetching.

                     {
    TRANSACTIONAL_FETCH,
    // Force fetch the row, regardless of it if is valid for the transaction or not
    FORCE_FETCH
};

◆ MiniZStreamType

enum class duckdb::MiniZStreamType

strong

77138{ MINIZ_TYPE_NONE, MINIZ_TYPE_INFLATE, MINIZ_TYPE_DEFLATE };

◆ ReaderInitializeType

enum class duckdb::ReaderInitializeType

strong

80649{ INITIALIZED, SKIP_READING_FILE };

◆ ExceptionFormatValueType

enum class duckdb::ExceptionFormatValueType : uint8_t

strong

                                    : uint8_t {
    FORMAT_VALUE_TYPE_DOUBLE,
    FORMAT_VALUE_TYPE_INTEGER,
    FORMAT_VALUE_TYPE_STRING
};

◆ ExceptionType

enum class duckdb::ExceptionType : uint8_t

strong

                         : uint8_t {
    INVALID = 0,          // invalid type
    OUT_OF_RANGE = 1,     // value out of range error
    CONVERSION = 2,       // conversion/casting error
    UNKNOWN_TYPE = 3,     // unknown type
    DECIMAL = 4,          // decimal related
    MISMATCH_TYPE = 5,    // type mismatch
    DIVIDE_BY_ZERO = 6,   // divide by 0
    OBJECT_SIZE = 7,      // object size exceeded
    INVALID_TYPE = 8,     // incompatible for operation
    SERIALIZATION = 9,    // serialization
    TRANSACTION = 10,     // transaction management
    NOT_IMPLEMENTED = 11, // method not implemented
    EXPRESSION = 12,      // expression parsing
    CATALOG = 13,         // catalog related
    PARSER = 14,          // parser related
    PLANNER = 15,         // planner related
    SCHEDULER = 16,       // scheduler related
    EXECUTOR = 17,        // executor related
    CONSTRAINT = 18,      // constraint related
    INDEX = 19,           // index related
    STAT = 20,            // stat related
    CONNECTION = 21,      // connection related
    SYNTAX = 22,          // syntax related
    SETTINGS = 23,        // settings related
    BINDER = 24,          // binder related
    NETWORK = 25,         // network related
    OPTIMIZER = 26,       // optimizer related
    NULL_POINTER = 27,    // nullptr exception
    IO = 28,              // IO exception
    INTERRUPT = 29,       // interrupt
    FATAL = 30,           // Fatal exceptions are non-recoverable, and render the entire DB in an unusable state
    INTERNAL = 31,        // Internal exceptions indicate something went wrong internally (i.e. bug in the code base)
    INVALID_INPUT = 32,   // Input or arguments error
    OUT_OF_MEMORY = 33,   // out of memory
    PERMISSION = 34,      // insufficient permissions
    PARAMETER_NOT_RESOLVED = 35, // parameter types could not be resolved
    PARAMETER_NOT_ALLOWED = 36,  // parameter types not allowed
    DEPENDENCY = 37,             // dependency
    HTTP = 38,
    MISSING_EXTENSION = 39, // Thrown when an extension is used but not loaded
    AUTOLOAD = 40,          // Thrown when an extension is used but not loaded
    SEQUENCE = 41,
    INVALID_CONFIGURATION =
        42 // An invalid configuration was detected (e.g. a Secret param was missing, or a required setting not found)
};

◆ ProfilerPrintFormat

enum class duckdb::ProfilerPrintFormat : uint8_t

strong

1171: uint8_t { QUERY_TREE, JSON, QUERY_TREE_OPTIMIZER, NO_OUTPUT, HTML, GRAPHVIZ, MERMAID };

◆ CatalogType

enum class duckdb::CatalogType : uint8_t

strong

                       : uint8_t {
    INVALID = 0,
    TABLE_ENTRY = 1,
    SCHEMA_ENTRY = 2,
    VIEW_ENTRY = 3,
    INDEX_ENTRY = 4,
    PREPARED_STATEMENT = 5,
    SEQUENCE_ENTRY = 6,
    COLLATION_ENTRY = 7,
    TYPE_ENTRY = 8,
    DATABASE_ENTRY = 9,
    COORDINATE_SYSTEM_ENTRY = 10,
 
    // functions
    TABLE_FUNCTION_ENTRY = 25,
    SCALAR_FUNCTION_ENTRY = 26,
    AGGREGATE_FUNCTION_ENTRY = 27,
    PRAGMA_FUNCTION_ENTRY = 28,
    COPY_FUNCTION_ENTRY = 29,
    MACRO_ENTRY = 30,
    TABLE_MACRO_ENTRY = 31,
 
    // version info
    DELETED_ENTRY = 51,
    RENAMED_ENTRY = 52,
 
    // secrets
    SECRET_ENTRY = 71,
    SECRET_TYPE_ENTRY = 72,
    SECRET_FUNCTION_ENTRY = 73,
 
    // dependency info
    DEPENDENCY_ENTRY = 100
 
};

◆ PhysicalType

enum class duckdb::PhysicalType : uint8_t

strong

Enumerator
BOOL	Boolean as 8 bit "bool" value.
UINT8	Unsigned 8-bit little-endian integer.
INT8	Signed 8-bit little-endian integer.
UINT16	Unsigned 16-bit little-endian integer.
INT16	Signed 16-bit little-endian integer.
UINT32	Unsigned 32-bit little-endian integer.
INT32	Signed 32-bit little-endian integer.
UINT64	Unsigned 64-bit little-endian integer.
INT64	Signed 64-bit little-endian integer.
FLOAT	4-byte floating point value
DOUBLE	8-byte floating point value
INTERVAL	YEAR_MONTH or DAY_TIME interval in SQL style.
LIST	A list of some logical data type. Precision- and scale-based decimal type. Storage type depends on the parameters.
STRUCT	Struct of logical types.
VARCHAR	DuckDB Extensions.
BIT	Boolean as 1 bit, LSB bit-packed ordering.

                        : uint8_t {
    // NA = 0,
 
    BOOL = 1,
 
    UINT8 = 2,
 
    INT8 = 3,
 
    UINT16 = 4,
 
    INT16 = 5,
 
    UINT32 = 6,
 
    INT32 = 7,
 
    UINT64 = 8,
 
    INT64 = 9,
 
    // HALF_FLOAT = 10,
 
    FLOAT = 11,
 
    DOUBLE = 12,
 
    // STRING = 13,
 
    // BINARY = 14,
 
    // FIXED_SIZE_BINARY = 15,
 
    // DATE32 = 16,
 
    // DATE64 = 17,
 
    // TIMESTAMP = 18,
 
    // TIME32 = 19,
 
    // TIME64 = 20,
 
    INTERVAL = 21,
 
    // DECIMAL = 22,
 
    LIST = 23,
 
    STRUCT = 24,
 
    // UNION = 25,
 
    // DICTIONARY = 26,
 
    // EXTENSION = 28,
 
    ARRAY = 29,
 
    // DURATION = 30,
 
    // LARGE_STRING = 31,
 
    // LARGE_BINARY = 32,
 
    // LARGE_LIST = 33,
 
    VARCHAR = 200, // our own string representation, different from STRING and LARGE_STRING above
    UINT128 = 203, // 128-bit unsigned integers
    INT128 = 204, // 128-bit integers
    UNKNOWN = 205, // Unknown physical type of user defined types
    BIT = 206,
 
    INVALID = 255
};

◆ LogicalTypeId

enum class duckdb::LogicalTypeId : uint8_t

strong

Enumerator
TIMESTAMP_NS	us

                         : uint8_t {
    INVALID = 0,
    SQLNULL = 1, /* NULL type, used for constant NULL */
    UNKNOWN = 2, /* unknown type, used for parameter expressions */
    ANY = 3,     /* ANY type, used for functions that accept any type as parameter */
    UNBOUND = 4,    /* A parsed but unbound type, used during query planning */
 
    // A "template" type functions as a "placeholder" type for function arguments and return types.
    // Templates only exist during the binding phase, in the scope of a function, and are replaced with concrete types
    // before execution. When defining a template, you provide a name to distinguish between different template types,
    // specifying to the binder that they dont need to resolve to the same concrete type. Two templates with the same
    // name are always resolved to the same concrete type.
    TEMPLATE = 5,
 
    TYPE = 6,    /* Type type, used for type parameters */
 
    BOOLEAN = 10,
    TINYINT = 11,
    SMALLINT = 12,
    INTEGER = 13,
    BIGINT = 14,
    DATE = 15,
    TIME = 16,
    TIMESTAMP_SEC = 17,
    TIMESTAMP_MS = 18,
    TIMESTAMP = 19, 
    TIMESTAMP_NS = 20,
    DECIMAL = 21,
    FLOAT = 22,
    DOUBLE = 23,
    CHAR = 24,
    VARCHAR = 25,
    BLOB = 26,
    INTERVAL = 27,
    UTINYINT = 28,
    USMALLINT = 29,
    UINTEGER = 30,
    UBIGINT = 31,
    TIMESTAMP_TZ = 32,
    TIME_TZ = 34,
    TIME_NS = 35,
    BIT = 36,
    STRING_LITERAL = 37, /* string literals, used for constant strings - only exists while binding */
    INTEGER_LITERAL = 38,/* integer literals, used for constant integers - only exists while binding */
    BIGNUM = 39,
    UHUGEINT = 49,
    HUGEINT = 50,
    POINTER = 51,
    VALIDITY = 53,
    UUID = 54,
 
    GEOMETRY = 60,
 
    STRUCT = 100,
    LIST = 101,
    MAP = 102,
    TABLE = 103,
    ENUM = 104,
    AGGREGATE_STATE = 105,
    LAMBDA = 106,
    UNION = 107,
    ARRAY = 108,
    VARIANT = 109
};

◆ ComplexJSONType

enum class duckdb::ComplexJSONType : uint8_t

strongprivate

3695: uint8_t { VALUE = 0, OBJECT = 1, ARRAY = 2 };

◆ TimestampCastResult

enum class duckdb::TimestampCastResult : uint8_t

strong

                               : uint8_t {
    SUCCESS,
    ERROR_INCORRECT_FORMAT,
    ERROR_NON_UTC_TIMEZONE,
    ERROR_RANGE,
    STRICT_UTC
};

◆ DateCastResult

enum class duckdb::DateCastResult : uint8_t

strong

5006: uint8_t { SUCCESS, ERROR_INCORRECT_FORMAT, ERROR_RANGE };

◆ CatalogLookupBehavior

enum class duckdb::CatalogLookupBehavior : uint8_t

enum class duckdb::CachingMode : uint8_t

strong

Caching mode for CachingFileSystemWrapper. By default only remote files will be cached, but it's also allowed to cache local for direct IO use case.

                       : uint8_t {
    // Cache all files.
    ALWAYS_CACHE = 0,
    // Only cache remote files, bypass cache for local files.
    CACHE_REMOTE_ONLY = 1,
    // Doesn't perform caching.
    NO_CACHING = 2,
};

◆ FileLockType

enum class duckdb::FileLockType : uint8_t

strong

7718: uint8_t { NO_LOCK = 0, READ_LOCK = 1, WRITE_LOCK = 2 };

◆ FileType

enum class duckdb::FileType

strongprivate

Enumerator
FILE_TYPE_REGULAR	Regular file.
FILE_TYPE_DIR	Directory.
FILE_TYPE_FIFO	FIFO named pipe.
FILE_TYPE_SOCKET	Socket.
FILE_TYPE_LINK	Symbolic link.
FILE_TYPE_BLOCKDEV	Block device.
FILE_TYPE_CHARDEV	Character device.
FILE_TYPE_INVALID	Unknown or invalid file handle.

                    {
    FILE_TYPE_REGULAR,
    FILE_TYPE_DIR,
    FILE_TYPE_FIFO,
    FILE_TYPE_SOCKET,
    FILE_TYPE_LINK,
    FILE_TYPE_BLOCKDEV,
    FILE_TYPE_CHARDEV,
    FILE_TYPE_INVALID,
};

◆ VectorType

enum class duckdb::VectorType : uint8_t

strong

                      : uint8_t {
    FLAT_VECTOR,       // Flat vectors represent a standard uncompressed vector
    FSST_VECTOR,       // Contains string data compressed with FSST
    CONSTANT_VECTOR,   // Constant vector represents a single constant
    DICTIONARY_VECTOR, // Dictionary vector represents a selection vector on top of another vector
    SEQUENCE_VECTOR    // Sequence vector represents a sequence with a start point and an increment
};

◆ AllocatorFreeType

enum class duckdb::AllocatorFreeType

strong

8575{ REQUIRES_FREE, DOES_NOT_REQUIRE_FREE };

◆ VectorBufferType

enum class duckdb::VectorBufferType : uint8_t

strongprivate

                            : uint8_t {
    STANDARD_BUFFER,     // standard buffer, holds a single array of data
    DICTIONARY_BUFFER,   // dictionary buffer, holds a selection vector
    VECTOR_CHILD_BUFFER, // vector child buffer: holds another vector
    STRING_BUFFER,       // string buffer, holds a string heap
    FSST_BUFFER,         // fsst compressed string buffer, holds a string heap, fsst symbol table and a string count
    STRUCT_BUFFER,       // struct buffer, holds a ordered mapping from name to child vector
    LIST_BUFFER,         // list buffer, holds a single flatvector child
    MANAGED_BUFFER,      // managed buffer, holds a buffer managed by the buffermanager
    OPAQUE_BUFFER,       // opaque buffer, can be created for example by the parquet reader
    ARRAY_BUFFER         // array buffer, holds a single flatvector child
};

◆ VectorAuxiliaryDataType

enum class duckdb::VectorAuxiliaryDataType : uint8_t

strongprivate

                                   : uint8_t {
    ARROW_AUXILIARY // Holds Arrow Chunks that this vector depends on
};

◆ MapInvalidReason

enum class duckdb::MapInvalidReason : uint8_t

strong

11082: uint8_t { VALID, NULL_KEY, DUPLICATE_KEY, NOT_ALIGNED, INVALID_PARAMS };

◆ UnionInvalidReason

enum class duckdb::UnionInvalidReason : uint8_t

strong

                              : uint8_t {
    VALID,
    TAG_OUT_OF_RANGE,
    NO_MEMBERS,
    VALIDITY_OVERLAP,
    TAG_MISMATCH,
    NULL_TAG
};

◆ FunctionErrors

enum class duckdb::FunctionErrors : uint8_t

strong

Whether or not a function can throw an error or not.

12540: uint8_t { CANNOT_ERROR = 0, CAN_THROW_RUNTIME_ERROR = 1 };

◆ ExpressionType

enum class duckdb::ExpressionType : uint8_t

strongprivate

                          : uint8_t {
    INVALID = 0,
 
    // explicitly cast left as right (right is integer in ValueType enum)
    OPERATOR_CAST = 12,
    // logical not operator
    OPERATOR_NOT = 13,
    // is null operator
    OPERATOR_IS_NULL = 14,
    // is not null operator
    OPERATOR_IS_NOT_NULL = 15,
    // unpack operator
    OPERATOR_UNPACK = 16,
 
    // -----------------------------
    // Comparison Operators
    // -----------------------------
    // equal operator between left and right
    COMPARE_EQUAL = 25,
    // compare initial boundary
    COMPARE_BOUNDARY_START = COMPARE_EQUAL,
    // inequal operator between left and right
    COMPARE_NOTEQUAL = 26,
    // less than operator between left and right
    COMPARE_LESSTHAN = 27,
    // greater than operator between left and right
    COMPARE_GREATERTHAN = 28,
    // less than equal operator between left and right
    COMPARE_LESSTHANOREQUALTO = 29,
    // greater than equal operator between left and right
    COMPARE_GREATERTHANOREQUALTO = 30,
    // IN operator [left IN (right1, right2, ...)]
    COMPARE_IN = 35,
    // NOT IN operator [left NOT IN (right1, right2, ...)]
    COMPARE_NOT_IN = 36,
    // IS DISTINCT FROM operator
    COMPARE_DISTINCT_FROM = 37,
 
    COMPARE_BETWEEN = 38,
    COMPARE_NOT_BETWEEN = 39,
    // IS NOT DISTINCT FROM operator
    COMPARE_NOT_DISTINCT_FROM = 40,
    // compare final boundary
    COMPARE_BOUNDARY_END = COMPARE_NOT_DISTINCT_FROM,
 
    // -----------------------------
    // Conjunction Operators
    // -----------------------------
    CONJUNCTION_AND = 50,
    CONJUNCTION_OR = 51,
 
    // -----------------------------
    // Values
    // -----------------------------
    VALUE_CONSTANT = 75,
    VALUE_PARAMETER = 76,
    VALUE_TUPLE = 77,
    VALUE_TUPLE_ADDRESS = 78,
    VALUE_NULL = 79,
    VALUE_VECTOR = 80,
    VALUE_SCALAR = 81,
    VALUE_DEFAULT = 82,
 
    // -----------------------------
    // Aggregates
    // -----------------------------
    AGGREGATE = 100,
    BOUND_AGGREGATE = 101,
    GROUPING_FUNCTION = 102,
 
    // -----------------------------
    // Window Functions
    // -----------------------------
    WINDOW_AGGREGATE = 110,
 
    WINDOW_RANK = 120,
    WINDOW_RANK_DENSE = 121,
    WINDOW_NTILE = 122,
    WINDOW_PERCENT_RANK = 123,
    WINDOW_CUME_DIST = 124,
    WINDOW_ROW_NUMBER = 125,
 
    WINDOW_FIRST_VALUE = 130,
    WINDOW_LAST_VALUE = 131,
    WINDOW_LEAD = 132,
    WINDOW_LAG = 133,
    WINDOW_NTH_VALUE = 134,
    WINDOW_FILL = 135,
 
    // -----------------------------
    // Functions
    // -----------------------------
    FUNCTION = 140,
    BOUND_FUNCTION = 141,
 
    // -----------------------------
    // Operators
    // -----------------------------
    CASE_EXPR = 150,
    OPERATOR_NULLIF = 151,
    OPERATOR_COALESCE = 152,
    ARRAY_EXTRACT = 153,
    ARRAY_SLICE = 154,
    STRUCT_EXTRACT = 155,
    ARRAY_CONSTRUCTOR = 156,
    ARROW = 157,
    OPERATOR_TRY = 158,
 
    // -----------------------------
    // Subquery IN/EXISTS
    // -----------------------------
    SUBQUERY = 175,
 
    // -----------------------------
    // Parser
    // -----------------------------
    STAR = 200,
    TABLE_STAR = 201,
    PLACEHOLDER = 202,
    COLUMN_REF = 203,
    FUNCTION_REF = 204,
    TABLE_REF = 205,
    LAMBDA_REF = 206,
    TYPE = 207,
 
    // -----------------------------
    // Miscellaneous
    // -----------------------------
    CAST = 225,
    BOUND_REF = 227,
    BOUND_COLUMN_REF = 228,
    BOUND_UNNEST = 229,
    COLLATE = 230,
    LAMBDA = 231,
    POSITIONAL_REFERENCE = 232,
    BOUND_LAMBDA_REF = 233,
    BOUND_EXPANDED = 234
};

◆ ExpressionClass

enum class duckdb::ExpressionClass : uint8_t

strongprivate

                           : uint8_t {
    INVALID = 0,
    //===--------------------------------------------------------------------===//
    // Parsed Expressions
    //===--------------------------------------------------------------------===//
    AGGREGATE = 1,
    CASE = 2,
    CAST = 3,
    COLUMN_REF = 4,
    COMPARISON = 5,
    CONJUNCTION = 6,
    CONSTANT = 7,
    DEFAULT = 8,
    FUNCTION = 9,
    OPERATOR = 10,
    STAR = 11,
    SUBQUERY = 13,
    WINDOW = 14,
    PARAMETER = 15,
    COLLATE = 16,
    LAMBDA = 17,
    POSITIONAL_REFERENCE = 18,
    BETWEEN = 19,
    LAMBDA_REF = 20,
    TYPE = 21,
    //===--------------------------------------------------------------------===//
    // Bound Expressions
    //===--------------------------------------------------------------------===//
    BOUND_AGGREGATE = 25,
    BOUND_CASE = 26,
    BOUND_CAST = 27,
    BOUND_COLUMN_REF = 28,
    BOUND_COMPARISON = 29,
    BOUND_CONJUNCTION = 30,
    BOUND_CONSTANT = 31,
    BOUND_DEFAULT = 32,
    BOUND_FUNCTION = 33,
    BOUND_OPERATOR = 34,
    BOUND_PARAMETER = 35,
    BOUND_REF = 36,
    BOUND_SUBQUERY = 37,
    BOUND_WINDOW = 38,
    BOUND_BETWEEN = 39,
    BOUND_UNNEST = 40,
    BOUND_LAMBDA = 41,
    BOUND_LAMBDA_REF = 42,
    //===--------------------------------------------------------------------===//
    // Miscellaneous
    //===--------------------------------------------------------------------===//
    BOUND_EXPRESSION = 50,
    BOUND_EXPANDED = 51
};

◆ SimplifiedTokenType

enum class duckdb::SimplifiedTokenType : uint8_t

strongprivate

Simplified tokens are a simplified (dense) representation of the lexer Used for simple syntax highlighting in the tests

                               : uint8_t {
    SIMPLIFIED_TOKEN_IDENTIFIER,
    SIMPLIFIED_TOKEN_NUMERIC_CONSTANT,
    SIMPLIFIED_TOKEN_STRING_CONSTANT,
    SIMPLIFIED_TOKEN_OPERATOR,
    SIMPLIFIED_TOKEN_KEYWORD,
    SIMPLIFIED_TOKEN_COMMENT,
    SIMPLIFIED_TOKEN_ERROR,
    SIMPLIFIED_TOKEN_ERROR_EMPHASIS,
    SIMPLIFIED_TOKEN_ERROR_SUGGESTION
};

◆ KeywordCategory

enum class duckdb::KeywordCategory : uint8_t

strongprivate

                           : uint8_t {
    KEYWORD_RESERVED,
    KEYWORD_UNRESERVED,
    KEYWORD_TYPE_FUNC,
    KEYWORD_COL_NAME,
    KEYWORD_NONE
};

◆ CompressionType

enum class duckdb::CompressionType : uint8_t

strongprotected

                           : uint8_t {
    COMPRESSION_AUTO = 0,
    COMPRESSION_UNCOMPRESSED = 1,
    COMPRESSION_CONSTANT = 2, // internal only
    COMPRESSION_RLE = 3,
    COMPRESSION_DICTIONARY = 4,
    COMPRESSION_PFOR_DELTA = 5,
    COMPRESSION_BITPACKING = 6,
    COMPRESSION_FSST = 7,
    COMPRESSION_CHIMP = 8,
    COMPRESSION_PATAS = 9,
    COMPRESSION_ALP = 10,
    COMPRESSION_ALPRD = 11,
    COMPRESSION_ZSTD = 12,
    COMPRESSION_ROARING = 13,
    COMPRESSION_EMPTY = 14, // internal only
    COMPRESSION_DICT_FSST = 15,
    COMPRESSION_COUNT // This has to stay the last entry of the type!
};

enum class duckdb::FunctionCollationHandling : uint8_t

strongprivate

How to handle collations PROPAGATE_COLLATIONS -> this function combines collation from its inputs and emits them again (default) PUSH_COMBINABLE_COLLATIONS -> combinable collations are executed for the input arguments IGNORE_COLLATIONS -> collations are completely ignored by the function

                                     : uint8_t {
    PROPAGATE_COLLATIONS = 0,
    PUSH_COMBINABLE_COLLATIONS = 1,
    IGNORE_COLLATIONS = 2
};

◆ ColumnIndexType

enum class duckdb::ColumnIndexType : uint8_t

strong

Enumerator
FULL_READ	Regular column index, refers to a column in its entirety.
PUSHDOWN_EXTRACT	This index references a struct/variant field that MUST be extracted by the scan and emitted directly.

                           : uint8_t {
    INVALID,
    FULL_READ,
    PUSHDOWN_EXTRACT
};

◆ StorageIndexType

enum class duckdb::StorageIndexType : uint8_t

strongprivate

14856: uint8_t { FULL_READ, PUSHDOWN_EXTRACT };

◆ FilterPropagateResult

enum class duckdb::FilterPropagateResult : uint8_t

strongprivate

                                 : uint8_t {
    NO_PRUNING_POSSIBLE = 0,
    FILTER_ALWAYS_TRUE = 1,
    FILTER_ALWAYS_FALSE = 2,
    FILTER_TRUE_OR_NULL = 3,
    FILTER_FALSE_OR_NULL = 4
};

◆ GeometryType

enum class duckdb::GeometryType : uint8_t

strongprivate

                        : uint8_t {
    INVALID = 0,
    POINT = 1,
    LINESTRING = 2,
    POLYGON = 3,
    MULTIPOINT = 4,
    MULTILINESTRING = 5,
    MULTIPOLYGON = 6,
    GEOMETRYCOLLECTION = 7,
};

◆ VertexType

enum class duckdb::VertexType : uint8_t

strongprivate

15411: uint8_t { XY = 0, XYZ = 1, XYM = 2, XYZM = 3 };

XYZ

◆ GeometryStorageType

enum class duckdb::GeometryStorageType : uint8_t

strongprivate

                               : uint8_t {
 
    SPATIAL = 0,
    WKB = 1,
 
    // Base: 16
    POINT_XY = 17,
    LINESTRING_XY = 18,
    POLYGON_XY = 19,
    MULTIPOINT_XY = 20,
    MULTILINESTRING_XY = 21,
    MULTIPOLYGON_XY = 22,
 
    // Base: 32
    POINT_XYZ = 33,
    LINESTRING_XYZ = 34,
    POLYGON_XYZ = 35,
    MULTIPOINT_XYZ = 36,
    MULTILINESTRING_XYZ = 37,
    MULTIPOLYGON_XYZ = 38,
 
    // Base: 64
    POINT_XYM = 65,
    LINESTRING_XYM = 66,
    POLYGON_XYM = 67,
    MULTIPOINT_XYM = 68,
    MULTILINESTRING_XYM = 69,
    MULTIPOLYGON_XYM = 70,
 
    // Base: 96
    POINT_XYZM = 97,
    LINESTRING_XYZM = 98,
    POLYGON_XYZM = 99,
    MULTIPOINT_XYZM = 100,
    MULTILINESTRING_XYZM = 101,
    MULTIPOLYGON_XYZM = 102,
};

◆ VariantChildLookupMode

enum class duckdb::VariantChildLookupMode : uint8_t

strong

15989: uint8_t { INVALID, BY_KEY, BY_INDEX };

◆ VariantLogicalType

enum class duckdb::VariantLogicalType : uint8_t

strong

                              : uint8_t {
    VARIANT_NULL = 0,
    BOOL_TRUE = 1,
    BOOL_FALSE = 2,
    INT8 = 3,
    INT16 = 4,
    INT32 = 5,
    INT64 = 6,
    INT128 = 7,
    UINT8 = 8,
    UINT16 = 9,
    UINT32 = 10,
    UINT64 = 11,
    UINT128 = 12,
    FLOAT = 13,
    DOUBLE = 14,
    DECIMAL = 15,
    VARCHAR = 16,
    BLOB = 17,
    UUID = 18,
    DATE = 19,
    TIME_MICROS = 20,
    TIME_NANOS = 21,
    TIMESTAMP_SEC = 22,
    TIMESTAMP_MILIS = 23,
    TIMESTAMP_MICROS = 24,
    TIMESTAMP_NANOS = 25,
    TIME_MICROS_TZ = 26,
    TIMESTAMP_MICROS_TZ = 27,
    INTERVAL = 28,
    OBJECT = 29,
    ARRAY = 30,
    BIGNUM = 31,
    BITSTRING = 32,
    GEOMETRY = 33,
    ENUM_SIZE /* always kept as last item of the enum */
};

◆ VariantStatsShreddingState

enum class duckdb::VariantStatsShreddingState : uint8_t

strong

Enumerator
UNINITIALIZED	Uninitialized, not unshredded/shredded.
NOT_SHREDDED	No shredding applied yet.
SHREDDED	Shredded consistently.
INCONSISTENT	Result from combining incompatible shreddings.

                                      : uint8_t {
    UNINITIALIZED,
    NOT_SHREDDED,
    SHREDDED,
    INCONSISTENT
};

◆ StatsInfo

enum class duckdb::StatsInfo : uint8_t

strongprivate

                     : uint8_t {
    CAN_HAVE_NULL_VALUES = 0,
    CANNOT_HAVE_NULL_VALUES = 1,
    CAN_HAVE_VALID_VALUES = 2,
    CANNOT_HAVE_VALID_VALUES = 3,
    CAN_HAVE_NULL_AND_VALID_VALUES = 4
};

◆ StatisticsType

enum class duckdb::StatisticsType : uint8_t

strongprivate

                          : uint8_t {
    NUMERIC_STATS,
    STRING_STATS,
    LIST_STATS,
    STRUCT_STATS,
    BASE_STATS,
    ARRAY_STATS,
    GEOMETRY_STATS,
    VARIANT_STATS
};

enum class duckdb::OrderType : uint8_t

strong

17490: uint8_t { INVALID = 0, ORDER_DEFAULT = 1, ASCENDING = 2, DESCENDING = 3 };

◆ OrderByNullType

enum class duckdb::OrderByNullType : uint8_t

strong

17492: uint8_t { INVALID = 0, ORDER_DEFAULT = 1, NULLS_FIRST = 2, NULLS_LAST = 3 };

◆ DefaultOrderByNullType

enum class duckdb::DefaultOrderByNullType : uint8_t

strong

                                  : uint8_t {
    INVALID = 0,
    NULLS_FIRST = 2,
    NULLS_LAST = 3,
    NULLS_FIRST_ON_ASC_LAST_ON_DESC = 4,
    NULLS_LAST_ON_ASC_FIRST_ON_DESC = 5
};

◆ ResultModifierType

enum class duckdb::ResultModifierType : uint8_t

strong

                              : uint8_t {
    LIMIT_MODIFIER = 1,
    ORDER_MODIFIER = 2,
    DISTINCT_MODIFIER = 3,
    LIMIT_PERCENT_MODIFIER = 4
};

◆ SetOperationType

enum class duckdb::SetOperationType : uint8_t

strong

17689: uint8_t { NONE = 0, UNION = 1, EXCEPT = 2, INTERSECT = 3, UNION_BY_NAME = 4 };

◆ LimitNodeType

enum class duckdb::LimitNodeType : uint8_t

strongprotected

                         : uint8_t {
    UNSET = 0,
    CONSTANT_VALUE = 1,
    CONSTANT_PERCENTAGE = 2,
    EXPRESSION_VALUE = 3,
    EXPRESSION_PERCENTAGE = 4
};

◆ DistinctType

enum class duckdb::DistinctType : uint8_t

strongprotected

17941: uint8_t { DISTINCT = 0, DISTINCT_ON = 1 };

◆ AggregateDestructorType

enum class duckdb::AggregateDestructorType

strong

                                   {
    STANDARD,
    // legacy destructors allow non-trivial destructors in aggregate states
    // these might not be trivial to off-load to disk
    LEGACY
};

◆ ColumnDataAllocatorType

enum class duckdb::ColumnDataAllocatorType : uint8_t

strong

Enumerator
BUFFER_MANAGER_ALLOCATOR	Use a buffer manager to allocate large chunks of memory that vectors then use.
IN_MEMORY_ALLOCATOR	Use an in-memory allocator, allocating data for every chunk This causes the column data collection to allocate blocks that are not tied to a buffer manager
HYBRID	Use a buffer manager to allocate vectors, but use a StringHeap for strings.

                                   : uint8_t {
    BUFFER_MANAGER_ALLOCATOR,
    IN_MEMORY_ALLOCATOR,
    HYBRID
};

◆ ColumnDataScanProperties

enum class duckdb::ColumnDataScanProperties : uint8_t

strong

Enumerator
ALLOW_ZERO_COPY	Allow zero copy scans - this introduces a dependency on the resulting vector on the scan state of the column data collection, which means vectors might not be valid anymore after the next chunk is scanned.
DISALLOW_ZERO_COPY	Disallow zero-copy scans, always copying data into the target vector As a result, data scanned will be valid even after the column data collection is destroyed

                                    : uint8_t {
    INVALID,
    ALLOW_ZERO_COPY,
    DISALLOW_ZERO_COPY
};

◆ ColumnDataCollectionLifetime

enum class duckdb::ColumnDataCollectionLifetime

strong

Enumerator
REGULAR	Regular lifetime management.
THROW_ERROR_AFTER_DATABASE_CLOSES	Accessing will throw an error after the DB closes Optional for ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR only

                                        {
    REGULAR,
    THROW_ERROR_AFTER_DATABASE_CLOSES,
};

◆ QueryResultOutputType

enum class duckdb::QueryResultOutputType : uint8_t

strongprivate

19230: uint8_t { FORCE_MATERIALIZED, ALLOW_STREAMING };

◆ QueryResultMemoryType

enum class duckdb::QueryResultMemoryType : uint8_t

strongprivate

19232: uint8_t { IN_MEMORY, BUFFER_MANAGED };

◆ StatementType

enum class duckdb::StatementType : uint8_t

strongprivate

                         : uint8_t {
    INVALID_STATEMENT,      // invalid statement type
    SELECT_STATEMENT,       // select statement type
    INSERT_STATEMENT,       // insert statement type
    UPDATE_STATEMENT,       // update statement type
    CREATE_STATEMENT,       // create statement type
    DELETE_STATEMENT,       // delete statement type
    PREPARE_STATEMENT,      // prepare statement type
    EXECUTE_STATEMENT,      // execute statement type
    ALTER_STATEMENT,        // alter statement type
    TRANSACTION_STATEMENT,  // transaction statement type,
    COPY_STATEMENT,         // copy type
    ANALYZE_STATEMENT,      // analyze type
    VARIABLE_SET_STATEMENT, // variable set statement type
    CREATE_FUNC_STATEMENT,  // create func statement type
    EXPLAIN_STATEMENT,      // explain statement type
    DROP_STATEMENT,         // DROP statement type
    EXPORT_STATEMENT,       // EXPORT statement type
    PRAGMA_STATEMENT,       // PRAGMA statement type
    VACUUM_STATEMENT,       // VACUUM statement type
    CALL_STATEMENT,         // CALL statement type
    SET_STATEMENT,          // SET statement type
    LOAD_STATEMENT,         // LOAD statement type
    RELATION_STATEMENT,
    EXTENSION_STATEMENT,
    LOGICAL_PLAN_STATEMENT,
    ATTACH_STATEMENT,
    DETACH_STATEMENT,
    MULTI_STATEMENT,
    COPY_DATABASE_STATEMENT,
    UPDATE_EXTENSIONS_STATEMENT,
    MERGE_INTO_STATEMENT
};

◆ StatementReturnType

enum class duckdb::StatementReturnType : uint8_t

strongprivate

                               : uint8_t {
    QUERY_RESULT, // the statement returns a query result (e.g. for display to the user)
    CHANGED_ROWS, // the statement returns a single row containing the number of changed rows (e.g. an insert stmt)
    NOTHING       // the statement returns nothing
};

◆ ArrowOffsetSize

enum class duckdb::ArrowOffsetSize : uint8_t

strong

19455: uint8_t { REGULAR, LARGE };

◆ ArrowFormatVersion

enum class duckdb::ArrowFormatVersion : uint8_t

strong

Enumerator
V1_0	Base Version.
V1_1	Added 256-bit Decimal type.
V1_2	Added MonthDayNano interval type.
V1_3	Added Run-End Encoded Layout.
V1_4	Added Variable-size Binary View Layout and the associated BinaryView and Utf8View types. Added ListView Layout and the associated ListView and LargeListView types. Added Variadic buffers.
V1_5	Expanded Decimal type bit widths to allow 32-bit and 64-bit types.

                              : uint8_t {
    V1_0 = 10,
    V1_1 = 11,
    V1_2 = 12,
    V1_3 = 13,
    V1_4 = 14,
    V1_5 = 15
};

◆ QueryResultType

enum class duckdb::QueryResultType : uint8_t

strong

19504: uint8_t { MATERIALIZED_RESULT, STREAM_RESULT, PENDING_RESULT, ARROW_RESULT };

◆ PendingExecutionResult

enum class duckdb::PendingExecutionResult : uint8_t

strongprivate

                                  : uint8_t {
    RESULT_READY,
    RESULT_NOT_READY,
    EXECUTION_ERROR,
    BLOCKED,
    NO_TASKS_AVAILABLE,
    EXECUTION_FINISHED
};

enum class duckdb::AsyncResultType : uint8_t

strong

AsyncResultType is used to indicate the result of a AsyncResult, in the context of a wider operation being executed.

                           : uint8_t {
    INVALID,  // current result is in an invalid state (eg: it's in the process of being initialized)
    IMPLICIT, // current result depends on external context (eg: in the context of TableFunctions, either FINISHED or
              // HAVE_MORE_OUTPUT depending on output_chunk.size())
    HAVE_MORE_OUTPUT, // current result is not completed, finished (eg: in the context of TableFunctions, function
                      // accept more iterations and might produce further results)
    FINISHED,         // current result is completed, no subsequent calls on the same state should be attempted
    BLOCKED // current result is blocked, no subsequent calls on the same state should be attempted (eg: in the context
            // of AsyncResult, BLOCKED will be associated with a vector of AsyncTasks to be scheduled)
};

◆ SinkResultType

enum class duckdb::SinkResultType : uint8_t

strong

The SinkResultType is used to indicate the result of data flowing into a sink There are three possible results: NEED_MORE_INPUT means the sink needs more input FINISHED means the sink is finished executing, and more input will not change the result any further BLOCKED means the sink is currently blocked, e.g. by some async I/O.

20222: uint8_t { NEED_MORE_INPUT, FINISHED, BLOCKED };

enum class duckdb::OrderPreservationType : uint8_t

strong

                                 : uint8_t {
    NO_ORDER,        // the operator makes no guarantees on order preservation (i.e. it might re-order the entire input)
    INSERTION_ORDER, // the operator maintains the order of the child operators
    FIXED_ORDER      // the operator outputs rows in a fixed order that must be maintained (e.g. ORDER BY)
};

◆ PhysicalOperatorType

enum class duckdb::PhysicalOperatorType : uint8_t

strong

                                : uint8_t {
    INVALID,
    ORDER_BY,
    LIMIT,
    STREAMING_LIMIT,
    LIMIT_PERCENT,
    TOP_N,
    WINDOW,
    UNNEST,
    UNGROUPED_AGGREGATE,
    HASH_GROUP_BY,
    PERFECT_HASH_GROUP_BY,
    PARTITIONED_AGGREGATE,
    FILTER,
    PROJECTION,
    COPY_TO_FILE,
    BATCH_COPY_TO_FILE,
    RESERVOIR_SAMPLE,
    STREAMING_SAMPLE,
    STREAMING_WINDOW,
    PIVOT,
    COPY_DATABASE,
 
    // -----------------------------
    // Scans
    // -----------------------------
    TABLE_SCAN,
    DUMMY_SCAN,
    COLUMN_DATA_SCAN,
    CHUNK_SCAN,
    RECURSIVE_CTE_SCAN,
    RECURSIVE_RECURRING_CTE_SCAN,
    CTE_SCAN,
    DELIM_SCAN,
    EXPRESSION_SCAN,
    POSITIONAL_SCAN,
    // -----------------------------
    // Joins
    // -----------------------------
    BLOCKWISE_NL_JOIN,
    NESTED_LOOP_JOIN,
    HASH_JOIN,
    CROSS_PRODUCT,
    PIECEWISE_MERGE_JOIN,
    IE_JOIN,
    LEFT_DELIM_JOIN,
    RIGHT_DELIM_JOIN,
    POSITIONAL_JOIN,
    ASOF_JOIN,
    // -----------------------------
    // SetOps
    // -----------------------------
    UNION,
    RECURSIVE_CTE,
    RECURSIVE_KEY_CTE,
    CTE,
 
    // -----------------------------
    // Updates
    // -----------------------------
    INSERT,
    BATCH_INSERT,
    DELETE_OPERATOR,
    UPDATE,
    MERGE_INTO,
 
    // -----------------------------
    // Schema
    // -----------------------------
    CREATE_TABLE,
    CREATE_TABLE_AS,
    BATCH_CREATE_TABLE_AS,
    CREATE_INDEX,
    ALTER,
    CREATE_SEQUENCE,
    CREATE_VIEW,
    CREATE_SCHEMA,
    CREATE_MACRO,
    DROP,
    PRAGMA,
    TRANSACTION,
    CREATE_TYPE,
    ATTACH,
    DETACH,
 
    // -----------------------------
    // Helpers
    // -----------------------------
    EXPLAIN,
    EXPLAIN_ANALYZE,
    EMPTY_RESULT,
    EXECUTE,
    PREPARE,
    VACUUM,
    EXPORT,
    SET,
    SET_VARIABLE,
    LOAD,
    INOUT_FUNCTION,
    RESULT_COLLECTOR,
    RESET,
    EXTENSION,
    VERIFY_VECTOR,
    UPDATE_EXTENSIONS,
 
    // -----------------------------
    // Secret
    // -----------------------------
    CREATE_SECRET,
};

◆ PartitionInfo

enum class duckdb::PartitionInfo

strong

20451{ NONE, REQUIRES_BATCH_INDEX };

◆ TableFilterType

enum class duckdb::TableFilterType : uint8_t

strong

                           : uint8_t {
    CONSTANT_COMPARISON = 0, // constant comparison (e.g. =C, >C, >=C, <C, <=C)
    IS_NULL = 1,             // C IS NULL
    IS_NOT_NULL = 2,         // C IS NOT NULL
    CONJUNCTION_OR = 3,      // OR of different filters
    CONJUNCTION_AND = 4,     // AND of different filters
    STRUCT_EXTRACT = 5,      // filter applies to child-column of struct
    OPTIONAL_FILTER = 6,     // executing filter is not required for query correctness
    IN_FILTER = 7,           // col IN (C1, C2, C3, ...)
    DYNAMIC_FILTER = 8,      // dynamic filters can be updated at run-time
    EXPRESSION_FILTER = 9,   // an arbitrary expression
    BLOOM_FILTER = 10,       // a probabilistic filter that can test whether a value is in a set of other value
};

◆ LogicalOperatorType

enum class duckdb::LogicalOperatorType : uint8_t

strong

                               : uint8_t {
    LOGICAL_INVALID = 0,
    LOGICAL_PROJECTION = 1,
    LOGICAL_FILTER = 2,
    LOGICAL_AGGREGATE_AND_GROUP_BY = 3,
    LOGICAL_WINDOW = 4,
    LOGICAL_UNNEST = 5,
    LOGICAL_LIMIT = 6,
    LOGICAL_ORDER_BY = 7,
    LOGICAL_TOP_N = 8,
    LOGICAL_COPY_TO_FILE = 10,
    LOGICAL_DISTINCT = 11,
    LOGICAL_SAMPLE = 12,
    LOGICAL_PIVOT = 14,
    LOGICAL_COPY_DATABASE = 15,
 
    // -----------------------------
    // Data sources
    // -----------------------------
    LOGICAL_GET = 25,
    LOGICAL_CHUNK_GET = 26,
    LOGICAL_DELIM_GET = 27,
    LOGICAL_EXPRESSION_GET = 28,
    LOGICAL_DUMMY_SCAN = 29,
    LOGICAL_EMPTY_RESULT = 30,
    LOGICAL_CTE_REF = 31,
    // -----------------------------
    // Joins
    // -----------------------------
    LOGICAL_JOIN = 50,
    LOGICAL_DELIM_JOIN = 51,
    LOGICAL_COMPARISON_JOIN = 52,
    LOGICAL_ANY_JOIN = 53,
    LOGICAL_CROSS_PRODUCT = 54,
    LOGICAL_POSITIONAL_JOIN = 55,
    LOGICAL_ASOF_JOIN = 56,
    LOGICAL_DEPENDENT_JOIN = 57,
    // -----------------------------
    // SetOps
    // -----------------------------
    LOGICAL_UNION = 75,
    LOGICAL_EXCEPT = 76,
    LOGICAL_INTERSECT = 77,
    LOGICAL_RECURSIVE_CTE = 78,
    LOGICAL_MATERIALIZED_CTE = 79,
 
    // -----------------------------
    // Updates
    // -----------------------------
    LOGICAL_INSERT = 100,
    LOGICAL_DELETE = 101,
    LOGICAL_UPDATE = 102,
    LOGICAL_MERGE_INTO = 103,
 
    // -----------------------------
    // Schema
    // -----------------------------
    LOGICAL_ALTER = 125,
    LOGICAL_CREATE_TABLE = 126,
    LOGICAL_CREATE_INDEX = 127,
    LOGICAL_CREATE_SEQUENCE = 128,
    LOGICAL_CREATE_VIEW = 129,
    LOGICAL_CREATE_SCHEMA = 130,
    LOGICAL_CREATE_MACRO = 131,
    LOGICAL_DROP = 132,
    LOGICAL_PRAGMA = 133,
    LOGICAL_TRANSACTION = 134,
    LOGICAL_CREATE_TYPE = 135,
    LOGICAL_ATTACH = 136,
    LOGICAL_DETACH = 137,
 
    // -----------------------------
    // Explain
    // -----------------------------
    LOGICAL_EXPLAIN = 150,
 
    // -----------------------------
    // Helpers
    // -----------------------------
    LOGICAL_PREPARE = 175,
    LOGICAL_EXECUTE = 176,
    LOGICAL_EXPORT = 177,
    LOGICAL_VACUUM = 178,
    LOGICAL_SET = 179,
    LOGICAL_LOAD = 180,
    LOGICAL_RESET = 181,
    LOGICAL_UPDATE_EXTENSIONS = 182,
 
    // -----------------------------
    // Secrets
    // -----------------------------
    LOGICAL_CREATE_SECRET = 190,
 
    LOGICAL_EXTENSION_OPERATOR = 255
};

◆ TaskExecutionMode

strong

                            {
    // get all rows valid for the transaction
    STANDARD,
    // scan all rows including transaction local rows
    ALL_ROWS
};

◆ DeletedScanType

enum class duckdb::DeletedScanType

strong

Enumerator
STANDARD	omit any rows that are deleted
INCLUDE_ALL_DELETED	include all rows, including all deleted rows
OMIT_COMMITTED_DELETES	omit only deleted rows that have been committed and have a commit ts lower than the transaction start

                           {
    STANDARD,
    INCLUDE_ALL_DELETED,
    OMIT_COMMITTED_DELETES
};

◆ UpdateScanType

enum class duckdb::UpdateScanType

strong

Enumerator
STANDARD	allow updates

                          {
    STANDARD,
    // disallow updates - throw on updates
    DISALLOW_UPDATES
};

◆ TableScanType

enum class duckdb::TableScanType

strong

Enumerator
TABLE_SCAN_ALL_ROWS	Scan all rows, including any deleted rows. Committed updates are merged in.
TABLE_SCAN_OMIT_PERMANENTLY_DELETED	Scan all rows, excluding any permanently deleted rows. Permanently deleted rows are rows which no transaction will ever need again.
TABLE_SCAN_COMMITTED_ROWS	Scan the latest committed rows.

                         {
    TABLE_SCAN_ALL_ROWS = 1,
    TABLE_SCAN_OMIT_PERMANENTLY_DELETED = 2,
    TABLE_SCAN_COMMITTED_ROWS = 3
};

◆ ChunkInfoType

enum class duckdb::ChunkInfoType : uint8_t

strong

22694: uint8_t { CONSTANT_INFO, VECTOR_INFO, EMPTY_INFO };

◆ CheckpointWALAction

enum class duckdb::CheckpointWALAction

strong

Enumerator
DELETE_WAL	Delete the WAL file after the checkpoint completes - generally done on shutdown.
DONT_DELETE_WAL	Leave the WAL file alone.

                               {
    DELETE_WAL,
    DONT_DELETE_WAL
};

◆ CheckpointAction

enum class duckdb::CheckpointAction

strong

Enumerator
CHECKPOINT_IF_REQUIRED	Checkpoint only if a checkpoint is required (i.e. the WAL has data in it that can be flushed)
ALWAYS_CHECKPOINT	Always checkpoint regardless of whether or not there is data in the WAL to flush.

                            {
    CHECKPOINT_IF_REQUIRED,
    ALWAYS_CHECKPOINT
};

◆ CheckpointType

enum class duckdb::CheckpointType

strong

Enumerator
FULL_CHECKPOINT	Full checkpoints involve vacuuming deleted rows and updates They can only be run if no transaction need to read old data (that would be cleaned up/vacuumed)
CONCURRENT_CHECKPOINT	Concurrent checkpoints write committed data to disk but do less clean-up They can be run even when active transactions need to read old data
VACUUM_ONLY	Only run vacuum - this can be triggered for in-memory tables.

                          {
    FULL_CHECKPOINT,
    CONCURRENT_CHECKPOINT,
    VACUUM_ONLY
};

◆ StorageLockType

enum class duckdb::StorageLockType

strongprivate

23432{ SHARED = 0, EXCLUSIVE = 1 };

◆ OrderByStatistics

enum class duckdb::OrderByStatistics : uint8_t

strongprotected

24019: uint8_t { MIN, MAX };

◆ OrderByColumnType

enum class duckdb::OrderByColumnType : uint8_t

strongprotected

24020: uint8_t { NUMERIC, STRING };

Param::STRING

@ STRING

◆ AsyncResultsExecutionMode

enum class duckdb::AsyncResultsExecutionMode : uint8_t

strong

                                     : uint8_t {
    SYNCHRONOUS,  // BLOCKED should not bubble up, and they should be executed synchronously
    TASK_EXECUTOR // BLOCKED is allowed
};

◆ ScanType

enum class duckdb::ScanType : uint8_t

strong

26388: uint8_t { TABLE, PARQUET, EXTERNAL };

◆ TableFunctionInitialization

enum class duckdb::TableFunctionInitialization

strong

When to call init_global to initialize the table function.

26498{ INITIALIZE_ON_EXECUTE, INITIALIZE_ON_SCHEDULE };

◆ JoinType

enum class duckdb::JoinType : uint8_t

strongprivate

                    : uint8_t {
    INVALID = 0, // invalid join type
    LEFT = 1,    // left
    RIGHT = 2,   // right
    INNER = 3,   // inner
    OUTER = 4,   // outer
    SEMI = 5,    // LEFT SEMI join returns left side row ONLY if it has a join partner, no duplicates.
    ANTI = 6,    // LEFT ANTI join returns left side row ONLY if it has NO join partner, no duplicates
    MARK = 7,    // MARK join returns marker indicating whether or not there is a join partner (true), there is no join
                 // partner (false)
    SINGLE = 8,  // SINGLE join is like LEFT OUTER JOIN, BUT returns at most one join partner per entry on the LEFT side
                 // (and NULL if no partner is found)
    RIGHT_SEMI = 9, // RIGHT SEMI join is created by the optimizer when the children of a semi join need to be switched
                    // so that the build side can be the smaller table
    RIGHT_ANTI = 10 // RIGHT ANTI join is created by the optimizer when the children of an anti join need to be
                    // switched so that the build side can be the smaller table
};

◆ RelationType

enum class duckdb::RelationType : uint8_t

strongprivate

                        : uint8_t {
    INVALID_RELATION,
    TABLE_RELATION,
    PROJECTION_RELATION,
    FILTER_RELATION,
    EXPLAIN_RELATION,
    CROSS_PRODUCT_RELATION,
    JOIN_RELATION,
    AGGREGATE_RELATION,
    SET_OPERATION_RELATION,
    DISTINCT_RELATION,
    LIMIT_RELATION,
    ORDER_RELATION,
    CREATE_VIEW_RELATION,
    CREATE_TABLE_RELATION,
    INSERT_RELATION,
    VALUE_LIST_RELATION,
    MATERIALIZED_RELATION,
    DELETE_RELATION,
    UPDATE_RELATION,
    WRITE_CSV_RELATION,
    WRITE_PARQUET_RELATION,
    READ_CSV_RELATION,
    SUBQUERY_RELATION,
    TABLE_FUNCTION_RELATION,
    VIEW_RELATION,
    QUERY_RELATION,
    DELIM_JOIN_RELATION,
    DELIM_GET_RELATION,
    EXTENSION_RELATION = 255
};

◆ JoinRefType

enum class duckdb::JoinRefType : uint8_t

strongprivate

                       : uint8_t {
    REGULAR,    // Explicit conditions
    NATURAL,    // Implied conditions
    CROSS,      // No condition
    POSITIONAL, // Positional condition
    ASOF,       // AsOf conditions
    DEPENDENT,  // Dependent join conditions
};

◆ ParseInfoType

enum class duckdb::ParseInfoType : uint8_t

strong

                         : uint8_t {
    ALTER_INFO,
    ATTACH_INFO,
    COPY_INFO,
    CREATE_INFO,
    CREATE_SECRET_INFO,
    DETACH_INFO,
    DROP_INFO,
    BOUND_EXPORT_DATA,
    LOAD_INFO,
    PRAGMA_INFO,
    SHOW_SELECT_INFO,
    TRANSACTION_INFO,
    VACUUM_INFO,
    COMMENT_ON_INFO,
    COMMENT_ON_COLUMN_INFO,
    COPY_DATABASE_INFO,
    UPDATE_EXTENSIONS_INFO
};

◆ OnCreateConflict

enum class duckdb::OnCreateConflict : uint8_t

strong

                            : uint8_t {
    // Standard: throw error
    ERROR_ON_CONFLICT,
    // CREATE IF NOT EXISTS, silently do nothing on conflict
    IGNORE_ON_CONFLICT,
    // CREATE OR REPLACE
    REPLACE_ON_CONFLICT,
    // Update on conflict - only support for functions. Add a function overload if the function already exists.
    ALTER_ON_CONFLICT
};

◆ SequenceInfo

enum class duckdb::SequenceInfo : uint8_t

strong

                        : uint8_t {
    // Sequence start
    SEQ_START,
    // Sequence increment
    SEQ_INC,
    // Sequence minimum value
    SEQ_MIN,
    // Sequence maximum value
    SEQ_MAX,
    // Sequence cycle option
    SEQ_CYCLE,
    // Sequence owner table
    SEQ_OWN
};

◆ AlterType

enum class duckdb::AlterType : uint8_t

strong

                     : uint8_t {
    INVALID = 0,
    ALTER_TABLE = 1,
    ALTER_VIEW = 2,
    ALTER_SEQUENCE = 3,
    CHANGE_OWNERSHIP = 4,
    ALTER_SCALAR_FUNCTION = 5,
    ALTER_TABLE_FUNCTION = 6,
    SET_COMMENT = 7,
    SET_COLUMN_COMMENT = 8,
    ALTER_DATABASE = 9
};

◆ ConstraintType

enum class duckdb::ConstraintType : uint8_t

strongprotected

                          : uint8_t {
    INVALID = 0,     // invalid constraint type
    NOT_NULL = 1,    // NOT NULL constraint
    CHECK = 2,       // CHECK constraint
    UNIQUE = 3,      // UNIQUE constraint
    FOREIGN_KEY = 4, // FOREIGN KEY constraint
};

◆ ForeignKeyType

enum class duckdb::ForeignKeyType : uint8_t

strongprotected

                          : uint8_t {
    FK_TYPE_PRIMARY_KEY_TABLE = 0,   // main table
    FK_TYPE_FOREIGN_KEY_TABLE = 1,   // referencing table
    FK_TYPE_SELF_REFERENCE_TABLE = 2 // self refrencing table
};

◆ AlterForeignKeyType

enum class duckdb::AlterForeignKeyType : uint8_t

strong

28441: uint8_t { AFT_ADD = 0, AFT_DELETE = 1 };

◆ AlterTableType

enum class duckdb::AlterTableType : uint8_t

strong

                          : uint8_t {
    INVALID = 0,
    RENAME_COLUMN = 1,
    RENAME_TABLE = 2,
    ADD_COLUMN = 3,
    REMOVE_COLUMN = 4,
    ALTER_COLUMN_TYPE = 5,
    SET_DEFAULT = 6,
    FOREIGN_KEY_CONSTRAINT = 7,
    SET_NOT_NULL = 8,
    DROP_NOT_NULL = 9,
    SET_COLUMN_COMMENT = 10,
    ADD_CONSTRAINT = 11,
    SET_PARTITIONED_BY = 12,
    SET_SORTED_BY = 13,
    ADD_FIELD = 14,
    REMOVE_FIELD = 15,
    RENAME_FIELD = 16,
    SET_TABLE_OPTIONS = 17,
    RESET_TABLE_OPTIONS = 18,
};

◆ AlterViewType

enum class duckdb::AlterViewType : uint8_t

strong

28824: uint8_t { INVALID = 0, RENAME_VIEW = 1 };

◆ PreparedStatementMode

enum class duckdb::PreparedStatementMode : uint8_t

strong

                                 : uint8_t {
    PREPARE_ONLY,
    PREPARE_AND_EXECUTE,
};

◆ ExplainOutputType

enum class duckdb::ExplainOutputType : uint8_t

strong

29567: uint8_t { ALL = 0, OPTIMIZED_ONLY = 1, PHYSICAL_ONLY = 2 };

◆ OptimizerType

enum class duckdb::OptimizerType : uint32_t

strongprivate

                         : uint32_t {
    INVALID = 0,
    EXPRESSION_REWRITER = 1,
    FILTER_PULLUP = 2,
    FILTER_PUSHDOWN = 3,
    EMPTY_RESULT_PULLUP = 4,
    CTE_FILTER_PUSHER = 5,
    REGEX_RANGE = 6,
    IN_CLAUSE = 7,
    JOIN_ORDER = 8,
    DELIMINATOR = 9,
    UNNEST_REWRITER = 10,
    UNUSED_COLUMNS = 11,
    STATISTICS_PROPAGATION = 12,
    COMMON_SUBEXPRESSIONS = 13,
    COMMON_AGGREGATE = 14,
    COLUMN_LIFETIME = 15,
    BUILD_SIDE_PROBE_SIDE = 16,
    LIMIT_PUSHDOWN = 17,
    TOP_N = 18,
    COMPRESSED_MATERIALIZATION = 19,
    DUPLICATE_GROUPS = 20,
    REORDER_FILTER = 21,
    SAMPLING_PUSHDOWN = 22,
    JOIN_FILTER_PUSHDOWN = 23,
    EXTENSION = 24,
    MATERIALIZED_CTE = 25,
    SUM_REWRITER = 26,
    LATE_MATERIALIZATION = 27,
    CTE_INLINING = 28,
    ROW_GROUP_PRUNER = 29,
    TOP_N_WINDOW_ELIMINATION = 30,
    COMMON_SUBPLAN = 31,
    JOIN_ELIMINATION = 32,
    WINDOW_SELF_JOIN = 33
};

◆ MetricGroup

enum class duckdb::MetricGroup : uint8_t

strongprivate

                       : uint8_t {
    ALL,
    CORE,
    DEFAULT,
    EXECUTION,
    FILE,
    OPERATOR,
    OPTIMIZER,
    PHASE_TIMING,
    INVALID,
};

◆ MetricType

enum class duckdb::MetricType : uint8_t

strongprivate

                      : uint8_t {
    // Core metrics
    CPU_TIME = 2,
    CUMULATIVE_CARDINALITY = 4,
    CUMULATIVE_ROWS_SCANNED = 7,
    EXTRA_INFO = 3,
    LATENCY = 11,
    QUERY_NAME = 0,
    RESULT_SET_SIZE = 10,
    ROWS_RETURNED = 12,
    // Execution metrics
    BLOCKED_THREAD_TIME = 1,
    SYSTEM_PEAK_BUFFER_MEMORY = 14,
    SYSTEM_PEAK_TEMP_DIR_SIZE = 15,
    TOTAL_MEMORY_ALLOCATED = 91,
    // File metrics
    ATTACH_LOAD_STORAGE_LATENCY = 92,
    ATTACH_REPLAY_WAL_LATENCY = 93,
    CHECKPOINT_LATENCY = 94,
    COMMIT_LOCAL_STORAGE_LATENCY = 95,
    TOTAL_BYTES_READ = 16,
    TOTAL_BYTES_WRITTEN = 17,
    WAITING_TO_ATTACH_LATENCY = 96,
    WAL_REPLAY_ENTRY_COUNT = 97,
    WRITE_TO_WAL_LATENCY = 98,
    // Operator metrics
    OPERATOR_CARDINALITY = 6,
    OPERATOR_NAME = 13,
    OPERATOR_ROWS_SCANNED = 8,
    OPERATOR_TIMING = 9,
    OPERATOR_TYPE = 5,
    // Optimizer metrics
    OPTIMIZER_EXPRESSION_REWRITER = 26,
    OPTIMIZER_FILTER_PULLUP = 27,
    OPTIMIZER_FILTER_PUSHDOWN = 28,
    OPTIMIZER_EMPTY_RESULT_PULLUP = 29,
    OPTIMIZER_CTE_FILTER_PUSHER = 30,
    OPTIMIZER_REGEX_RANGE = 31,
    OPTIMIZER_IN_CLAUSE = 32,
    OPTIMIZER_JOIN_ORDER = 33,
    OPTIMIZER_DELIMINATOR = 34,
    OPTIMIZER_UNNEST_REWRITER = 35,
    OPTIMIZER_UNUSED_COLUMNS = 36,
    OPTIMIZER_STATISTICS_PROPAGATION = 37,
    OPTIMIZER_COMMON_SUBEXPRESSIONS = 38,
    OPTIMIZER_COMMON_AGGREGATE = 39,
    OPTIMIZER_COLUMN_LIFETIME = 40,
    OPTIMIZER_BUILD_SIDE_PROBE_SIDE = 41,
    OPTIMIZER_LIMIT_PUSHDOWN = 42,
    OPTIMIZER_TOP_N = 43,
    OPTIMIZER_COMPRESSED_MATERIALIZATION = 44,
    OPTIMIZER_DUPLICATE_GROUPS = 45,
    OPTIMIZER_REORDER_FILTER = 46,
    OPTIMIZER_SAMPLING_PUSHDOWN = 47,
    OPTIMIZER_JOIN_FILTER_PUSHDOWN = 48,
    OPTIMIZER_EXTENSION = 49,
    OPTIMIZER_MATERIALIZED_CTE = 50,
    OPTIMIZER_SUM_REWRITER = 51,
    OPTIMIZER_LATE_MATERIALIZATION = 52,
    OPTIMIZER_CTE_INLINING = 53,
    OPTIMIZER_ROW_GROUP_PRUNER = 54,
    OPTIMIZER_TOP_N_WINDOW_ELIMINATION = 55,
    OPTIMIZER_COMMON_SUBPLAN = 56,
    OPTIMIZER_JOIN_ELIMINATION = 57,
    OPTIMIZER_WINDOW_SELF_JOIN = 58,
    // PhaseTiming metrics
    ALL_OPTIMIZERS = 18,
    CUMULATIVE_OPTIMIZER_TIMING = 19,
    PHYSICAL_PLANNER = 22,
    PHYSICAL_PLANNER_COLUMN_BINDING = 23,
    PHYSICAL_PLANNER_CREATE_PLAN = 25,
    PHYSICAL_PLANNER_RESOLVE_TYPES = 24,
    PLANNER = 20,
    PLANNER_BINDING = 21,
};

◆ ProfilingParameterNames

enum class duckdb::ProfilingParameterNames : uint8_t

strong

36295: uint8_t { FORMAT, COVERAGE, SAVE_LOCATION, MODE, METRICS };

◆ LambdaSyntax

enum class duckdb::LambdaSyntax : uint8_t

strong

36420: uint8_t { DEFAULT = 0, ENABLE_SINGLE_ARROW = 1, DISABLE_SINGLE_ARROW = 2 };

◆ LambdaSyntaxType

enum class duckdb::LambdaSyntaxType : uint8_t

strong

36427: uint8_t { SINGLE_ARROW_STORAGE = 0, SINGLE_ARROW = 1, LAMBDA_KEYWORD = 2 };

◆ ProfilingCoverage

enum class duckdb::ProfilingCoverage : uint8_t

strongprivate

36730: uint8_t { SELECT = 0, ALL = 1 };

◆ SetScope

enum class duckdb::SetScope : uint8_t

strongprivate

                    : uint8_t {
    AUTOMATIC = 0,
    LOCAL = 1, /* unused */
    SESSION = 2,
    GLOBAL = 3,
    VARIABLE = 4
};

◆ SettingScope

enum class duckdb::SettingScope : uint8_t

strongprivate

Enumerator
GLOBAL	Setting is from the global Setting scope.
LOCAL	Setting is from the local Setting scope.
SECRET	Setting was not fetched from settings, but it was fetched from a secret instead.
INVALID	The setting was not found or invalid in some other way.

                        : uint8_t {
    GLOBAL,
    LOCAL,
    SECRET,
    INVALID
};

◆ SettingScopeTarget

enum class duckdb::SettingScopeTarget

strongprivate

Enumerator
GLOBAL_ONLY	Setting can be set in global scope only.
LOCAL_ONLY	Setting can be set in local scope only.
GLOBAL_DEFAULT	Setting can be set in both scopes - but defaults to global.
LOCAL_DEFAULT	Setting can be set in both scopes - but defaults to local.

                              {
    INVALID,
    GLOBAL_ONLY,
    LOCAL_ONLY,
    GLOBAL_DEFAULT,
    LOCAL_DEFAULT
};

◆ ArrowTypeInfoType

enum class duckdb::ArrowTypeInfoType : uint8_t

strongprotected

37463: uint8_t { LIST, STRUCT, DATE_TIME, STRING, ARRAY, DECIMAL };

◆ ArrowDateTimeType

enum class duckdb::ArrowDateTimeType : uint8_t

strongprotected

                             : uint8_t {
    MILLISECONDS,
    MICROSECONDS,
    NANOSECONDS,
    SECONDS,
    DAYS,
    MONTHS,
    MONTH_DAY_NANO
};

◆ ArrowVariableSizeType

enum class duckdb::ArrowVariableSizeType : uint8_t

strongprotected

37493: uint8_t { NORMAL, FIXED_SIZE, SUPER_SIZE, VIEW };

◆ ArrowArrayPhysicalType

enum class duckdb::ArrowArrayPhysicalType : uint8_t

strongprotected

37503: uint8_t { DICTIONARY_ENCODED, RUN_END_ENCODED, DEFAULT };

◆ DecimalBitWidth

enum class duckdb::DecimalBitWidth : uint8_t

strongprotected

37568: uint8_t { DECIMAL_32, DECIMAL_64, DECIMAL_128, DECIMAL_256 };

◆ AccessMode

enum class duckdb::AccessMode : uint8_t

strong

37939: uint8_t { UNDEFINED = 0, AUTOMATIC = 1, READ_ONLY = 2, READ_WRITE = 3 };

ColorFormat::UNDEFINED

@ UNDEFINED

◆ CacheValidationMode

enum class duckdb::CacheValidationMode : uint8_t

strong

                               : uint8_t {
    // Validate all cache entries, default option.
    VALIDATE_ALL = 0,
    // Validate only remote cache entries.
    VALIDATE_REMOTE = 1,
    // Disable cache validation.
    NO_VALIDATION = 2,
};

                              : uint8_t {
    ALL_LOGS,     // Denormalized: log entries consisting of both the full log entry and the context
    LOG_ENTRIES,  // Normalized: contains only the log entries and a context_id
    LOG_CONTEXTS, // Normalized: contains only the log contexts
};

◆ AttachedDatabaseType

enum class duckdb::AttachedDatabaseType

strongprivate

                                {
    READ_WRITE_DATABASE,
    READ_ONLY_DATABASE,
    SYSTEM_DATABASE,
    TEMP_DATABASE,
};

enum class duckdb::ExtensionABIType : uint8_t

strong

Enumerator
CPP	Uses C++ ABI, version needs to match precisely.
C_STRUCT	Uses C ABI using the duckdb_ext_api_v1 struct, version needs to be equal or higher.
C_STRUCT_UNSTABLE	Uses C ABI using the duckdb_ext_api_v1 struct including "unstable" functions, version needs to match precisely.

                            : uint8_t {
    UNKNOWN = 0,
    CPP = 1,
    C_STRUCT = 2,
    C_STRUCT_UNSTABLE = 3
};

◆ PragmaType

enum class duckdb::PragmaType : uint8_t

strongprivate

43983: uint8_t { PRAGMA_STATEMENT, PRAGMA_CALL };

◆ MemoryTag

enum class duckdb::MemoryTag : uint8_t

strongprivate

                     : uint8_t {
    BASE_TABLE = 0,
    HASH_TABLE = 1,
    PARQUET_READER = 2,
    CSV_READER = 3,
    ORDER_BY = 4,
    ART_INDEX = 5,
    COLUMN_DATA = 6,
    METADATA = 7,
    OVERFLOW_STRINGS = 8,
    IN_MEMORY_TABLE = 9,
    ALLOCATOR = 10,
    EXTENSION = 11,
    TRANSACTION = 12,
    EXTERNAL_FILE_CACHE = 13,
    WINDOW = 14,
    OBJECT_CACHE = 15,
    // Intentionally left as the end, used to indicate memory tag type count.
    UNKNOWN = 16,
};

◆ ConvertToPersistentMode

enum class duckdb::ConvertToPersistentMode

strongprivate

45202{ DESTRUCTIVE, THREAD_SAFE };

◆ DestroyBufferUpon

enum class duckdb::DestroyBufferUpon : uint8_t

strong

Enumerator
EVICTION	Destroy the data buffer upon destroying the associated BlockHandle (block can be evicted)
UNPIN	Destroy the data buffer upon eviction to storage (destroy instead of evict)

                             : uint8_t {
    BLOCK = 0,    
    EVICTION = 1, 
    UNPIN = 2     
};

◆ BlockState

enum class duckdb::BlockState : uint8_t

strong

45605: uint8_t { BLOCK_UNLOADED = 0, BLOCK_LOADED = 1 };

◆ StrTimeSpecifier

enum class duckdb::StrTimeSpecifier : uint8_t

strongprivate

                            : uint8_t {
    ABBREVIATED_WEEKDAY_NAME = 0,    // %a - Abbreviated weekday name. (Sun, Mon, ...)
    FULL_WEEKDAY_NAME = 1,           // %A Full weekday name. (Sunday, Monday, ...)
    WEEKDAY_DECIMAL = 2,             // %w - Weekday as a decimal number. (0, 1, ..., 6)
    DAY_OF_MONTH_PADDED = 3,         // %d - Day of the month as a zero-padded decimal. (01, 02, ..., 31)
    DAY_OF_MONTH = 4,                // %-d - Day of the month as a decimal number. (1, 2, ..., 30)
    ABBREVIATED_MONTH_NAME = 5,      // %b - Abbreviated month name. (Jan, Feb, ..., Dec)
    FULL_MONTH_NAME = 6,             // %B - Full month name. (January, February, ...)
    MONTH_DECIMAL_PADDED = 7,        // %m - Month as a zero-padded decimal number. (01, 02, ..., 12)
    MONTH_DECIMAL = 8,               // %-m - Month as a decimal number. (1, 2, ..., 12)
    YEAR_WITHOUT_CENTURY_PADDED = 9, // %y - Year without century as a zero-padded decimal number. (00, 01, ..., 99)
    YEAR_WITHOUT_CENTURY = 10,       // %-y - Year without century as a decimal number. (0, 1, ..., 99)
    YEAR_DECIMAL = 11,               // %Y - Year with century as a decimal number. (2013, 2019 etc.)
    HOUR_24_PADDED = 12,             // %H - Hour (24-hour clock) as a zero-padded decimal number. (00, 01, ..., 23)
    HOUR_24_DECIMAL = 13,            // %-H - Hour (24-hour clock) as a decimal number. (0, 1, ..., 23)
    HOUR_12_PADDED = 14,             // %I - Hour (12-hour clock) as a zero-padded decimal number. (01, 02, ..., 12)
    HOUR_12_DECIMAL = 15,            // %-I - Hour (12-hour clock) as a decimal number. (1, 2, ... 12)
    AM_PM = 16,                      // %p - Locale’s AM or PM. (AM, PM)
    MINUTE_PADDED = 17,              // %M - Minute as a zero-padded decimal number. (00, 01, ..., 59)
    MINUTE_DECIMAL = 18,             // %-M - Minute as a decimal number. (0, 1, ..., 59)
    SECOND_PADDED = 19,              // %S - Second as a zero-padded decimal number. (00, 01, ..., 59)
    SECOND_DECIMAL = 20,             // %-S - Second as a decimal number. (0, 1, ..., 59)
    MICROSECOND_PADDED = 21,         // %f - Microsecond as a decimal number, zero-padded on the left. (000000 - 999999)
    MILLISECOND_PADDED = 22,         // %g - Millisecond as a decimal number, zero-padded on the left. (000 - 999)
    UTC_OFFSET = 23,                 // %z - UTC offset in the form +HHMM or -HHMM. ( )
    TZ_NAME = 24,                    // %Z - Time zone name. ( )
    DAY_OF_YEAR_PADDED = 25,         // %j - Day of the year as a zero-padded decimal number. (001, 002, ..., 366)
    DAY_OF_YEAR_DECIMAL = 26,        // %-j - Day of the year as a decimal number. (1, 2, ..., 366)
    WEEK_NUMBER_PADDED_SUN_FIRST =
        27, // %U - Week number of the year (Sunday as the first day of the week). All days in a new year preceding the
            // first Sunday are considered to be in week 0. (00, 01, ..., 53)
    WEEK_NUMBER_PADDED_MON_FIRST =
        28, // %W - Week number of the year (Monday as the first day of the week). All days in a new year preceding the
            // first Monday are considered to be in week 0. (00, 01, ..., 53)
    LOCALE_APPROPRIATE_DATE_AND_TIME =
        29, // %c - Locale’s appropriate date and time representation. (Mon Sep 30 07:06:05 2013)
    LOCALE_APPROPRIATE_DATE = 30, // %x - Locale’s appropriate date representation. (09/30/13)
    LOCALE_APPROPRIATE_TIME = 31, // %X - Locale’s appropriate time representation. (07:06:05)
    NANOSECOND_PADDED = 32, // %n - Nanosecond as a decimal number, zero-padded on the left. (000000000 - 999999999)
    // Python 3.6 ISO directives https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes
    YEAR_ISO =
        33, // %G - ISO 8601 year with century representing the year that contains the greater part of the ISO week
    WEEKDAY_ISO = 34,     // %u - ISO 8601 weekday as a decimal number where 1 is Monday (1..7)
    WEEK_NUMBER_ISO = 35, // %V - ISO 8601 week as a decimal number with Monday as the first day of the week.
                          // Week 01 is the week containing Jan 4. (01..53)
};

◆ NewLineIdentifier

enum class duckdb::NewLineIdentifier : uint8_t

strong

                             : uint8_t {
    SINGLE_N = 1, // \n
    CARRY_ON = 2, // \r\n
    NOT_SET = 3,
    SINGLE_R = 4 // \r
 
};

◆ PartitionedColumnDataType

enum class duckdb::PartitionedColumnDataType : uint8_t

strong

Enumerator
RADIX	Radix partitioning on a hash column.
HIVE	Hive-style multi-field partitioning.

                                     : uint8_t {
    INVALID,
    RADIX,
    HIVE
};

◆ DebugVectorVerification

enum class duckdb::DebugVectorVerification : uint8_t

strong

                                   : uint8_t {
    NONE,
    DICTIONARY_EXPRESSION,
    DICTIONARY_OPERATOR,
    CONSTANT_OPERATOR,
    SEQUENCE_OPERATOR,
    NESTED_SHUFFLE,
    VARIANT_VECTOR
};

◆ IndexConstraintType

enum class duckdb::IndexConstraintType : uint8_t

strong

                               : uint8_t {
    NONE = 0,    // index is an index don't built to any constraint
    UNIQUE = 1,  // index is an index built to enforce a UNIQUE constraint
    PRIMARY = 2, // index is an index built to enforce a PRIMARY KEY constraint
    FOREIGN = 3  // index is an index built to enforce a FOREIGN KEY constraint
};

◆ DeprecatedIndexType

enum class duckdb::DeprecatedIndexType : uint8_t

strong

                               : uint8_t {
    INVALID = 0,    // invalid index type
    ART = 1,        // Adaptive Radix Tree
    EXTENSION = 100 // Extension index
};

◆ SampleType

enum class duckdb::SampleType : uint8_t

strongprivate

47730: uint8_t { BLOCKING_SAMPLE = 0, RESERVOIR_SAMPLE = 1, RESERVOIR_PERCENTAGE_SAMPLE = 2 };

◆ SamplingState

enum class duckdb::SamplingState : uint8_t

strongprivate

47732: uint8_t { RANDOM = 0, RESERVOIR = 1 };

◆ HLLStorageType

enum class duckdb::HLLStorageType : uint8_t

strong

Enumerator
HLL_V2	Redis HLL.

                          : uint8_t {
    HLL_V1 = 1, 
    HLL_V2 = 2, 
};

◆ IndexBindState

enum class duckdb::IndexBindState : uint8_t

strongprivate

IndexBindState to transition index binding phases preventing lock order inversion.

50202: uint8_t { UNBOUND, BINDING, BOUND };

◆ IndexRemovalType

enum class duckdb::IndexRemovalType

strongprivate

Enumerator
MAIN_INDEX	Remove from main index, insert into deleted_rows_in_use.
MAIN_INDEX_ONLY	Remove from main index only.
REVERT_MAIN_INDEX	Revert MAIN_INDEX, i.e. append to main index and remove from deleted_rows_in_use.
REVERT_MAIN_INDEX_ONLY	Revert MAIN_INDEX_ONLY, i.e. append to main index.
DELETED_ROWS_IN_USE	Remove from deleted_rows_in_use.

                            {
    MAIN_INDEX,
    MAIN_INDEX_ONLY,
    REVERT_MAIN_INDEX,
    REVERT_MAIN_INDEX_ONLY,
    DELETED_ROWS_IN_USE
};

◆ OptimisticWritePartialManagers

enum class duckdb::OptimisticWritePartialManagers

strong

50719{ PER_COLUMN, GLOBAL };

◆ DataTableVersion

enum class duckdb::DataTableVersion

strong

                            {
    MAIN_TABLE, // this is the newest version of the table - it has not been altered or dropped
    ALTERED,    // this table has been altered
    DROPPED     // this table has been dropped
};

◆ ValueComparisonResult

enum class duckdb::ValueComparisonResult

strongprivate

51270{ PRUNE_LEFT, PRUNE_RIGHT, UNSATISFIABLE_CONDITION, PRUNE_NOTHING };

◆ FilterResult

enum class duckdb::FilterResult

strongprivate

51271{ UNSATISFIABLE, SUCCESS, UNSUPPORTED };

◆ FilterPushdownResult

enum class duckdb::FilterPushdownResult

strongprivate

51272{ NO_PUSHDOWN, PUSHED_DOWN_PARTIALLY, PUSHED_DOWN_FULLY };

◆ MultiFileColumnMappingMode

enum class duckdb::MultiFileColumnMappingMode : uint8_t

strongprotected

51635: uint8_t { BY_NAME, BY_FIELD_ID };

◆ SecretPersistType

enum class duckdb::SecretPersistType : uint8_t

strong

Whether a secret is persistent or temporary.

53134: uint8_t { DEFAULT, TEMPORARY, PERSISTENT };

◆ SecretDisplayType

enum class duckdb::SecretDisplayType : uint8_t

strong

Determines whether the secrets are allowed to be shown.

53187: uint8_t { REDACTED, UNREDACTED };

◆ SecretSerializationType

enum class duckdb::SecretSerializationType : uint8_t

strong

Enumerator
CUSTOM	The secret is serialized with a custom serialization function.
KEY_VALUE_SECRET	The secret has been serialized as a KeyValueSecret.

                                   : uint8_t {
    CUSTOM = 0,
    KEY_VALUE_SECRET = 1
};

◆ CTEMaterialize

enum class duckdb::CTEMaterialize : uint8_t

strongprotected

                          : uint8_t {
    CTE_MATERIALIZE_DEFAULT = 1, /* no option specified */
    CTE_MATERIALIZE_ALWAYS = 2,  /* MATERIALIZED */
    CTE_MATERIALIZE_NEVER = 3    /* NOT MATERIALIZED */
};

◆ QueryNodeType

enum class duckdb::QueryNodeType : uint8_t

strongprivate

                         : uint8_t {
    SELECT_NODE = 1,
    SET_OPERATION_NODE = 2,
    BOUND_SUBQUERY_NODE = 3,
    RECURSIVE_CTE_NODE = 4,
    CTE_NODE = 5,
    STATEMENT_NODE = 6
};

◆ TableReferenceType

enum class duckdb::TableReferenceType : uint8_t

strong

                              : uint8_t {
    INVALID = 0,         // invalid table reference type
    BASE_TABLE = 1,      // base table reference
    SUBQUERY = 2,        // output of a subquery
    JOIN = 3,            // output of join
    TABLE_FUNCTION = 5,  // table producing function
    EXPRESSION_LIST = 6, // expression list
    CTE = 7,             // Recursive CTE
    EMPTY_FROM = 8,      // placeholder for empty FROM
    PIVOT = 9,           // pivot statement
    SHOW_REF = 10,       // SHOW statement
    COLUMN_DATA = 11,    // column data collection
    DELIM_GET = 12,      // Delim get ref
    BOUND_TABLE_REF = 13 // Bound table ref
};

◆ SampleMethod

enum class duckdb::SampleMethod : uint8_t

strong

53691: uint8_t { SYSTEM_SAMPLE = 0, BERNOULLI_SAMPLE = 1, RESERVOIR_SAMPLE = 2, INVALID = 255 };

◆ ExtensionInstallMode

enum class duckdb::ExtensionInstallMode : uint8_t

strong

Enumerator
REPOSITORY	Extension was installed using a url deduced from a repository base url.
CUSTOM_PATH	Extension was install from a custom path, this could be either local or remote.
STATICALLY_LINKED	Extension was statically linked.
NOT_INSTALLED	Extension is not installed, for example the extension might be directly loaded without installing.

                                : uint8_t {
    // Fallback for when install info is missing
    UNKNOWN = 0,
    REPOSITORY = 1,
    CUSTOM_PATH = 2,
    STATICALLY_LINKED = 3,
    NOT_INSTALLED = 4
};

◆ AppenderType

enum class duckdb::AppenderType : uint8_t

strong

                        : uint8_t {
    LOGICAL, // Cast input -> LogicalType
    PHYSICAL // Cast input -> PhysicalType
};

◆ CacheBehavior

enum class duckdb::CacheBehavior

strongprivate

56889{ AUTOMATIC, ALWAYS_CACHE, NEVER_CACHE };

◆ CAPIResultSetType

enum class duckdb::CAPIResultSetType : uint8_t

strongprivate

                             : uint8_t {
    CAPI_RESULT_TYPE_NONE = 0,
    CAPI_RESULT_TYPE_MATERIALIZED,
    CAPI_RESULT_TYPE_STREAMING,
    CAPI_RESULT_TYPE_DEPRECATED
};

◆ CopyToType

enum class duckdb::CopyToType : uint8_t

strong

57841: uint8_t { COPY_TO_FILE, EXPORT_DATABASE };

◆ CopyOptionMode

enum class duckdb::CopyOptionMode

strongprivate

57878{ WRITE_ONLY, READ_ONLY, READ_WRITE };

◆ CopyFunctionExecutionMode

enum class duckdb::CopyFunctionExecutionMode

strongprivate

57992{ REGULAR_COPY_TO_FILE, PARALLEL_COPY_TO_FILE, BATCH_COPY_TO_FILE };

◆ CopyFunctionReturnType

enum class duckdb::CopyFunctionReturnType : uint8_t

strongprivate

                                  : uint8_t {
    CHANGED_ROWS = 0,
    CHANGED_ROWS_AND_FILE_LIST = 1,
    WRITTEN_FILE_STATISTICS = 2
};

Function Documentation

◆ GetDefaultCatalog()

const string & duckdb::GetDefaultCatalog ( CatalogEntryRetriever & retriever )

                                                                  {
    return DatabaseManager::GetDefaultDatabase(retriever.GetContext());
}

◆ GetCatalogEntries()

vector< CatalogSearchEntry > duckdb::GetCatalogEntries	(	CatalogEntryRetriever &	retriever,
		const string &	catalog,
		const string &	schema
	)

                                                                   {
    auto &context = retriever.GetContext();
    vector<CatalogSearchEntry> entries;
    auto &search_path = retriever.GetSearchPath();
    if (IsInvalidCatalog(catalog) && IsInvalidSchema(schema)) {
        // no catalog or schema provided - scan the entire search path
        entries = search_path.Get();
    } else if (IsInvalidCatalog(catalog)) {
        auto catalogs = search_path.GetCatalogsForSchema(schema);
        for (auto &catalog_name : catalogs) {
            entries.emplace_back(catalog_name, schema);
        }
        if (entries.empty()) {
            auto &default_entry = search_path.GetDefault();
            if (!IsInvalidCatalog(default_entry.catalog)) {
                entries.emplace_back(default_entry.catalog, schema);
            } else {
                entries.emplace_back(DatabaseManager::GetDefaultDatabase(context), schema);
            }
        }
    } else if (IsInvalidSchema(schema)) {
        auto schemas = search_path.GetSchemasForCatalog(catalog);
        for (auto &schema_name : schemas) {
            entries.emplace_back(catalog, schema_name);
        }
        if (entries.empty()) {
            auto catalog_entry = Catalog::GetCatalogEntry(context, catalog);
            if (catalog_entry) {
                entries.emplace_back(catalog, catalog_entry->GetDefaultSchema());
            } else {
                entries.emplace_back(catalog, DEFAULT_SCHEMA);
            }
        }
    } else {
        // specific catalog and schema provided
        entries.emplace_back(catalog, schema);
    }
    return entries;
}

◆ FindMinimalQualification()

void duckdb::FindMinimalQualification	(	CatalogEntryRetriever &	retriever,
		const string &	catalog_name,
		const string &	schema_name,
		bool &	qualify_database,
		bool &	qualify_schema
	)

                                                                            {
    // check if we can we qualify ONLY the schema
    bool found = false;
    auto entries = GetCatalogEntries(retriever, INVALID_CATALOG, schema_name);
    for (auto &entry : entries) {
        if (entry.catalog == catalog_name && entry.schema == schema_name) {
            found = true;
            break;
        }
    }
    if (found) {
        qualify_database = false;
        qualify_schema = true;
        return;
    }
    // check if we can qualify ONLY the catalog
    found = false;
    entries = GetCatalogEntries(retriever, catalog_name, INVALID_SCHEMA);
    for (auto &entry : entries) {
        if (entry.catalog == catalog_name && entry.schema == schema_name) {
            found = true;
            break;
        }
    }
    if (found) {
        qualify_database = true;
        qualify_schema = false;
        return;
    }
    // need to qualify both catalog and schema
    qualify_database = true;
    qualify_schema = true;
}

◆ IsAutoloadableFunction()

static bool duckdb::IsAutoloadableFunction ( CatalogType type )

static

                                                     {
    return (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY ||
            type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY);
}

◆ IsTableFunction()

bool duckdb::IsTableFunction ( CatalogType type )

                                       {
    switch (type) {
    case CatalogType::TABLE_FUNCTION_ENTRY:
    case CatalogType::TABLE_MACRO_ENTRY:
    case CatalogType::PRAGMA_FUNCTION_ENTRY:
        return true;
    default:
        return false;
    }
}

◆ IsScalarFunction()

bool duckdb::IsScalarFunction ( CatalogType type )

                                        {
    switch (type) {
    case CatalogType::SCALAR_FUNCTION_ENTRY:
    case CatalogType::AGGREGATE_FUNCTION_ENTRY:
    case CatalogType::MACRO_ENTRY:
        return true;
    default:
        return false;
    }
}

◆ CompareCatalogTypes()

static bool duckdb::CompareCatalogTypes	(	CatalogType	type_a,
		CatalogType	type_b
	)

static

                                                                        {
    if (type_a == type_b) {
        // Types are same
        return true;
    }
    if (IsScalarFunction(type_a) && IsScalarFunction(type_b)) {
        return true;
    }
    if (IsTableFunction(type_a) && IsTableFunction(type_b)) {
        return true;
    }
    return false;
}

◆ ThrowDefaultTableAmbiguityException()

static void duckdb::ThrowDefaultTableAmbiguityException	(	CatalogEntryLookup &	base_lookup,
		CatalogEntryLookup &	default_table,
		const string &	name
	)

static

                                                                    {
    auto entry_type = CatalogTypeToString(base_lookup.entry->type);
    string fully_qualified_name_hint;
    if (base_lookup.schema) {
        fully_qualified_name_hint = StringUtil::Format(": '%s.%s.%s'", base_lookup.schema->catalog.GetName(),
                                                       base_lookup.schema->name, base_lookup.entry->name);
    }
    string fully_qualified_catalog_name_hint = StringUtil::Format(
        ": '%s.%s.%s'", default_table.schema->catalog.GetName(), default_table.schema->name, default_table.entry->name);
    throw CatalogException(
        "Ambiguity detected for '%s': this could either refer to the '%s' '%s', or the "
        "attached catalog '%s' which has a default table. To avoid this error, either detach the catalog and "
        "reattach under a different name, or use a fully qualified name for the '%s'%s or for the Catalog "
        "Default Table%s.",
        name, entry_type, name, name, entry_type, fully_qualified_name_hint, fully_qualified_catalog_name_hint);
}

◆ FindForeignKeyInformation()

static void duckdb::FindForeignKeyInformation	(	TableCatalogEntry &	table,
		AlterForeignKeyType	alter_fk_type,
		vector< unique_ptr< AlterForeignKeyInfo > > &	fk_arrays
	)

static

                                                                                          {
    auto &constraints = table.GetConstraints();
    auto &catalog = table.ParentCatalog();
    auto &name = table.name;
    for (idx_t i = 0; i < constraints.size(); i++) {
        auto &cond = constraints[i];
        if (cond->type != ConstraintType::FOREIGN_KEY) {
            continue;
        }
        auto &fk = cond->Cast<ForeignKeyConstraint>();
        if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
            AlterEntryData alter_data(catalog.GetName(), fk.info.schema, fk.info.table,
                                      OnEntryNotFound::THROW_EXCEPTION);
            fk_arrays.push_back(make_uniq<AlterForeignKeyInfo>(std::move(alter_data), name, fk.pk_columns,
                                                               fk.fk_columns, fk.info.pk_keys, fk.info.fk_keys,
                                                               alter_fk_type));
        } else if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE &&
                   alter_fk_type == AlterForeignKeyType::AFT_DELETE) {
            throw CatalogException("Could not drop the table because this table is main key table of the table \"%s\"",
                                   fk.info.table);
        }
    }
}

◆ GetIndexInfo()

IndexStorageInfo duckdb::GetIndexInfo	(	const IndexConstraintType	type,
		const bool	v1_0_0_storage,
		unique_ptr< CreateInfo > &	info,
		const idx_t	id
	)

                                              {
    auto &table_info = info->Cast<CreateTableInfo>();
    auto constraint_name = EnumUtil::ToString(type) + "_";
    auto name = constraint_name + table_info.table + "_" + to_string(id);
    IndexStorageInfo index_info(name);
    if (!v1_0_0_storage) {
        index_info.options.emplace("v1_0_0_storage", v1_0_0_storage);
    }
    return index_info;
}

◆ CheckTypeIsSupported()

static void duckdb::CheckTypeIsSupported	(	const LogicalType &	logical_type,
		AttachedDatabase &	db
	)

static

                                                                                        {
    TypeVisitor::Contains(logical_type, [&](const LogicalType &type) {
        switch (type.id()) {
        case LogicalTypeId::TYPE: {
            throw InvalidInputException("A table cannot be created with a 'TYPE' column");
        } break;
        case LogicalTypeId::VARIANT: {
            const auto storage_version = db.GetStorageManager().GetStorageVersion();
 
            if (storage_version < Variant::VERSION_ADDED) {
                auto required = GetStorageVersionName(Variant::VERSION_ADDED, false);
                auto current = GetStorageVersionName(storage_version, false);
 
                throw InvalidInputException("VARIANT columns are not supported in storage versions prior to %s "
                                            "(database \"%s\" is using storage version %s)",
                                            required, db.GetName(), current);
            }
        } break;
        case LogicalTypeId::GEOMETRY: {
            const auto storage_version = db.GetStorageManager().GetStorageVersion();
 
            if (GeoType::HasCRS(type) && storage_version < Geometry::VERSION_ADDED) {
                auto required = GetStorageVersionName(Geometry::VERSION_ADDED, false);
                auto current = GetStorageVersionName(storage_version, false);
 
                // TODO: Turn this into a hard error
                auto &logger = Logger::Get(db.GetDatabase());
                logger.WriteLog(DefaultLogType::NAME, LogLevel::LOG_WARNING,
                                "GEOMETRY columns with coordinate reference system identifiers are not supported in "
                                "storage versions prior "
                                "to %s (database \"%s\" is using storage version %s). CRS will not be persisted.",
                                required, db.GetName(), current);
            }
        } break;
        default:
            break;
        }
        return false;
    });
}

◆ RenameExpression()

static void duckdb::RenameExpression	(	ParsedExpression &	root_expr,
		RenameColumnInfo &	info
	)

static

                                                                                  {
    ParsedExpressionIterator::VisitExpressionMutable<ColumnRefExpression>(root_expr, [&](ColumnRefExpression &colref) {
        if (colref.column_names.back() == info.old_name) {
            colref.column_names.back() = info.new_name;
        }
    });
}

◆ PackExpression()

unique_ptr< ParsedExpression > duckdb::PackExpression	(	unique_ptr< ParsedExpression >	expr,
		string	name
	)

                                                                                            {
    expr->SetAlias(std::move(name));
    vector<unique_ptr<ParsedExpression>> children;
    children.push_back(std::move(expr));
    auto res = make_uniq<FunctionExpression>("struct_pack", std::move(children));
    return std::move(res);
}

◆ GetChildList()

static child_list_t< LogicalType > duckdb::GetChildList ( const LogicalType & type )

static

                                                                       {
    child_list_t<LogicalType> child_types;
    switch (type.id()) {
    case LogicalTypeId::LIST: {
        child_types.emplace_back("list", ListType::GetChildType(type));
        break;
    }
    case LogicalTypeId::MAP: {
        child_types.emplace_back("key", MapType::KeyType(type));
        child_types.emplace_back("value", MapType::ValueType(type));
        break;
    }
    case LogicalTypeId::STRUCT: {
        child_types = StructType::GetChildTypes(type);
        break;
    }
    default:
        throw BinderException("Can't ConstructMapping for type '%s'", type.ToString());
    }
    return child_types;
}

◆ ConstructNewType()

static LogicalType duckdb::ConstructNewType	(	const LogicalType &	original_type,
		child_list_t< LogicalType >	new_child_types
	)

static

                                                                                                                 {
    switch (original_type.id()) {
    case LogicalTypeId::STRUCT: {
        return LogicalType::STRUCT(std::move(new_child_types));
    }
    case LogicalTypeId::LIST: {
        D_ASSERT(new_child_types.size() == 1);
        return LogicalType::LIST(new_child_types[0].second);
    }
    case LogicalTypeId::MAP: {
        D_ASSERT(new_child_types.size() == 2);
        return LogicalType::MAP(new_child_types[0].second, new_child_types[1].second);
    }
    default:
        throw BinderException("Type '%s' not supported for ADD COLUMN", original_type.ToString());
    }
}

◆ ConstructMapping()

Value duckdb::ConstructMapping	(	const string &	name,
		const LogicalType &	type
	)

                                                                    {
    if (!type.IsNested()) {
        return Value(name);
    }
    child_list_t<Value> child_mapping;
    auto child_types = GetChildList(type);
    for (auto &entry : child_types) {
        auto mapping_value = ConstructMapping(entry.first, entry.second);
        if (entry.second.IsNested()) {
            child_list_t<Value> child_values;
            child_values.emplace_back(string(), Value(entry.first));
            child_values.emplace_back(string(), std::move(mapping_value));
            mapping_value = Value::STRUCT(std::move(child_values));
        }
        child_mapping.emplace_back(entry.first, std::move(mapping_value));
    }
    return Value::STRUCT(std::move(child_mapping));
}

◆ AddFieldToStruct()

StructMappingInfo duckdb::AddFieldToStruct	(	const LogicalType &	type,
		const vector< string > &	column_path,
		const ColumnDefinition &	new_field,
		idx_t	depth = `0`
	)

                                                                                       {
    if (!type.IsNested()) {
        throw BinderException("Column '%s' is not a nested type, ADD COLUMN can only be used on nested types",
                              column_path[depth]);
    }
 
    StructMappingInfo result;
    auto child_list = GetChildList(type);
    auto &current_component = column_path[depth];
    bool last_entry = depth + 1 == column_path.size();
 
    if (last_entry) {
        if (type.id() != LogicalTypeId::STRUCT) {
            throw BinderException("Column %s is not a struct - ALTER TABLE can only add fields to structs",
                                  current_component);
        }
        // root path - we are adding at this level
        // check if a field with this name already exists
        for (auto &entry : child_list) {
            if (StringUtil::CIEquals(entry.first, new_field.Name())) {
                // already exists!
                result.error = ErrorData(CatalogException("Duplicate field \"%s\" - field already exists in struct %s",
                                                          new_field.Name(), current_component));
                return result;
            }
        }
        // add the new type
        child_list.emplace_back(new_field.Name(), new_field.Type());
        result.new_type = LogicalType::STRUCT(std::move(child_list));
        // set the default value
        unique_ptr<ParsedExpression> default_value;
        if (new_field.HasDefaultValue()) {
            default_value = new_field.DefaultValue().Copy();
        } else {
            default_value = make_uniq<ConstantExpression>(Value(new_field.Type()));
        }
        result.default_value = PackExpression(std::move(default_value), new_field.Name());
        return result;
    }
 
    // not the root path - we need to recurse
    auto &next_component = column_path[depth + 1];
    bool found = false;
    for (auto &entry : child_list) {
        if ((type.id() == LogicalTypeId::LIST && StringUtil::CIEquals(next_component, "element")) ||
            StringUtil::CIEquals(entry.first, next_component)) {
            // found the entry - recurse
            auto child_res = AddFieldToStruct(entry.second, column_path, new_field, depth + 1);
            if (child_res.error.HasError()) {
                return child_res;
            }
            entry.second = std::move(child_res.new_type);
            if (type.id() == LogicalTypeId::LIST) {
                result.default_value = PackExpression(std::move(child_res.default_value), "list");
            } else {
                result.default_value = PackExpression(std::move(child_res.default_value), entry.first);
            }
            found = true;
            break;
        }
    }
    if (!found) {
        throw BinderException("Sub-field %s does not exist in column %s", next_component, column_path[depth]);
    }
    result.new_type = ConstructNewType(type, std::move(child_list));
    return result;
}

◆ DropFieldFromStruct()

DroppedFieldMapping duckdb::DropFieldFromStruct	(	const LogicalType &	type,
		const vector< string > &	column_path,
		idx_t	depth
	)

                                                                                                                 {
    if (!type.IsNested()) {
        throw CatalogException("Cannot drop field from column \"%s\" - not a nested type", column_path[0]);
    }
    auto &dropped_entry = column_path[depth];
    bool last_entry = depth + 1 == column_path.size();
    bool found = false;
    DroppedFieldMapping result;
    child_list_t<Value> child_mapping;
    child_list_t<LogicalType> new_type_children;
    auto child_types = GetChildList(type);
 
    for (auto &entry : child_types) {
        Value mapping_value;
        LogicalType type_value;
        if ((type.id() == LogicalTypeId::LIST && StringUtil::CIEquals(dropped_entry, "element")) ||
            StringUtil::CIEquals(entry.first, dropped_entry)) {
            // this is the entry we are dropping
            found = true;
            if (last_entry) {
                if (type.id() != LogicalTypeId::STRUCT) {
                    throw CatalogException("Cannot drop field '%s' from column '%s' - it's not a struct",
                                           column_path.back(), column_path.front());
                }
                // we are dropping this entry in its entirety - just skip
                if (child_types.size() == 1) {
                    throw CatalogException("Cannot drop field %s from column %s - it is the last field of the struct",
                                           column_path.back(), column_path.front());
                }
                continue;
            } else {
                // we are dropping a field in this entry - recurse
                auto child_result = DropFieldFromStruct(entry.second, column_path, depth + 1);
                if (child_result.error.HasError()) {
                    // bubble up error
                    return child_result;
                }
                mapping_value = std::move(child_result.mapping);
                type_value = std::move(child_result.new_type);
            }
        } else {
            // we are not adjusting this entry - copy the type and create a straightforward mapping
            mapping_value = ConstructMapping(entry.first, entry.second);
            type_value = entry.second;
        }
 
        if (entry.second.IsNested()) {
            child_list_t<Value> child_values;
            child_values.emplace_back(string(), Value(entry.first));
            child_values.emplace_back(string(), std::move(mapping_value));
            mapping_value = Value::STRUCT(std::move(child_values));
        }
        child_mapping.emplace_back(entry.first, std::move(mapping_value));
        new_type_children.emplace_back(entry.first, type_value);
    }
 
    if (!found) {
        result.error = ErrorData(CatalogException("Cannot drop field \"%s\" - it does not exist", dropped_entry));
    } else {
        result.mapping = Value::STRUCT(std::move(child_mapping));
        result.new_type = ConstructNewType(type, std::move(new_type_children));
    }
    return result;
}

◆ RenameFieldFromStruct()

DroppedFieldMapping duckdb::RenameFieldFromStruct	(	const LogicalType &	type,
		const vector< string > &	column_path,
		const string &	new_name,
		idx_t	depth
	)

                                                                               {
    if (!type.IsNested()) {
        throw CatalogException("Cannot rename field from column \"%s\" - not a nested type", column_path[0]);
    }
    auto &rename_entry = column_path[depth];
    bool last_entry = depth + 1 == column_path.size();
    bool found = false;
    DroppedFieldMapping result;
    child_list_t<Value> child_mapping;
    child_list_t<LogicalType> new_type_children;
    auto child_types = GetChildList(type);
    for (auto &entry : child_types) {
        auto field_name = entry.first;
        Value mapping_value;
        LogicalType type_value;
        if ((type.id() == LogicalTypeId::LIST && StringUtil::CIEquals(rename_entry, "element")) ||
            StringUtil::CIEquals(field_name, rename_entry)) {
            // this is the entry we are renaming
            found = true;
            if (last_entry) {
                if (type.id() != LogicalTypeId::STRUCT) {
                    throw CatalogException(
                        "Cannot rename field '%s' from column '%s' - can only rename fields inside a struct",
                        column_path.back(), column_path.front());
                }
                // we are renaming this entry
                for (auto &sub_entry : child_types) {
                    if (StringUtil::CIEquals(new_name, sub_entry.first)) {
                        throw CatalogException(
                            "Cannot rename field %s from column %s to %s - a field with this name already exists",
                            column_path.back(), column_path.front(), new_name);
                    }
                }
                field_name = new_name;
                mapping_value = ConstructMapping(entry.first, entry.second);
                type_value = entry.second;
            } else {
                // we are renaming a field in this entry - recurse
                auto child_result = RenameFieldFromStruct(entry.second, column_path, new_name, depth + 1);
                if (child_result.error.HasError()) {
                    // bubble up error
                    return child_result;
                }
                mapping_value = std::move(child_result.mapping);
                type_value = std::move(child_result.new_type);
            }
        } else {
            // we are not adjusting this entry - copy the type and create a straightforward mapping
            mapping_value = ConstructMapping(entry.first, entry.second);
            type_value = entry.second;
        }
        if (entry.second.IsNested()) {
            child_list_t<Value> child_values;
            child_values.emplace_back(string(), Value(entry.first));
            child_values.emplace_back(string(), std::move(mapping_value));
            mapping_value = Value::STRUCT(std::move(child_values));
        }
        child_mapping.emplace_back(field_name, std::move(mapping_value));
        new_type_children.emplace_back(field_name, type_value);
    }
    if (!found) {
        result.error = ErrorData(CatalogException("Cannot rename field \"%s\" - it does not exist", rename_entry));
    } else {
        result.mapping = Value::STRUCT(std::move(child_mapping));
        result.new_type = ConstructNewType(type, std::move(new_type_children));
    }
    return result;
}

◆ IsDependencyEntry()

static bool duckdb::IsDependencyEntry ( CatalogEntry & entry )

static

                                                   {
    return entry.type == CatalogType::DEPENDENCY_ENTRY;
}

◆ DefaultFunctionMatches()

static bool duckdb::DefaultFunctionMatches	(	const DefaultMacro &	macro,
		const string &	schema,
		const string &	name
	)

staticprivate

                                                                                                        {
    return macro.schema == schema && macro.name == name;
}

◆ GetDefaultFunction()

static unique_ptr< CreateFunctionInfo > duckdb::GetDefaultFunction	(	const string &	input_schema,
		const string &	input_name
	)

staticprivate

                                                                                                               {
    auto schema = StringUtil::Lower(input_schema);
    auto name = StringUtil::Lower(input_name);
    for (idx_t index = 0; internal_macros[index].name != nullptr; index++) {
        if (DefaultFunctionMatches(internal_macros[index], schema, name)) {
            // found the function! keep on iterating to find all overloads
            idx_t overload_count;
            for(overload_count = 1; internal_macros[index + overload_count].name; overload_count++) {
                if (!DefaultFunctionMatches(internal_macros[index + overload_count], schema, name)) {
                    break;
                }
            }
            return DefaultFunctionGenerator::CreateInternalMacroInfo(array_ptr<const DefaultMacro>(internal_macros + index, overload_count));
        }
    }
    return nullptr;
}

◆ GetDefaultTableFunction()

static unique_ptr< CreateFunctionInfo > duckdb::GetDefaultTableFunction	(	const string &	input_schema,
		const string &	input_name
	)

static

                                                                                                                    {
    auto schema = StringUtil::Lower(input_schema);
    auto name = StringUtil::Lower(input_name);
    for (idx_t index = 0; internal_table_macros[index].name != nullptr; index++) {
        if (internal_table_macros[index].schema == schema && internal_table_macros[index].name == name) {
            return DefaultTableFunctionGenerator::CreateTableMacroInfo(internal_table_macros[index]);
        }
    }
    return nullptr;
}

◆ GetDefaultView()

static unique_ptr< CreateViewInfo > duckdb::GetDefaultView	(	ClientContext &	context,
		const string &	input_schema,
		const string &	input_name
	)

static

                                                                                                                               {
    auto schema = StringUtil::Lower(input_schema);
    auto name = StringUtil::Lower(input_name);
    for (idx_t index = 0; internal_views[index].name != nullptr; index++) {
        if (internal_views[index].schema == schema && internal_views[index].name == name) {
            auto result = make_uniq<CreateViewInfo>();
            result->schema = schema;
            result->view_name = name;
            result->sql = internal_views[index].sql;
            result->temporary = true;
            result->internal = true;
 
            return CreateViewInfo::FromSelect(context, std::move(result));
        }
    }
    return nullptr;
}

◆ GetSchema()

static string duckdb::GetSchema ( CatalogEntry & entry )

static

                                             {
    if (entry.type == CatalogType::SCHEMA_ENTRY) {
        return entry.name;
    }
    return entry.ParentSchema().name;
}

◆ AssertMangledName()

static void duckdb::AssertMangledName	(	const string &	mangled_name,
		idx_t	expected_null_bytes
	)

static

                                                                                     {
#ifdef DEBUG
    idx_t nullbyte_count = 0;
    for (auto &ch : mangled_name) {
        nullbyte_count += ch == '\0';
    }
    D_ASSERT(nullbyte_count == expected_null_bytes);
#endif
}

◆ CascadeDrop()

static bool duckdb::CascadeDrop	(	bool	cascade,
		const DependencyDependentFlags &	flags
	)

static

                                                                             {
    if (cascade) {
        return true;
    }
    if (flags.IsOwnedBy()) {
        // We are owned by this object, while it exists we can not be dropped without cascade.
        return false;
    }
    return !flags.IsBlocking();
}

◆ EntryToString()

static string duckdb::EntryToString ( CatalogEntryInfo & info )

static

                                                    {
    auto type = info.type;
    switch (type) {
    case CatalogType::TABLE_ENTRY: {
        return StringUtil::Format("table \"%s\"", info.name);
    }
    case CatalogType::SCHEMA_ENTRY: {
        return StringUtil::Format("schema \"%s\"", info.name);
    }
    case CatalogType::VIEW_ENTRY: {
        return StringUtil::Format("view \"%s\"", info.name);
    }
    case CatalogType::INDEX_ENTRY: {
        return StringUtil::Format("index \"%s\"", info.name);
    }
    case CatalogType::SEQUENCE_ENTRY: {
        return StringUtil::Format("index \"%s\"", info.name);
    }
    case CatalogType::COLLATION_ENTRY: {
        return StringUtil::Format("collation \"%s\"", info.name);
    }
    case CatalogType::COORDINATE_SYSTEM_ENTRY: {
        return StringUtil::Format("coordinate system \"%s\"", info.name);
    }
    case CatalogType::TYPE_ENTRY: {
        return StringUtil::Format("type \"%s\"", info.name);
    }
    case CatalogType::TABLE_FUNCTION_ENTRY: {
        return StringUtil::Format("table function \"%s\"", info.name);
    }
    case CatalogType::SCALAR_FUNCTION_ENTRY: {
        return StringUtil::Format("scalar function \"%s\"", info.name);
    }
    case CatalogType::AGGREGATE_FUNCTION_ENTRY: {
        return StringUtil::Format("aggregate function \"%s\"", info.name);
    }
    case CatalogType::PRAGMA_FUNCTION_ENTRY: {
        return StringUtil::Format("pragma function \"%s\"", info.name);
    }
    case CatalogType::COPY_FUNCTION_ENTRY: {
        return StringUtil::Format("copy function \"%s\"", info.name);
    }
    case CatalogType::MACRO_ENTRY: {
        return StringUtil::Format("macro function \"%s\"", info.name);
    }
    case CatalogType::TABLE_MACRO_ENTRY: {
        return StringUtil::Format("table macro function \"%s\"", info.name);
    }
    case CatalogType::SECRET_ENTRY: {
        return StringUtil::Format("secret \"%s\"", info.name);
    }
    case CatalogType::SECRET_TYPE_ENTRY: {
        return StringUtil::Format("secret type \"%s\"", info.name);
    }
    case CatalogType::SECRET_FUNCTION_ENTRY: {
        return StringUtil::Format("secret function \"%s\"", info.name);
    }
    default:
        throw InternalException("CatalogType not handled in EntryToString (DependencyManager) for %s",
                                CatalogTypeToString(type));
    };
}

◆ FormatString()

static string duckdb::FormatString ( const MangledEntryName & mangled )

static

                                                            {
    auto input = mangled.name;
    for (size_t i = 0; i < input.size(); i++) {
        if (input[i] == '\0') {
            input[i] = '_';
        }
    }
    return input;
}

◆ NullValue() [1/9]

template<class T >

T duckdb::NullValue ( )

inline

Placeholder to insert in Vectors or to use for hashing NULLs.

                     {
    return std::numeric_limits<T>::min();
}

◆ NullValue() [2/9]

template<>

const char * duckdb::NullValue ( )

inline

                               {
    D_ASSERT(str_nil[0] == '\200' && str_nil[1] == '\0' && str_nil[2] == '\0' && str_nil[3] == '\0');
    return str_nil;
}

◆ NullValue() [3/9]

template<>

string_t duckdb::NullValue ( )

inline

                            {
    return string_t(NullValue<const char *>());
}

◆ NullValue() [4/9]

template<>

char * duckdb::NullValue ( )

inline

                         {
    return (char *)NullValue<const char *>(); // NOLINT
}

◆ NullValue() [5/9]

template<>

string duckdb::NullValue ( )

inline

                          {
    return string(NullValue<const char *>());
}

◆ NullValue() [6/9]

template<>

interval_t duckdb::NullValue ( )

inline

                              {
    interval_t null_value;
    null_value.days = NullValue<int32_t>();
    null_value.months = NullValue<int32_t>();
    null_value.micros = NullValue<int64_t>();
    return null_value;
}

◆ NullValue() [7/9]

template<>

hugeint_t duckdb::NullValue ( )

inline

                             {
    hugeint_t min;
    min.lower = 0;
    min.upper = std::numeric_limits<int64_t>::min();
    return min;
}

◆ NullValue() [8/9]

template<>

float duckdb::NullValue ( )

inline

                         {
    return NAN;
}

◆ NullValue() [9/9]

template<>

double duckdb::NullValue ( )

inline

                          {
    return NAN;
}

◆ CastExceptionText()

template<class SRC , class DST >

static string duckdb::CastExceptionText ( SRC input )

static

                                           {
    if (std::is_same<SRC, string_t>()) {
        return "Could not convert string '" + ConvertToString::Operation<SRC>(input) + "' to " +
               TypeIdToString(GetTypeId<DST>());
    }
    if (TypeIsNumber<SRC>() && TypeIsNumber<DST>()) {
        return "Type " + TypeIdToString(GetTypeId<SRC>()) + " with value " + ConvertToString::Operation<SRC>(input) +
               " can't be cast because the value is out of range for the destination type " +
               TypeIdToString(GetTypeId<DST>());
    }
    return "Type " + TypeIdToString(GetTypeId<SRC>()) + " with value " + ConvertToString::Operation<SRC>(input) +
           " can't be cast to the destination type " + TypeIdToString(GetTypeId<DST>());
}

◆ TryCastStringBool()

static bool duckdb::TryCastStringBool	(	const char *	input_data,
		idx_t	input_size,
		bool &	result,
		bool	strict
	)

inlinestatic

                                                                                                          {
    switch (input_size) {
    case 1: {
        unsigned char c = static_cast<uint8_t>(std::tolower(*input_data));
        if (c == 't' || (!strict && c == 'y') || (!strict && c == '1')) {
            result = true;
            return true;
        } else if (c == 'f' || (!strict && c == 'n') || (!strict && c == '0')) {
            result = false;
            return true;
        }
        return false;
    }
    case 2: {
        unsigned char n = static_cast<uint8_t>(std::tolower(input_data[0]));
        unsigned char o = static_cast<uint8_t>(std::tolower(input_data[1]));
        if (n == 'n' && o == 'o') {
            result = false;
            return true;
        }
        return false;
    }
    case 3: {
        unsigned char y = static_cast<uint8_t>(std::tolower(input_data[0]));
        unsigned char e = static_cast<uint8_t>(std::tolower(input_data[1]));
        unsigned char s = static_cast<uint8_t>(std::tolower(input_data[2]));
        if (y == 'y' && e == 'e' && s == 's') {
            result = true;
            return true;
        }
        return false;
    }
    case 4: {
        unsigned char t = static_cast<uint8_t>(std::tolower(input_data[0]));
        unsigned char r = static_cast<uint8_t>(std::tolower(input_data[1]));
        unsigned char u = static_cast<uint8_t>(std::tolower(input_data[2]));
        unsigned char e = static_cast<uint8_t>(std::tolower(input_data[3]));
        if (t == 't' && r == 'r' && u == 'u' && e == 'e') {
            result = true;
            return true;
        }
        return false;
    }
    case 5: {
        unsigned char f = static_cast<uint8_t>(std::tolower(input_data[0]));
        unsigned char a = static_cast<uint8_t>(std::tolower(input_data[1]));
        unsigned char l = static_cast<uint8_t>(std::tolower(input_data[2]));
        unsigned char s = static_cast<uint8_t>(std::tolower(input_data[3]));
        unsigned char e = static_cast<uint8_t>(std::tolower(input_data[4]));
        if (f == 'f' && a == 'a' && l == 'l' && s == 's' && e == 'e') {
            result = false;
            return true;
        }
        return false;
    }
    default:
        return false;
    }
}

◆ MallocTrim()

static void duckdb::MallocTrim ( idx_t pad )

static

                                  {
#ifdef __GLIBC__
    static constexpr int64_t TRIM_INTERVAL_MS = 100;
    static atomic<int64_t> LAST_TRIM_TIMESTAMP_MS {0};
 
    int64_t last_trim_timestamp_ms = LAST_TRIM_TIMESTAMP_MS.load();
    auto current_ts = Timestamp::GetCurrentTimestamp();
    auto current_timestamp_ms = Cast::Operation<timestamp_t, timestamp_ms_t>(current_ts).value;
 
    if (current_timestamp_ms - last_trim_timestamp_ms < TRIM_INTERVAL_MS) {
        return; // We trimmed less than TRIM_INTERVAL_MS ago
    }
    if (!LAST_TRIM_TIMESTAMP_MS.compare_exchange_strong(last_trim_timestamp_ms, current_timestamp_ms,
                                                        std::memory_order_acquire, std::memory_order_relaxed)) {
        return; // Another thread has updated LAST_TRIM_TIMESTAMP_MS since we loaded it
    }
 
    // We successfully updated LAST_TRIM_TIMESTAMP_MS, we can trim
    malloc_trim(pad);
#endif
}

◆ InitializeAppenderForType()

template<class OP >

static void duckdb::InitializeAppenderForType ( ArrowAppendData & append_data )

static

                                                                    {
    append_data.initialize = OP::Initialize;
    append_data.append_vector = OP::Append;
    append_data.finalize = OP::Finalize;
}

◆ InitializeFunctionPointers()

static void duckdb::InitializeFunctionPointers	(	ArrowAppendData &	append_data,
		const LogicalType &	type
	)

static

                                                                                              {
    // handle special logical types
    switch (type.id()) {
    case LogicalTypeId::SQLNULL:
        InitializeAppenderForType<ArrowNullData>(append_data);
        break;
    case LogicalTypeId::BOOLEAN:
        InitializeAppenderForType<ArrowBoolData>(append_data);
        break;
    case LogicalTypeId::TINYINT:
        InitializeAppenderForType<ArrowScalarData<int8_t>>(append_data);
        break;
    case LogicalTypeId::SMALLINT:
        InitializeAppenderForType<ArrowScalarData<int16_t>>(append_data);
        break;
    case LogicalTypeId::DATE:
    case LogicalTypeId::INTEGER:
        InitializeAppenderForType<ArrowScalarData<int32_t>>(append_data);
        break;
    case LogicalTypeId::TIME_TZ: {
        if (append_data.options.arrow_lossless_conversion) {
            InitializeAppenderForType<ArrowScalarData<int64_t>>(append_data);
        } else {
            InitializeAppenderForType<ArrowScalarData<int64_t, dtime_tz_t, ArrowTimeTzConverter>>(append_data);
        }
        break;
    }
    case LogicalTypeId::TIME:
    case LogicalTypeId::TIME_NS:
    case LogicalTypeId::TIMESTAMP_SEC:
    case LogicalTypeId::TIMESTAMP_MS:
    case LogicalTypeId::TIMESTAMP:
    case LogicalTypeId::TIMESTAMP_NS:
    case LogicalTypeId::TIMESTAMP_TZ:
    case LogicalTypeId::BIGINT:
        InitializeAppenderForType<ArrowScalarData<int64_t>>(append_data);
        break;
    case LogicalTypeId::UUID:
        if (append_data.options.arrow_lossless_conversion) {
            InitializeAppenderForType<ArrowScalarData<hugeint_t, hugeint_t, ArrowUUIDBlobConverter>>(append_data);
        } else {
            if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
                InitializeAppenderForType<ArrowVarcharData<hugeint_t, ArrowUUIDConverter>>(append_data);
            } else {
                InitializeAppenderForType<ArrowVarcharData<hugeint_t, ArrowUUIDConverter, int32_t>>(append_data);
            }
        }
        break;
    case LogicalTypeId::HUGEINT:
        InitializeAppenderForType<ArrowScalarData<hugeint_t>>(append_data);
        break;
    case LogicalTypeId::UHUGEINT:
        InitializeAppenderForType<ArrowScalarData<uhugeint_t>>(append_data);
        break;
    case LogicalTypeId::UTINYINT:
        InitializeAppenderForType<ArrowScalarData<uint8_t>>(append_data);
        break;
    case LogicalTypeId::USMALLINT:
        InitializeAppenderForType<ArrowScalarData<uint16_t>>(append_data);
        break;
    case LogicalTypeId::UINTEGER:
        InitializeAppenderForType<ArrowScalarData<uint32_t>>(append_data);
        break;
    case LogicalTypeId::UBIGINT:
        InitializeAppenderForType<ArrowScalarData<uint64_t>>(append_data);
        break;
    case LogicalTypeId::FLOAT:
        InitializeAppenderForType<ArrowScalarData<float>>(append_data);
        break;
    case LogicalTypeId::DOUBLE:
        InitializeAppenderForType<ArrowScalarData<double>>(append_data);
        break;
    case LogicalTypeId::DECIMAL:
        switch (type.InternalType()) {
        case PhysicalType::INT16:
            if (append_data.options.arrow_output_version > ArrowFormatVersion::V1_4) {
                InitializeAppenderForType<ArrowScalarData<int32_t, int16_t>>(append_data);
            } else {
                InitializeAppenderForType<ArrowScalarData<hugeint_t, int16_t>>(append_data);
            }
            break;
        case PhysicalType::INT32:
            if (append_data.options.arrow_output_version > ArrowFormatVersion::V1_4) {
                InitializeAppenderForType<ArrowScalarData<int32_t>>(append_data);
            } else {
                InitializeAppenderForType<ArrowScalarData<hugeint_t, int32_t>>(append_data);
            }
            break;
        case PhysicalType::INT64:
            if (append_data.options.arrow_output_version > ArrowFormatVersion::V1_4) {
                InitializeAppenderForType<ArrowScalarData<int64_t>>(append_data);
            } else {
                InitializeAppenderForType<ArrowScalarData<hugeint_t, int64_t>>(append_data);
            }
            break;
        case PhysicalType::INT128:
            InitializeAppenderForType<ArrowScalarData<hugeint_t>>(append_data);
            break;
        default:
            throw InternalException("Unsupported internal decimal type");
        }
        break;
    case LogicalTypeId::VARCHAR:
    case LogicalTypeId::BLOB:
    case LogicalTypeId::BIT:
    case LogicalTypeId::BIGNUM:
        if ((append_data.options.produce_arrow_string_view || type.id() != LogicalTypeId::VARCHAR) &&
            append_data.options.arrow_output_version >= ArrowFormatVersion::V1_4) {
            InitializeAppenderForType<ArrowVarcharToStringViewData>(append_data);
        } else {
            if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
                InitializeAppenderForType<ArrowVarcharData<>>(append_data);
            } else {
                InitializeAppenderForType<ArrowVarcharData<string_t, ArrowVarcharConverter, int32_t>>(append_data);
            }
        }
        break;
    case LogicalTypeId::ENUM:
        switch (type.InternalType()) {
        case PhysicalType::UINT8:
            InitializeAppenderForType<ArrowEnumData<uint8_t>>(append_data);
            break;
        case PhysicalType::UINT16:
            InitializeAppenderForType<ArrowEnumData<uint16_t>>(append_data);
            break;
        case PhysicalType::UINT32:
            InitializeAppenderForType<ArrowEnumData<uint32_t>>(append_data);
            break;
        default:
            throw InternalException("Unsupported internal enum type");
        }
        break;
    case LogicalTypeId::INTERVAL:
        InitializeAppenderForType<ArrowScalarData<ArrowInterval, interval_t, ArrowIntervalConverter>>(append_data);
        break;
    case LogicalTypeId::UNION:
        InitializeAppenderForType<ArrowUnionData>(append_data);
        break;
    case LogicalTypeId::STRUCT:
        InitializeAppenderForType<ArrowStructData>(append_data);
        break;
    case LogicalTypeId::ARRAY:
        InitializeAppenderForType<ArrowFixedSizeListData>(append_data);
        break;
    case LogicalTypeId::LIST: {
        if (append_data.options.arrow_use_list_view &&
            append_data.options.arrow_output_version >= ArrowFormatVersion::V1_4) {
            if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
                InitializeAppenderForType<ArrowListViewData<>>(append_data);
            } else {
                InitializeAppenderForType<ArrowListViewData<int32_t>>(append_data);
            }
        } else {
            if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
                InitializeAppenderForType<ArrowListData<>>(append_data);
            } else {
                InitializeAppenderForType<ArrowListData<int32_t>>(append_data);
            }
        }
        break;
    }
    case LogicalTypeId::MAP:
        // Arrow MapArray only supports 32-bit offsets. There is no LargeMapArray type in Arrow.
        InitializeAppenderForType<ArrowMapData<int32_t>>(append_data);
        break;
    default:
        throw NotImplementedException("Unsupported type in DuckDB -> Arrow Conversion: %s\n", type.ToString());
    }
}

◆ AddName()

unsafe_unique_array< char > duckdb::AddName ( const string & name )

private

                                                      {
    auto name_ptr = make_unsafe_uniq_array<char>(name.size() + 1);
    for (size_t i = 0; i < name.size(); i++) {
        name_ptr[i] = name[i];
    }
    name_ptr[name.size()] = '\0';
    return name_ptr;
}

◆ ReleaseDuckDBArrowSchema()

static void duckdb::ReleaseDuckDBArrowSchema ( ArrowSchema * schema )

staticprivate

                                                          {
    if (!schema || !schema->release) {
        return;
    }
    schema->release = nullptr;
    auto holder = static_cast<DuckDBArrowSchemaHolder *>(schema->private_data);
    schema->private_data = nullptr;
 
    delete holder;
}

◆ InitializeChild()

void duckdb::InitializeChild	(	ArrowSchema &	child,
		DuckDBArrowSchemaHolder &	root_holder,
		const string &	name = `""`
	)

private

Child is cleaned up by parent

                                                                                                        {
    child.private_data = nullptr;
    child.release = ReleaseDuckDBArrowSchema;
 
    // Store the child schema
    child.flags = ARROW_FLAG_NULLABLE;
    root_holder.owned_type_names.push_back(AddName(name));
 
    child.name = root_holder.owned_type_names.back().get();
    child.n_children = 0;
    child.children = nullptr;
    child.metadata = nullptr;
    child.dictionary = nullptr;
}

Here is the caller graph for this function:

◆ SetArrowFormat()

void duckdb::SetArrowFormat	(	DuckDBArrowSchemaHolder &	root_holder,
		ArrowSchema &	child,
		const LogicalType &	type,
		ClientProperties &	options,
		ClientContext &	context
	)

private

                                                                       {
    if (type.HasAlias()) {
        // If it is a json type, we only export it as json if arrow_lossless_conversion = True
        if (!(type.IsJSONType() && !options.arrow_lossless_conversion)) {
            // If the type has an alias, we check if it is an Arrow-Type extension
            if (SetArrowExtension(root_holder, child, type, context)) {
                return;
            }
        }
    }
    switch (type.id()) {
    case LogicalTypeId::BOOLEAN:
        if (options.arrow_lossless_conversion) {
            SetArrowExtension(root_holder, child, type, context);
        } else {
            child.format = "b";
        }
        break;
    case LogicalTypeId::TINYINT:
        child.format = "c";
        break;
    case LogicalTypeId::SMALLINT:
        child.format = "s";
        break;
    case LogicalTypeId::INTEGER:
        child.format = "i";
        break;
    case LogicalTypeId::BIGINT:
        child.format = "l";
        break;
    case LogicalTypeId::UTINYINT:
        child.format = "C";
        break;
    case LogicalTypeId::USMALLINT:
        child.format = "S";
        break;
    case LogicalTypeId::UINTEGER:
        child.format = "I";
        break;
    case LogicalTypeId::UBIGINT:
        child.format = "L";
        break;
    case LogicalTypeId::FLOAT:
        child.format = "f";
        break;
    case LogicalTypeId::UHUGEINT:
    case LogicalTypeId::HUGEINT: {
        if (options.arrow_lossless_conversion) {
            SetArrowExtension(root_holder, child, type, context);
        } else {
            child.format = "d:38,0";
        }
        break;
    }
    case LogicalTypeId::DOUBLE:
        child.format = "g";
        break;
    case LogicalTypeId::UUID: {
        if (options.arrow_lossless_conversion) {
            SetArrowExtension(root_holder, child, type, context);
        } else {
            if (options.produce_arrow_string_view && options.arrow_output_version >= ArrowFormatVersion::V1_4) {
                // List views are only introduced in arrow format v1.4
                child.format = "vu";
            } else {
                if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
                    child.format = "U";
                } else {
                    child.format = "u";
                }
            }
        }
        break;
    }
    case LogicalTypeId::VARCHAR:
        if (options.produce_arrow_string_view && options.arrow_output_version >= ArrowFormatVersion::V1_4) {
            // List views are only introduced in arrow format v1.4
            child.format = "vu";
        } else {
            if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
                child.format = "U";
            } else {
                child.format = "u";
            }
        }
        break;
    case LogicalTypeId::DATE:
        child.format = "tdD";
        break;
    case LogicalTypeId::TIME_TZ: {
        if (options.arrow_lossless_conversion) {
            SetArrowExtension(root_holder, child, type, context);
        } else {
            child.format = "ttu";
        }
        break;
    }
    case LogicalTypeId::TIME:
        child.format = "ttu";
        break;
    case LogicalTypeId::TIME_NS:
        child.format = "ttn";
        break;
    case LogicalTypeId::TIMESTAMP:
        child.format = "tsu:";
        break;
    case LogicalTypeId::TIMESTAMP_TZ: {
        string format = "tsu:" + options.time_zone;
        root_holder.owned_type_names.push_back(AddName(format));
        child.format = root_holder.owned_type_names.back().get();
        break;
    }
    case LogicalTypeId::TIMESTAMP_SEC:
        child.format = "tss:";
        break;
    case LogicalTypeId::TIMESTAMP_NS:
        child.format = "tsn:";
        break;
    case LogicalTypeId::TIMESTAMP_MS:
        child.format = "tsm:";
        break;
    case LogicalTypeId::INTERVAL:
        child.format = "tin";
        break;
    case LogicalTypeId::DECIMAL: {
        uint8_t width, scale, bit_width;
        if (options.arrow_output_version <= ArrowFormatVersion::V1_4) {
            // Before version 1.4 all decimals were int128
            bit_width = 128;
        } else {
            switch (type.InternalType()) {
            case PhysicalType::INT16:
            case PhysicalType::INT32:
                bit_width = 32;
                break;
            case PhysicalType::INT64:
                bit_width = 64;
                break;
            case PhysicalType::INT128:
                bit_width = 128;
                break;
            default:
                throw NotImplementedException("Unsupported internal type For DUCKDB Decimal -> Arrow ");
            }
        }
 
        type.GetDecimalProperties(width, scale);
        string format = "d:" + to_string(width) + "," + to_string(scale) + "," + to_string(bit_width);
        root_holder.owned_type_names.push_back(AddName(format));
        child.format = root_holder.owned_type_names.back().get();
        break;
    }
    case LogicalTypeId::SQLNULL: {
        child.format = "n";
        break;
    }
    case LogicalTypeId::BLOB:
        if (options.arrow_output_version >= ArrowFormatVersion::V1_4) {
            // Views are only introduced in arrow format v1.4
            child.format = "vz";
        } else if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
            child.format = "Z";
        } else {
            child.format = "z";
        }
        break;
    case LogicalTypeId::BIT: {
        if (options.arrow_lossless_conversion) {
            SetArrowExtension(root_holder, child, type, context);
        } else {
            if (options.arrow_output_version >= ArrowFormatVersion::V1_4) {
                // Views are only introduced in arrow format v1.4
                child.format = "vz";
            } else if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
                child.format = "Z";
            } else {
                child.format = "z";
            }
        }
 
        break;
    }
    case LogicalTypeId::LIST: {
        if (options.arrow_use_list_view && options.arrow_output_version >= ArrowFormatVersion::V1_4) {
            // List views are only introduced in arrow format v1.4
            if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
                child.format = "+vL";
            } else {
                child.format = "+vl";
            }
        } else {
            if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
                child.format = "+L";
            } else {
                child.format = "+l";
            }
        }
        child.n_children = 1;
        root_holder.nested_children.emplace_back();
        root_holder.nested_children.back().resize(1);
        root_holder.nested_children_ptr.emplace_back();
        root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
        InitializeChild(root_holder.nested_children.back()[0], root_holder);
        child.children = &root_holder.nested_children_ptr.back()[0];
        child.children[0]->name = "l";
        SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), options, context);
        break;
    }
    case LogicalTypeId::STRUCT: {
        SetArrowStructFormat(root_holder, child, type, options, context);
        break;
    }
    case LogicalTypeId::ARRAY: {
        auto array_size = ArrayType::GetSize(type);
        auto &child_type = ArrayType::GetChildType(type);
        auto format = "+w:" + to_string(array_size);
        root_holder.owned_type_names.push_back(AddName(format));
        child.format = root_holder.owned_type_names.back().get();
 
        child.n_children = 1;
        root_holder.nested_children.emplace_back();
        root_holder.nested_children.back().resize(1);
        root_holder.nested_children_ptr.emplace_back();
        root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
        InitializeChild(root_holder.nested_children.back()[0], root_holder);
        child.children = &root_holder.nested_children_ptr.back()[0];
        SetArrowFormat(root_holder, **child.children, child_type, options, context);
        break;
    }
    case LogicalTypeId::MAP: {
        SetArrowMapFormat(root_holder, child, type, options, context);
        break;
    }
    case LogicalTypeId::UNION: {
        std::string format = "+us:";
 
        auto &child_types = UnionType::CopyMemberTypes(type);
        child.n_children = NumericCast<int64_t>(child_types.size());
        root_holder.nested_children.emplace_back();
        root_holder.nested_children.back().resize(child_types.size());
        root_holder.nested_children_ptr.emplace_back();
        root_holder.nested_children_ptr.back().resize(child_types.size());
        for (idx_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
            root_holder.nested_children_ptr.back()[type_idx] = &root_holder.nested_children.back()[type_idx];
        }
        child.children = &root_holder.nested_children_ptr.back()[0];
        for (size_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
            InitializeChild(*child.children[type_idx], root_holder);
 
            root_holder.owned_type_names.push_back(AddName(child_types[type_idx].first));
 
            child.children[type_idx]->name = root_holder.owned_type_names.back().get();
            SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, options, context);
 
            format += to_string(type_idx) + ",";
        }
 
        format.pop_back();
 
        root_holder.owned_type_names.push_back(AddName(format));
        child.format = root_holder.owned_type_names.back().get();
 
        break;
    }
    case LogicalTypeId::ENUM: {
        // TODO what do we do with pointer enums here?
        switch (EnumType::GetPhysicalType(type)) {
        case PhysicalType::UINT8:
            child.format = "C";
            break;
        case PhysicalType::UINT16:
            child.format = "S";
            break;
        case PhysicalType::UINT32:
            child.format = "I";
            break;
        default:
            throw InternalException("Unsupported Enum Internal Type");
        }
        root_holder.nested_children.emplace_back();
        root_holder.nested_children.back().resize(1);
        root_holder.nested_children_ptr.emplace_back();
        root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
        InitializeChild(root_holder.nested_children.back()[0], root_holder);
        child.dictionary = root_holder.nested_children_ptr.back()[0];
        child.dictionary->format = "u";
        break;
    }
    default: {
        // It is possible we can export this type as a registered extension
        auto success = SetArrowExtension(root_holder, child, type, context);
        if (!success) {
            throw NotImplementedException("Unsupported Arrow type %s", type.ToString());
        }
    }
    }
}

◆ SetArrowStructFormat()

void duckdb::SetArrowStructFormat	(	DuckDBArrowSchemaHolder &	root_holder,
		ArrowSchema &	child,
		const LogicalType &	type,
		ClientProperties &	options,
		ClientContext &	context,
		bool	map_is_parent = `false`
	)

private

                                                                                                         {
    child.format = "+s";
    auto &child_types = StructType::GetChildTypes(type);
    child.n_children = NumericCast<int64_t>(child_types.size());
    root_holder.nested_children.emplace_back();
    root_holder.nested_children.back().resize(child_types.size());
    root_holder.nested_children_ptr.emplace_back();
    root_holder.nested_children_ptr.back().resize(child_types.size());
    for (idx_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
        root_holder.nested_children_ptr.back()[type_idx] = &root_holder.nested_children.back()[type_idx];
    }
    child.children = &root_holder.nested_children_ptr.back()[0];
    for (size_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
        InitializeChild(*child.children[type_idx], root_holder);
        root_holder.owned_type_names.push_back(AddName(child_types[type_idx].first));
        child.children[type_idx]->name = root_holder.owned_type_names.back().get();
        SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, options, context);
    }
    if (map_is_parent) {
        child.children[0]->flags = 0; // Set the 'keys' field to non-nullable
    }
}

◆ SetArrowMapFormat()

void duckdb::SetArrowMapFormat	(	DuckDBArrowSchemaHolder &	root_holder,
		ArrowSchema &	child,
		const LogicalType &	type,
		ClientProperties &	options,
		ClientContext &	context
	)

private

Map has one child which is a struct

                                                                          {
    child.format = "+m";
    child.n_children = 1;
    root_holder.nested_children.emplace_back();
    root_holder.nested_children.back().resize(1);
    root_holder.nested_children_ptr.emplace_back();
    root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
    InitializeChild(root_holder.nested_children.back()[0], root_holder);
    child.children = &root_holder.nested_children_ptr.back()[0];
    child.children[0]->name = "entries";
    child.children[0]->flags = 0; // Set the 'entries' field to non-nullable
    SetArrowStructFormat(root_holder, **child.children, ListType::GetChildType(type), options, context, true);
}

Here is the call graph for this function:

◆ SetArrowExtension()

bool duckdb::SetArrowExtension	(	DuckDBArrowSchemaHolder &	root_holder,
		ArrowSchema &	child,
		const LogicalType &	type,
		ClientContext &	context
	)

private

                                               {
    auto &config = DBConfig::GetConfig(context);
    if (config.HasArrowExtension(type)) {
        auto arrow_extension = config.GetArrowExtension(type);
        arrow_extension.PopulateArrowSchema(root_holder, child, type, context, arrow_extension);
        return true;
    }
    return false;
}

◆ FastMemcpy()

void duckdb::FastMemcpy	(	void *	dest,
		const void *	src,
		const size_t	size
	)

inlineprivate

This templated memcpy is significantly faster than std::memcpy, but only when you are calling memcpy with a const size in a loop. For instance while (<cond>) { memcpy(<dest>, <src>, const_size); ... }

                                                                       {
    // LCOV_EXCL_START
    switch (size) {
    case 0:
        return;
    case 1:
        return MemcpyFixed<1>(dest, src);
    case 2:
        return MemcpyFixed<2>(dest, src);
    case 3:
        return MemcpyFixed<3>(dest, src);
    case 4:
        return MemcpyFixed<4>(dest, src);
    case 5:
        return MemcpyFixed<5>(dest, src);
    case 6:
        return MemcpyFixed<6>(dest, src);
    case 7:
        return MemcpyFixed<7>(dest, src);
    case 8:
        return MemcpyFixed<8>(dest, src);
    case 9:
        return MemcpyFixed<9>(dest, src);
    case 10:
        return MemcpyFixed<10>(dest, src);
    case 11:
        return MemcpyFixed<11>(dest, src);
    case 12:
        return MemcpyFixed<12>(dest, src);
    case 13:
        return MemcpyFixed<13>(dest, src);
    case 14:
        return MemcpyFixed<14>(dest, src);
    case 15:
        return MemcpyFixed<15>(dest, src);
    case 16:
        return MemcpyFixed<16>(dest, src);
    case 17:
        return MemcpyFixed<17>(dest, src);
    case 18:
        return MemcpyFixed<18>(dest, src);
    case 19:
        return MemcpyFixed<19>(dest, src);
    case 20:
        return MemcpyFixed<20>(dest, src);
    case 21:
        return MemcpyFixed<21>(dest, src);
    case 22:
        return MemcpyFixed<22>(dest, src);
    case 23:
        return MemcpyFixed<23>(dest, src);
    case 24:
        return MemcpyFixed<24>(dest, src);
    case 25:
        return MemcpyFixed<25>(dest, src);
    case 26:
        return MemcpyFixed<26>(dest, src);
    case 27:
        return MemcpyFixed<27>(dest, src);
    case 28:
        return MemcpyFixed<28>(dest, src);
    case 29:
        return MemcpyFixed<29>(dest, src);
    case 30:
        return MemcpyFixed<30>(dest, src);
    case 31:
        return MemcpyFixed<31>(dest, src);
    case 32:
        return MemcpyFixed<32>(dest, src);
    case 33:
        return MemcpyFixed<33>(dest, src);
    case 34:
        return MemcpyFixed<34>(dest, src);
    case 35:
        return MemcpyFixed<35>(dest, src);
    case 36:
        return MemcpyFixed<36>(dest, src);
    case 37:
        return MemcpyFixed<37>(dest, src);
    case 38:
        return MemcpyFixed<38>(dest, src);
    case 39:
        return MemcpyFixed<39>(dest, src);
    case 40:
        return MemcpyFixed<40>(dest, src);
    case 41:
        return MemcpyFixed<41>(dest, src);
    case 42:
        return MemcpyFixed<42>(dest, src);
    case 43:
        return MemcpyFixed<43>(dest, src);
    case 44:
        return MemcpyFixed<44>(dest, src);
    case 45:
        return MemcpyFixed<45>(dest, src);
    case 46:
        return MemcpyFixed<46>(dest, src);
    case 47:
        return MemcpyFixed<47>(dest, src);
    case 48:
        return MemcpyFixed<48>(dest, src);
    case 49:
        return MemcpyFixed<49>(dest, src);
    case 50:
        return MemcpyFixed<50>(dest, src);
    case 51:
        return MemcpyFixed<51>(dest, src);
    case 52:
        return MemcpyFixed<52>(dest, src);
    case 53:
        return MemcpyFixed<53>(dest, src);
    case 54:
        return MemcpyFixed<54>(dest, src);
    case 55:
        return MemcpyFixed<55>(dest, src);
    case 56:
        return MemcpyFixed<56>(dest, src);
    case 57:
        return MemcpyFixed<57>(dest, src);
    case 58:
        return MemcpyFixed<58>(dest, src);
    case 59:
        return MemcpyFixed<59>(dest, src);
    case 60:
        return MemcpyFixed<60>(dest, src);
    case 61:
        return MemcpyFixed<61>(dest, src);
    case 62:
        return MemcpyFixed<62>(dest, src);
    case 63:
        return MemcpyFixed<63>(dest, src);
    case 64:
        return MemcpyFixed<64>(dest, src);
    case 65:
        return MemcpyFixed<65>(dest, src);
    case 66:
        return MemcpyFixed<66>(dest, src);
    case 67:
        return MemcpyFixed<67>(dest, src);
    case 68:
        return MemcpyFixed<68>(dest, src);
    case 69:
        return MemcpyFixed<69>(dest, src);
    case 70:
        return MemcpyFixed<70>(dest, src);
    case 71:
        return MemcpyFixed<71>(dest, src);
    case 72:
        return MemcpyFixed<72>(dest, src);
    case 73:
        return MemcpyFixed<73>(dest, src);
    case 74:
        return MemcpyFixed<74>(dest, src);
    case 75:
        return MemcpyFixed<75>(dest, src);
    case 76:
        return MemcpyFixed<76>(dest, src);
    case 77:
        return MemcpyFixed<77>(dest, src);
    case 78:
        return MemcpyFixed<78>(dest, src);
    case 79:
        return MemcpyFixed<79>(dest, src);
    case 80:
        return MemcpyFixed<80>(dest, src);
    case 81:
        return MemcpyFixed<81>(dest, src);
    case 82:
        return MemcpyFixed<82>(dest, src);
    case 83:
        return MemcpyFixed<83>(dest, src);
    case 84:
        return MemcpyFixed<84>(dest, src);
    case 85:
        return MemcpyFixed<85>(dest, src);
    case 86:
        return MemcpyFixed<86>(dest, src);
    case 87:
        return MemcpyFixed<87>(dest, src);
    case 88:
        return MemcpyFixed<88>(dest, src);
    case 89:
        return MemcpyFixed<89>(dest, src);
    case 90:
        return MemcpyFixed<90>(dest, src);
    case 91:
        return MemcpyFixed<91>(dest, src);
    case 92:
        return MemcpyFixed<92>(dest, src);
    case 93:
        return MemcpyFixed<93>(dest, src);
    case 94:
        return MemcpyFixed<94>(dest, src);
    case 95:
        return MemcpyFixed<95>(dest, src);
    case 96:
        return MemcpyFixed<96>(dest, src);
    case 97:
        return MemcpyFixed<97>(dest, src);
    case 98:
        return MemcpyFixed<98>(dest, src);
    case 99:
        return MemcpyFixed<99>(dest, src);
    case 100:
        return MemcpyFixed<100>(dest, src);
    case 101:
        return MemcpyFixed<101>(dest, src);
    case 102:
        return MemcpyFixed<102>(dest, src);
    case 103:
        return MemcpyFixed<103>(dest, src);
    case 104:
        return MemcpyFixed<104>(dest, src);
    case 105:
        return MemcpyFixed<105>(dest, src);
    case 106:
        return MemcpyFixed<106>(dest, src);
    case 107:
        return MemcpyFixed<107>(dest, src);
    case 108:
        return MemcpyFixed<108>(dest, src);
    case 109:
        return MemcpyFixed<109>(dest, src);
    case 110:
        return MemcpyFixed<110>(dest, src);
    case 111:
        return MemcpyFixed<111>(dest, src);
    case 112:
        return MemcpyFixed<112>(dest, src);
    case 113:
        return MemcpyFixed<113>(dest, src);
    case 114:
        return MemcpyFixed<114>(dest, src);
    case 115:
        return MemcpyFixed<115>(dest, src);
    case 116:
        return MemcpyFixed<116>(dest, src);
    case 117:
        return MemcpyFixed<117>(dest, src);
    case 118:
        return MemcpyFixed<118>(dest, src);
    case 119:
        return MemcpyFixed<119>(dest, src);
    case 120:
        return MemcpyFixed<120>(dest, src);
    case 121:
        return MemcpyFixed<121>(dest, src);
    case 122:
        return MemcpyFixed<122>(dest, src);
    case 123:
        return MemcpyFixed<123>(dest, src);
    case 124:
        return MemcpyFixed<124>(dest, src);
    case 125:
        return MemcpyFixed<125>(dest, src);
    case 126:
        return MemcpyFixed<126>(dest, src);
    case 127:
        return MemcpyFixed<127>(dest, src);
    case 128:
        return MemcpyFixed<128>(dest, src);
    case 129:
        return MemcpyFixed<129>(dest, src);
    case 130:
        return MemcpyFixed<130>(dest, src);
    case 131:
        return MemcpyFixed<131>(dest, src);
    case 132:
        return MemcpyFixed<132>(dest, src);
    case 133:
        return MemcpyFixed<133>(dest, src);
    case 134:
        return MemcpyFixed<134>(dest, src);
    case 135:
        return MemcpyFixed<135>(dest, src);
    case 136:
        return MemcpyFixed<136>(dest, src);
    case 137:
        return MemcpyFixed<137>(dest, src);
    case 138:
        return MemcpyFixed<138>(dest, src);
    case 139:
        return MemcpyFixed<139>(dest, src);
    case 140:
        return MemcpyFixed<140>(dest, src);
    case 141:
        return MemcpyFixed<141>(dest, src);
    case 142:
        return MemcpyFixed<142>(dest, src);
    case 143:
        return MemcpyFixed<143>(dest, src);
    case 144:
        return MemcpyFixed<144>(dest, src);
    case 145:
        return MemcpyFixed<145>(dest, src);
    case 146:
        return MemcpyFixed<146>(dest, src);
    case 147:
        return MemcpyFixed<147>(dest, src);
    case 148:
        return MemcpyFixed<148>(dest, src);
    case 149:
        return MemcpyFixed<149>(dest, src);
    case 150:
        return MemcpyFixed<150>(dest, src);
    case 151:
        return MemcpyFixed<151>(dest, src);
    case 152:
        return MemcpyFixed<152>(dest, src);
    case 153:
        return MemcpyFixed<153>(dest, src);
    case 154:
        return MemcpyFixed<154>(dest, src);
    case 155:
        return MemcpyFixed<155>(dest, src);
    case 156:
        return MemcpyFixed<156>(dest, src);
    case 157:
        return MemcpyFixed<157>(dest, src);
    case 158:
        return MemcpyFixed<158>(dest, src);
    case 159:
        return MemcpyFixed<159>(dest, src);
    case 160:
        return MemcpyFixed<160>(dest, src);
    case 161:
        return MemcpyFixed<161>(dest, src);
    case 162:
        return MemcpyFixed<162>(dest, src);
    case 163:
        return MemcpyFixed<163>(dest, src);
    case 164:
        return MemcpyFixed<164>(dest, src);
    case 165:
        return MemcpyFixed<165>(dest, src);
    case 166:
        return MemcpyFixed<166>(dest, src);
    case 167:
        return MemcpyFixed<167>(dest, src);
    case 168:
        return MemcpyFixed<168>(dest, src);
    case 169:
        return MemcpyFixed<169>(dest, src);
    case 170:
        return MemcpyFixed<170>(dest, src);
    case 171:
        return MemcpyFixed<171>(dest, src);
    case 172:
        return MemcpyFixed<172>(dest, src);
    case 173:
        return MemcpyFixed<173>(dest, src);
    case 174:
        return MemcpyFixed<174>(dest, src);
    case 175:
        return MemcpyFixed<175>(dest, src);
    case 176:
        return MemcpyFixed<176>(dest, src);
    case 177:
        return MemcpyFixed<177>(dest, src);
    case 178:
        return MemcpyFixed<178>(dest, src);
    case 179:
        return MemcpyFixed<179>(dest, src);
    case 180:
        return MemcpyFixed<180>(dest, src);
    case 181:
        return MemcpyFixed<181>(dest, src);
    case 182:
        return MemcpyFixed<182>(dest, src);
    case 183:
        return MemcpyFixed<183>(dest, src);
    case 184:
        return MemcpyFixed<184>(dest, src);
    case 185:
        return MemcpyFixed<185>(dest, src);
    case 186:
        return MemcpyFixed<186>(dest, src);
    case 187:
        return MemcpyFixed<187>(dest, src);
    case 188:
        return MemcpyFixed<188>(dest, src);
    case 189:
        return MemcpyFixed<189>(dest, src);
    case 190:
        return MemcpyFixed<190>(dest, src);
    case 191:
        return MemcpyFixed<191>(dest, src);
    case 192:
        return MemcpyFixed<192>(dest, src);
    case 193:
        return MemcpyFixed<193>(dest, src);
    case 194:
        return MemcpyFixed<194>(dest, src);
    case 195:
        return MemcpyFixed<195>(dest, src);
    case 196:
        return MemcpyFixed<196>(dest, src);
    case 197:
        return MemcpyFixed<197>(dest, src);
    case 198:
        return MemcpyFixed<198>(dest, src);
    case 199:
        return MemcpyFixed<199>(dest, src);
    case 200:
        return MemcpyFixed<200>(dest, src);
    case 201:
        return MemcpyFixed<201>(dest, src);
    case 202:
        return MemcpyFixed<202>(dest, src);
    case 203:
        return MemcpyFixed<203>(dest, src);
    case 204:
        return MemcpyFixed<204>(dest, src);
    case 205:
        return MemcpyFixed<205>(dest, src);
    case 206:
        return MemcpyFixed<206>(dest, src);
    case 207:
        return MemcpyFixed<207>(dest, src);
    case 208:
        return MemcpyFixed<208>(dest, src);
    case 209:
        return MemcpyFixed<209>(dest, src);
    case 210:
        return MemcpyFixed<210>(dest, src);
    case 211:
        return MemcpyFixed<211>(dest, src);
    case 212:
        return MemcpyFixed<212>(dest, src);
    case 213:
        return MemcpyFixed<213>(dest, src);
    case 214:
        return MemcpyFixed<214>(dest, src);
    case 215:
        return MemcpyFixed<215>(dest, src);
    case 216:
        return MemcpyFixed<216>(dest, src);
    case 217:
        return MemcpyFixed<217>(dest, src);
    case 218:
        return MemcpyFixed<218>(dest, src);
    case 219:
        return MemcpyFixed<219>(dest, src);
    case 220:
        return MemcpyFixed<220>(dest, src);
    case 221:
        return MemcpyFixed<221>(dest, src);
    case 222:
        return MemcpyFixed<222>(dest, src);
    case 223:
        return MemcpyFixed<223>(dest, src);
    case 224:
        return MemcpyFixed<224>(dest, src);
    case 225:
        return MemcpyFixed<225>(dest, src);
    case 226:
        return MemcpyFixed<226>(dest, src);
    case 227:
        return MemcpyFixed<227>(dest, src);
    case 228:
        return MemcpyFixed<228>(dest, src);
    case 229:
        return MemcpyFixed<229>(dest, src);
    case 230:
        return MemcpyFixed<230>(dest, src);
    case 231:
        return MemcpyFixed<231>(dest, src);
    case 232:
        return MemcpyFixed<232>(dest, src);
    case 233:
        return MemcpyFixed<233>(dest, src);
    case 234:
        return MemcpyFixed<234>(dest, src);
    case 235:
        return MemcpyFixed<235>(dest, src);
    case 236:
        return MemcpyFixed<236>(dest, src);
    case 237:
        return MemcpyFixed<237>(dest, src);
    case 238:
        return MemcpyFixed<238>(dest, src);
    case 239:
        return MemcpyFixed<239>(dest, src);
    case 240:
        return MemcpyFixed<240>(dest, src);
    case 241:
        return MemcpyFixed<241>(dest, src);
    case 242:
        return MemcpyFixed<242>(dest, src);
    case 243:
        return MemcpyFixed<243>(dest, src);
    case 244:
        return MemcpyFixed<244>(dest, src);
    case 245:
        return MemcpyFixed<245>(dest, src);
    case 246:
        return MemcpyFixed<246>(dest, src);
    case 247:
        return MemcpyFixed<247>(dest, src);
    case 248:
        return MemcpyFixed<248>(dest, src);
    case 249:
        return MemcpyFixed<249>(dest, src);
    case 250:
        return MemcpyFixed<250>(dest, src);
    case 251:
        return MemcpyFixed<251>(dest, src);
    case 252:
        return MemcpyFixed<252>(dest, src);
    case 253:
        return MemcpyFixed<253>(dest, src);
    case 254:
        return MemcpyFixed<254>(dest, src);
    case 255:
        return MemcpyFixed<255>(dest, src);
    case 256:
        return MemcpyFixed<256>(dest, src);
    default:
        memcpy(dest, src, size);
    }
    // LCOV_EXCL_STOP
}

Here is the call graph for this function:

◆ FastMemcmp()

int duckdb::FastMemcmp	(	const void *	str1,
		const void *	str2,
		const size_t	size
	)

inlineprivate

This templated memcmp is significantly faster than std::memcmp, but only when you are calling memcmp with a const size in a loop. For instance while (<cond>) { memcmp(<str1>, <str2>, const_size); ... }

                                                                             {
    // LCOV_EXCL_START
    switch (size) {
    case 0:
        return 0;
    case 1:
        return MemcmpFixed<1>(str1, str2);
    case 2:
        return MemcmpFixed<2>(str1, str2);
    case 3:
        return MemcmpFixed<3>(str1, str2);
    case 4:
        return MemcmpFixed<4>(str1, str2);
    case 5:
        return MemcmpFixed<5>(str1, str2);
    case 6:
        return MemcmpFixed<6>(str1, str2);
    case 7:
        return MemcmpFixed<7>(str1, str2);
    case 8:
        return MemcmpFixed<8>(str1, str2);
    case 9:
        return MemcmpFixed<9>(str1, str2);
    case 10:
        return MemcmpFixed<10>(str1, str2);
    case 11:
        return MemcmpFixed<11>(str1, str2);
    case 12:
        return MemcmpFixed<12>(str1, str2);
    case 13:
        return MemcmpFixed<13>(str1, str2);
    case 14:
        return MemcmpFixed<14>(str1, str2);
    case 15:
        return MemcmpFixed<15>(str1, str2);
    case 16:
        return MemcmpFixed<16>(str1, str2);
    case 17:
        return MemcmpFixed<17>(str1, str2);
    case 18:
        return MemcmpFixed<18>(str1, str2);
    case 19:
        return MemcmpFixed<19>(str1, str2);
    case 20:
        return MemcmpFixed<20>(str1, str2);
    case 21:
        return MemcmpFixed<21>(str1, str2);
    case 22:
        return MemcmpFixed<22>(str1, str2);
    case 23:
        return MemcmpFixed<23>(str1, str2);
    case 24:
        return MemcmpFixed<24>(str1, str2);
    case 25:
        return MemcmpFixed<25>(str1, str2);
    case 26:
        return MemcmpFixed<26>(str1, str2);
    case 27:
        return MemcmpFixed<27>(str1, str2);
    case 28:
        return MemcmpFixed<28>(str1, str2);
    case 29:
        return MemcmpFixed<29>(str1, str2);
    case 30:
        return MemcmpFixed<30>(str1, str2);
    case 31:
        return MemcmpFixed<31>(str1, str2);
    case 32:
        return MemcmpFixed<32>(str1, str2);
    case 33:
        return MemcmpFixed<33>(str1, str2);
    case 34:
        return MemcmpFixed<34>(str1, str2);
    case 35:
        return MemcmpFixed<35>(str1, str2);
    case 36:
        return MemcmpFixed<36>(str1, str2);
    case 37:
        return MemcmpFixed<37>(str1, str2);
    case 38:
        return MemcmpFixed<38>(str1, str2);
    case 39:
        return MemcmpFixed<39>(str1, str2);
    case 40:
        return MemcmpFixed<40>(str1, str2);
    case 41:
        return MemcmpFixed<41>(str1, str2);
    case 42:
        return MemcmpFixed<42>(str1, str2);
    case 43:
        return MemcmpFixed<43>(str1, str2);
    case 44:
        return MemcmpFixed<44>(str1, str2);
    case 45:
        return MemcmpFixed<45>(str1, str2);
    case 46:
        return MemcmpFixed<46>(str1, str2);
    case 47:
        return MemcmpFixed<47>(str1, str2);
    case 48:
        return MemcmpFixed<48>(str1, str2);
    case 49:
        return MemcmpFixed<49>(str1, str2);
    case 50:
        return MemcmpFixed<50>(str1, str2);
    case 51:
        return MemcmpFixed<51>(str1, str2);
    case 52:
        return MemcmpFixed<52>(str1, str2);
    case 53:
        return MemcmpFixed<53>(str1, str2);
    case 54:
        return MemcmpFixed<54>(str1, str2);
    case 55:
        return MemcmpFixed<55>(str1, str2);
    case 56:
        return MemcmpFixed<56>(str1, str2);
    case 57:
        return MemcmpFixed<57>(str1, str2);
    case 58:
        return MemcmpFixed<58>(str1, str2);
    case 59:
        return MemcmpFixed<59>(str1, str2);
    case 60:
        return MemcmpFixed<60>(str1, str2);
    case 61:
        return MemcmpFixed<61>(str1, str2);
    case 62:
        return MemcmpFixed<62>(str1, str2);
    case 63:
        return MemcmpFixed<63>(str1, str2);
    case 64:
        return MemcmpFixed<64>(str1, str2);
    default:
        return memcmp(str1, str2, size);
    }
    // LCOV_EXCL_STOP
}

Here is the call graph for this function:

◆ FastMemset()

void duckdb::FastMemset	(	void *	ptr,
		int	value,
		size_t	size
	)

inlineprivate

                                                          {
    // LCOV_EXCL_START
    switch (size) {
    case 0:
        return;
    case 1:
        return MemsetFixed<1>(ptr, value);
    case 2:
        return MemsetFixed<2>(ptr, value);
    case 3:
        return MemsetFixed<3>(ptr, value);
    case 4:
        return MemsetFixed<4>(ptr, value);
    case 5:
        return MemsetFixed<5>(ptr, value);
    case 6:
        return MemsetFixed<6>(ptr, value);
    case 7:
        return MemsetFixed<7>(ptr, value);
    case 8:
        return MemsetFixed<8>(ptr, value);
    case 9:
        return MemsetFixed<9>(ptr, value);
    case 10:
        return MemsetFixed<10>(ptr, value);
    case 11:
        return MemsetFixed<11>(ptr, value);
    case 12:
        return MemsetFixed<12>(ptr, value);
    case 13:
        return MemsetFixed<13>(ptr, value);
    case 14:
        return MemsetFixed<14>(ptr, value);
    case 15:
        return MemsetFixed<15>(ptr, value);
    case 16:
        return MemsetFixed<16>(ptr, value);
    case 17:
        return MemsetFixed<17>(ptr, value);
    case 18:
        return MemsetFixed<18>(ptr, value);
    case 19:
        return MemsetFixed<19>(ptr, value);
    case 20:
        return MemsetFixed<20>(ptr, value);
    case 21:
        return MemsetFixed<21>(ptr, value);
    case 22:
        return MemsetFixed<22>(ptr, value);
    case 23:
        return MemsetFixed<23>(ptr, value);
    case 24:
        return MemsetFixed<24>(ptr, value);
    case 25:
        return MemsetFixed<25>(ptr, value);
    case 26:
        return MemsetFixed<26>(ptr, value);
    case 27:
        return MemsetFixed<27>(ptr, value);
    case 28:
        return MemsetFixed<28>(ptr, value);
    case 29:
        return MemsetFixed<29>(ptr, value);
    case 30:
        return MemsetFixed<30>(ptr, value);
    case 31:
        return MemsetFixed<31>(ptr, value);
    case 32:
        return MemsetFixed<32>(ptr, value);
    case 33:
        return MemsetFixed<33>(ptr, value);
    case 34:
        return MemsetFixed<34>(ptr, value);
    case 35:
        return MemsetFixed<35>(ptr, value);
    case 36:
        return MemsetFixed<36>(ptr, value);
    case 37:
        return MemsetFixed<37>(ptr, value);
    case 38:
        return MemsetFixed<38>(ptr, value);
    case 39:
        return MemsetFixed<39>(ptr, value);
    case 40:
        return MemsetFixed<40>(ptr, value);
    case 41:
        return MemsetFixed<41>(ptr, value);
    case 42:
        return MemsetFixed<42>(ptr, value);
    case 43:
        return MemsetFixed<43>(ptr, value);
    case 44:
        return MemsetFixed<44>(ptr, value);
    case 45:
        return MemsetFixed<45>(ptr, value);
    case 46:
        return MemsetFixed<46>(ptr, value);
    case 47:
        return MemsetFixed<47>(ptr, value);
    case 48:
        return MemsetFixed<48>(ptr, value);
    case 49:
        return MemsetFixed<49>(ptr, value);
    case 50:
        return MemsetFixed<50>(ptr, value);
    case 51:
        return MemsetFixed<51>(ptr, value);
    case 52:
        return MemsetFixed<52>(ptr, value);
    case 53:
        return MemsetFixed<53>(ptr, value);
    case 54:
        return MemsetFixed<54>(ptr, value);
    case 55:
        return MemsetFixed<55>(ptr, value);
    case 56:
        return MemsetFixed<56>(ptr, value);
    case 57:
        return MemsetFixed<57>(ptr, value);
    case 58:
        return MemsetFixed<58>(ptr, value);
    case 59:
        return MemsetFixed<59>(ptr, value);
    case 60:
        return MemsetFixed<60>(ptr, value);
    case 61:
        return MemsetFixed<61>(ptr, value);
    case 62:
        return MemsetFixed<62>(ptr, value);
    case 63:
        return MemsetFixed<63>(ptr, value);
    case 64:
        return MemsetFixed<64>(ptr, value);
    case 65:
        return MemsetFixed<65>(ptr, value);
    case 66:
        return MemsetFixed<66>(ptr, value);
    case 67:
        return MemsetFixed<67>(ptr, value);
    case 68:
        return MemsetFixed<68>(ptr, value);
    case 69:
        return MemsetFixed<69>(ptr, value);
    case 70:
        return MemsetFixed<70>(ptr, value);
    case 71:
        return MemsetFixed<71>(ptr, value);
    case 72:
        return MemsetFixed<72>(ptr, value);
    case 73:
        return MemsetFixed<73>(ptr, value);
    case 74:
        return MemsetFixed<74>(ptr, value);
    case 75:
        return MemsetFixed<75>(ptr, value);
    case 76:
        return MemsetFixed<76>(ptr, value);
    case 77:
        return MemsetFixed<77>(ptr, value);
    case 78:
        return MemsetFixed<78>(ptr, value);
    case 79:
        return MemsetFixed<79>(ptr, value);
    case 80:
        return MemsetFixed<80>(ptr, value);
    case 81:
        return MemsetFixed<81>(ptr, value);
    case 82:
        return MemsetFixed<82>(ptr, value);
    case 83:
        return MemsetFixed<83>(ptr, value);
    case 84:
        return MemsetFixed<84>(ptr, value);
    case 85:
        return MemsetFixed<85>(ptr, value);
    case 86:
        return MemsetFixed<86>(ptr, value);
    case 87:
        return MemsetFixed<87>(ptr, value);
    case 88:
        return MemsetFixed<88>(ptr, value);
    case 89:
        return MemsetFixed<89>(ptr, value);
    case 90:
        return MemsetFixed<90>(ptr, value);
    case 91:
        return MemsetFixed<91>(ptr, value);
    case 92:
        return MemsetFixed<92>(ptr, value);
    case 93:
        return MemsetFixed<93>(ptr, value);
    case 94:
        return MemsetFixed<94>(ptr, value);
    case 95:
        return MemsetFixed<95>(ptr, value);
    case 96:
        return MemsetFixed<96>(ptr, value);
    case 97:
        return MemsetFixed<97>(ptr, value);
    case 98:
        return MemsetFixed<98>(ptr, value);
    case 99:
        return MemsetFixed<99>(ptr, value);
    case 100:
        return MemsetFixed<100>(ptr, value);
    case 101:
        return MemsetFixed<101>(ptr, value);
    case 102:
        return MemsetFixed<102>(ptr, value);
    case 103:
        return MemsetFixed<103>(ptr, value);
    case 104:
        return MemsetFixed<104>(ptr, value);
    case 105:
        return MemsetFixed<105>(ptr, value);
    case 106:
        return MemsetFixed<106>(ptr, value);
    case 107:
        return MemsetFixed<107>(ptr, value);
    case 108:
        return MemsetFixed<108>(ptr, value);
    case 109:
        return MemsetFixed<109>(ptr, value);
    case 110:
        return MemsetFixed<110>(ptr, value);
    case 111:
        return MemsetFixed<111>(ptr, value);
    case 112:
        return MemsetFixed<112>(ptr, value);
    case 113:
        return MemsetFixed<113>(ptr, value);
    case 114:
        return MemsetFixed<114>(ptr, value);
    case 115:
        return MemsetFixed<115>(ptr, value);
    case 116:
        return MemsetFixed<116>(ptr, value);
    case 117:
        return MemsetFixed<117>(ptr, value);
    case 118:
        return MemsetFixed<118>(ptr, value);
    case 119:
        return MemsetFixed<119>(ptr, value);
    case 120:
        return MemsetFixed<120>(ptr, value);
    case 121:
        return MemsetFixed<121>(ptr, value);
    case 122:
        return MemsetFixed<122>(ptr, value);
    case 123:
        return MemsetFixed<123>(ptr, value);
    case 124:
        return MemsetFixed<124>(ptr, value);
    case 125:
        return MemsetFixed<125>(ptr, value);
    case 126:
        return MemsetFixed<126>(ptr, value);
    case 127:
        return MemsetFixed<127>(ptr, value);
    case 128:
        return MemsetFixed<128>(ptr, value);
    case 129:
        return MemsetFixed<129>(ptr, value);
    case 130:
        return MemsetFixed<130>(ptr, value);
    case 131:
        return MemsetFixed<131>(ptr, value);
    case 132:
        return MemsetFixed<132>(ptr, value);
    case 133:
        return MemsetFixed<133>(ptr, value);
    case 134:
        return MemsetFixed<134>(ptr, value);
    case 135:
        return MemsetFixed<135>(ptr, value);
    case 136:
        return MemsetFixed<136>(ptr, value);
    case 137:
        return MemsetFixed<137>(ptr, value);
    case 138:
        return MemsetFixed<138>(ptr, value);
    case 139:
        return MemsetFixed<139>(ptr, value);
    case 140:
        return MemsetFixed<140>(ptr, value);
    case 141:
        return MemsetFixed<141>(ptr, value);
    case 142:
        return MemsetFixed<142>(ptr, value);
    case 143:
        return MemsetFixed<143>(ptr, value);
    case 144:
        return MemsetFixed<144>(ptr, value);
    case 145:
        return MemsetFixed<145>(ptr, value);
    case 146:
        return MemsetFixed<146>(ptr, value);
    case 147:
        return MemsetFixed<147>(ptr, value);
    case 148:
        return MemsetFixed<148>(ptr, value);
    case 149:
        return MemsetFixed<149>(ptr, value);
    case 150:
        return MemsetFixed<150>(ptr, value);
    case 151:
        return MemsetFixed<151>(ptr, value);
    case 152:
        return MemsetFixed<152>(ptr, value);
    case 153:
        return MemsetFixed<153>(ptr, value);
    case 154:
        return MemsetFixed<154>(ptr, value);
    case 155:
        return MemsetFixed<155>(ptr, value);
    case 156:
        return MemsetFixed<156>(ptr, value);
    case 157:
        return MemsetFixed<157>(ptr, value);
    case 158:
        return MemsetFixed<158>(ptr, value);
    case 159:
        return MemsetFixed<159>(ptr, value);
    case 160:
        return MemsetFixed<160>(ptr, value);
    case 161:
        return MemsetFixed<161>(ptr, value);
    case 162:
        return MemsetFixed<162>(ptr, value);
    case 163:
        return MemsetFixed<163>(ptr, value);
    case 164:
        return MemsetFixed<164>(ptr, value);
    case 165:
        return MemsetFixed<165>(ptr, value);
    case 166:
        return MemsetFixed<166>(ptr, value);
    case 167:
        return MemsetFixed<167>(ptr, value);
    case 168:
        return MemsetFixed<168>(ptr, value);
    case 169:
        return MemsetFixed<169>(ptr, value);
    case 170:
        return MemsetFixed<170>(ptr, value);
    case 171:
        return MemsetFixed<171>(ptr, value);
    case 172:
        return MemsetFixed<172>(ptr, value);
    case 173:
        return MemsetFixed<173>(ptr, value);
    case 174:
        return MemsetFixed<174>(ptr, value);
    case 175:
        return MemsetFixed<175>(ptr, value);
    case 176:
        return MemsetFixed<176>(ptr, value);
    case 177:
        return MemsetFixed<177>(ptr, value);
    case 178:
        return MemsetFixed<178>(ptr, value);
    case 179:
        return MemsetFixed<179>(ptr, value);
    case 180:
        return MemsetFixed<180>(ptr, value);
    case 181:
        return MemsetFixed<181>(ptr, value);
    case 182:
        return MemsetFixed<182>(ptr, value);
    case 183:
        return MemsetFixed<183>(ptr, value);
    case 184:
        return MemsetFixed<184>(ptr, value);
    case 185:
        return MemsetFixed<185>(ptr, value);
    case 186:
        return MemsetFixed<186>(ptr, value);
    case 187:
        return MemsetFixed<187>(ptr, value);
    case 188:
        return MemsetFixed<188>(ptr, value);
    case 189:
        return MemsetFixed<189>(ptr, value);
    case 190:
        return MemsetFixed<190>(ptr, value);
    case 191:
        return MemsetFixed<191>(ptr, value);
    case 192:
        return MemsetFixed<192>(ptr, value);
    case 193:
        return MemsetFixed<193>(ptr, value);
    case 194:
        return MemsetFixed<194>(ptr, value);
    case 195:
        return MemsetFixed<195>(ptr, value);
    case 196:
        return MemsetFixed<196>(ptr, value);
    case 197:
        return MemsetFixed<197>(ptr, value);
    case 198:
        return MemsetFixed<198>(ptr, value);
    case 199:
        return MemsetFixed<199>(ptr, value);
    case 200:
        return MemsetFixed<200>(ptr, value);
    case 201:
        return MemsetFixed<201>(ptr, value);
    case 202:
        return MemsetFixed<202>(ptr, value);
    case 203:
        return MemsetFixed<203>(ptr, value);
    case 204:
        return MemsetFixed<204>(ptr, value);
    case 205:
        return MemsetFixed<205>(ptr, value);
    case 206:
        return MemsetFixed<206>(ptr, value);
    case 207:
        return MemsetFixed<207>(ptr, value);
    case 208:
        return MemsetFixed<208>(ptr, value);
    case 209:
        return MemsetFixed<209>(ptr, value);
    case 210:
        return MemsetFixed<210>(ptr, value);
    case 211:
        return MemsetFixed<211>(ptr, value);
    case 212:
        return MemsetFixed<212>(ptr, value);
    case 213:
        return MemsetFixed<213>(ptr, value);
    case 214:
        return MemsetFixed<214>(ptr, value);
    case 215:
        return MemsetFixed<215>(ptr, value);
    case 216:
        return MemsetFixed<216>(ptr, value);
    case 217:
        return MemsetFixed<217>(ptr, value);
    case 218:
        return MemsetFixed<218>(ptr, value);
    case 219:
        return MemsetFixed<219>(ptr, value);
    case 220:
        return MemsetFixed<220>(ptr, value);
    case 221:
        return MemsetFixed<221>(ptr, value);
    case 222:
        return MemsetFixed<222>(ptr, value);
    case 223:
        return MemsetFixed<223>(ptr, value);
    case 224:
        return MemsetFixed<224>(ptr, value);
    case 225:
        return MemsetFixed<225>(ptr, value);
    case 226:
        return MemsetFixed<226>(ptr, value);
    case 227:
        return MemsetFixed<227>(ptr, value);
    case 228:
        return MemsetFixed<228>(ptr, value);
    case 229:
        return MemsetFixed<229>(ptr, value);
    case 230:
        return MemsetFixed<230>(ptr, value);
    case 231:
        return MemsetFixed<231>(ptr, value);
    case 232:
        return MemsetFixed<232>(ptr, value);
    case 233:
        return MemsetFixed<233>(ptr, value);
    case 234:
        return MemsetFixed<234>(ptr, value);
    case 235:
        return MemsetFixed<235>(ptr, value);
    case 236:
        return MemsetFixed<236>(ptr, value);
    case 237:
        return MemsetFixed<237>(ptr, value);
    case 238:
        return MemsetFixed<238>(ptr, value);
    case 239:
        return MemsetFixed<239>(ptr, value);
    case 240:
        return MemsetFixed<240>(ptr, value);
    case 241:
        return MemsetFixed<241>(ptr, value);
    case 242:
        return MemsetFixed<242>(ptr, value);
    case 243:
        return MemsetFixed<243>(ptr, value);
    case 244:
        return MemsetFixed<244>(ptr, value);
    case 245:
        return MemsetFixed<245>(ptr, value);
    case 246:
        return MemsetFixed<246>(ptr, value);
    case 247:
        return MemsetFixed<247>(ptr, value);
    case 248:
        return MemsetFixed<248>(ptr, value);
    case 249:
        return MemsetFixed<249>(ptr, value);
    case 250:
        return MemsetFixed<250>(ptr, value);
    case 251:
        return MemsetFixed<251>(ptr, value);
    case 252:
        return MemsetFixed<252>(ptr, value);
    case 253:
        return MemsetFixed<253>(ptr, value);
    case 254:
        return MemsetFixed<254>(ptr, value);
    case 255:
        return MemsetFixed<255>(ptr, value);
    case 256:
        return MemsetFixed<256>(ptr, value);
    default:
        memset(ptr, value, size);
    }
    // LCOV_EXCL_STOP
}

◆ GetArrowExtensionInternal()

ArrowTypeExtension duckdb::GetArrowExtensionInternal	(	unordered_map< ArrowExtensionMetadata, ArrowTypeExtension, HashArrowTypeExtension > &	type_extensions,
		ArrowExtensionMetadata	info
	)

                                 {
    if (type_extensions.find(info) == type_extensions.end()) {
        auto og_info = info;
        info.SetArrowFormat("");
        if (type_extensions.find(info) == type_extensions.end()) {
            auto format = og_info.GetArrowFormat();
            auto type = ArrowType::GetTypeFromFormat(format);
            return ArrowTypeExtension(og_info, std::move(type));
        }
    }
    return type_extensions[info];
}

◆ DuckDBAssertInternal()

DUCKDB_API void duckdb::DuckDBAssertInternal	(	bool	condition,
		const char *	condition_name,
		const char *	file,
		int	linenr
	)

                                                                                                    {
#ifdef DISABLE_ASSERTIONS
    return;
#endif
    if (condition) {
        return;
    }
    throw InternalException("Assertion triggered in file \"%s\" on line %d: %s", file, linenr, condition_name);
}

◆ PrintBits()

void duckdb::PrintBits ( const char value )

                                 {
    string result;
    for (int i = 7; i >= 0; --i) {
        result += to_string((value >> i) & 1);
    }
    Printer::RawPrint(OutputStream::STREAM_STDOUT, result);
}

◆ BignumAddition()

void duckdb::BignumAddition	(	data_ptr_t	result,
		int64_t	result_end,
		bool	is_target_absolute_bigger,
		const BignumIntermediate &	lhs,
		const BignumIntermediate &	rhs
	)

                                                                                  {
    bool is_result_negative = is_target_absolute_bigger ? lhs.is_negative : rhs.is_negative;
 
    int64_t i_target = lhs.size - 1;   // last byte index in target
    int64_t i_source = rhs.size - 1;   // last byte index in source
    int64_t i_result = result_end - 1; // last byte index in result
 
    // Carry for addition
    uint16_t carry = 0;
    uint16_t borrow = 0;
    // Add bytes from right to left
    while (i_result >= 0) {
        // If the numbers are negative, we bit flip them
        uint8_t target_byte = lhs.GetAbsoluteByte(i_target);
        uint8_t source_byte = rhs.GetAbsoluteByte(i_source);
        // Add bytes and carry
        uint16_t sum;
        if (lhs.is_negative == rhs.is_negative) {
            sum = static_cast<uint16_t>(target_byte) + static_cast<uint16_t>(source_byte) + carry;
            carry = (sum >> 8) & 0xFF;
        } else {
            if (is_target_absolute_bigger) {
                sum = static_cast<uint16_t>(target_byte) - static_cast<uint16_t>(source_byte) - borrow;
                borrow = sum > static_cast<uint16_t>(target_byte) ? 1 : 0;
            } else {
                sum = static_cast<uint16_t>(source_byte) - static_cast<uint16_t>(target_byte) - borrow;
                borrow = sum > static_cast<uint16_t>(source_byte) ? 1 : 0;
            }
        }
        uint8_t result_byte = static_cast<uint8_t>(sum & 0xFF);
        // If the result is not positive, we must flip the bits again
        result[i_result] = is_result_negative ? ~result_byte : result_byte;
        i_target--;
        i_source--;
        i_result--;
    }
 
    if (is_result_negative != lhs.is_negative) {
        // If we are flipping the sign we must be sure that we are flipping all extra bits from our target
        for (int64_t i = 0; i < result_end - rhs.size; ++i) {
            result[i] = is_result_negative ? 0xFF : 0x00;
        }
    }
}

◆ ProduceOverUnderFlowError()

string duckdb::ProduceOverUnderFlowError	(	bool	is_result_negative,
		idx_t	actual_start,
		idx_t	data_size
	)

                                                                                               {
    // We must throw an error, usually we should print the numbers, but I have a feeling that it won't be possible
    // here.
    std::ostringstream error;
    if (is_result_negative) {
        error << "Underflow ";
    } else {
        error << "Overflow ";
    }
    error << "in Bignum Operation. A Bignum can hold max " << Bignum::MAX_DATA_SIZE
          << " data bytes. Current bignum has " << data_size - actual_start << " bytes.";
    return error.str();
}

◆ ConvertVectorToValue()

Value duckdb::ConvertVectorToValue ( vector< Value > set )

                                              {
    if (set.empty()) {
        return Value::LIST(LogicalType::BOOLEAN, std::move(set));
    }
    return Value::LIST(std::move(set));
}

◆ ParseColumnList() [1/2]

vector< bool > duckdb::ParseColumnList	(	const vector< Value > &	set,
		vector< string > &	names,
		const string &	option_name
	)

                                                                                                     {
    vector<bool> result;
 
    if (set.empty()) {
        throw BinderException("\"%s\" expects a column list or * as parameter", loption);
    }
    // list of options: parse the list
    case_insensitive_map_t<bool> option_map;
    for (idx_t i = 0; i < set.size(); i++) {
        option_map[set[i].ToString()] = false;
    }
    result.resize(names.size(), false);
    for (idx_t i = 0; i < names.size(); i++) {
        auto entry = option_map.find(names[i]);
        if (entry != option_map.end()) {
            result[i] = true;
            entry->second = true;
        }
    }
    for (auto &entry : option_map) {
        if (!entry.second) {
            throw BinderException("\"%s\" expected to find %s, but it was not found in the table", loption,
                                  entry.first.c_str());
        }
    }
    return result;
}

◆ ParseColumnList() [2/2]

vector< bool > duckdb::ParseColumnList	(	const Value &	value,
		vector< string > &	names,
		const string &	option_name
	)

                                                                                               {
    vector<bool> result;
 
    // Only accept a list of arguments
    if (value.type().id() != LogicalTypeId::LIST) {
        // Support a single argument if it's '*'
        if (value.type().id() == LogicalTypeId::VARCHAR && value.GetValue<string>() == "*") {
            result.resize(names.size(), true);
            return result;
        }
        throw BinderException("\"%s\" expects a column list or * as parameter", loption);
    }
    if (value.IsNull()) {
        throw BinderException("\"%s\" expects a column list or * as parameter, it can't be a NULL value", loption);
    }
    auto &children = ListValue::GetChildren(value);
    // accept '*' as single argument
    if (children.size() == 1 && children[0].type().id() == LogicalTypeId::VARCHAR &&
        children[0].GetValue<string>() == "*") {
        result.resize(names.size(), true);
        return result;
    }
    return ParseColumnList(children, names, loption);
}

◆ ParseColumnsOrdered() [1/2]

vector< idx_t > duckdb::ParseColumnsOrdered	(	const vector< Value > &	set,
		vector< string > &	names,
		const string &	loption
	)

                                                                                                          {
    vector<idx_t> result;
 
    if (set.empty()) {
        throw BinderException("\"%s\" expects a column list or * as parameter", loption);
    }
 
    // Maps option to bool indicating if its found and the index in the original set
    case_insensitive_map_t<std::pair<bool, idx_t>> option_map;
    for (idx_t i = 0; i < set.size(); i++) {
        option_map[set[i].ToString()] = {false, i};
    }
    result.resize(option_map.size());
 
    for (idx_t i = 0; i < names.size(); i++) {
        auto entry = option_map.find(names[i]);
        if (entry != option_map.end()) {
            result[entry->second.second] = i;
            entry->second.first = true;
        }
    }
    for (auto &entry : option_map) {
        if (!entry.second.first) {
            throw BinderException("\"%s\" expected to find %s, but it was not found in the table", loption,
                                  entry.first.c_str());
        }
    }
    return result;
}

◆ ParseColumnsOrdered() [2/2]

vector< idx_t > duckdb::ParseColumnsOrdered	(	const Value &	value,
		vector< string > &	names,
		const string &	loption
	)

                                                                                                    {
    vector<idx_t> result;
 
    // Only accept a list of arguments
    if (value.type().id() != LogicalTypeId::LIST) {
        // Support a single argument if it's '*'
        if (value.type().id() == LogicalTypeId::VARCHAR && value.GetValue<string>() == "*") {
            result.resize(names.size(), 0);
            std::iota(std::begin(result), std::end(result), 0);
            return result;
        }
        throw BinderException("\"%s\" expects a column list or * as parameter", loption);
    }
    auto &children = ListValue::GetChildren(value);
    // accept '*' as single argument
    if (children.size() == 1 && children[0].type().id() == LogicalTypeId::VARCHAR &&
        children[0].GetValue<string>() == "*") {
        result.resize(names.size(), 0);
        std::iota(std::begin(result), std::end(result), 0);
        return result;
    }
    return ParseColumnsOrdered(children, names, loption);
}

◆ IsWhitespaceEscape()

bool duckdb::IsWhitespaceEscape ( const char c )

                                      {
    // \n and \t are whitespace escapes
    return c == 'n' || c == 't';
}

◆ Checksum() [1/2]

uint64_t duckdb::Checksum	(	uint8_t *	buffer,
		size_t	size
	)

protected

Compute a checksum over a buffer of size size.

                                                {
    uint64_t result = 5381;
    uint64_t *ptr = reinterpret_cast<uint64_t *>(buffer);
    size_t i;
    // for efficiency, we first checksum uint64_t values
    for (i = 0; i < size / 8; i++) {
        result ^= Checksum(ptr[i]);
    }
    if (size - i * 8 > 0) {
        // the remaining 0-7 bytes we hash using a string hash
        result ^= ChecksumRemainder(buffer + i * 8, size - i * 8);
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Checksum() [2/2]

hash_t duckdb::Checksum ( uint64_t x )

protected

                            {
    return x * UINT64_C(0xbf58476d1ce4e5b9);
}

◆ ChecksumRemainder()

hash_t duckdb::ChecksumRemainder	(	void *	ptr,
		size_t	len
	)

protectednoexcept

                                                         {
    static constexpr uint64_t M = UINT64_C(0xc6a4a7935bd1e995);
    static constexpr uint64_t SEED = UINT64_C(0xe17a1465);
    static constexpr unsigned int R = 47;
 
    auto const *const data64 = static_cast<uint64_t const *>(ptr);
    uint64_t h = SEED ^ (len * M);
 
    size_t const n_blocks = len / 8;
    for (size_t i = 0; i < n_blocks; ++i) {
        auto k = Load<uint64_t>(reinterpret_cast<const_data_ptr_t>(data64 + i));
 
        k *= M;
        k ^= k >> R;
        k *= M;
 
        h ^= k;
        h *= M;
    }
 
    auto const *const data8 = reinterpret_cast<uint8_t const *>(data64 + n_blocks);
    switch (len & 7U) {
    case 7:
        h ^= static_cast<uint64_t>(data8[6]) << 48U;
        DUCKDB_EXPLICIT_FALLTHROUGH;
    case 6:
        h ^= static_cast<uint64_t>(data8[5]) << 40U;
        DUCKDB_EXPLICIT_FALLTHROUGH;
    case 5:
        h ^= static_cast<uint64_t>(data8[4]) << 32U;
        DUCKDB_EXPLICIT_FALLTHROUGH;
    case 4:
        h ^= static_cast<uint64_t>(data8[3]) << 24U;
        DUCKDB_EXPLICIT_FALLTHROUGH;
    case 3:
        h ^= static_cast<uint64_t>(data8[2]) << 16U;
        DUCKDB_EXPLICIT_FALLTHROUGH;
    case 2:
        h ^= static_cast<uint64_t>(data8[1]) << 8U;
        DUCKDB_EXPLICIT_FALLTHROUGH;
    case 1:
        h ^= static_cast<uint64_t>(data8[0]);
        h *= M;
        DUCKDB_EXPLICIT_FALLTHROUGH;
    default:
        break;
    }
    h ^= h >> R;
    h *= M;
    h ^= h >> R;
    return static_cast<hash_t>(h);
}

◆ IsPowerOfTwo()

DUCKDB_API bool duckdb::IsPowerOfTwo ( uint64_t v )

private

                              {
    return (v & (v - 1)) == 0;
}

◆ NextPowerOfTwo()

DUCKDB_API uint64_t duckdb::NextPowerOfTwo ( uint64_t v )

private

                                    {
    auto v_in = v;
    if (v < 1) { // this is not strictly right but we seem to rely on it in places
        return 2;
    }
    v--;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    v |= v >> 32;
    v++;
    if (v == 0) {
        throw OutOfRangeException("Can't find next power of 2 for %llu", v_in);
    }
    return v;
}

◆ PreviousPowerOfTwo()

DUCKDB_API uint64_t duckdb::PreviousPowerOfTwo ( uint64_t v )

private

                                        {
    return NextPowerOfTwo((v / 2) + 1);
}

◆ IsInvalidSchema()

DUCKDB_API bool duckdb::IsInvalidSchema ( const string & str )

private

                                        {
    return str.empty();
}

◆ IsInvalidCatalog()

DUCKDB_API bool duckdb::IsInvalidCatalog ( const string & str )

private

                                         {
    return str.empty();
}

◆ IsRowIdColumnId()

DUCKDB_API bool duckdb::IsRowIdColumnId ( column_t column_id )

private

                                         {
    return column_id == COLUMN_IDENTIFIER_ROW_ID;
}

◆ IsVirtualColumn()

DUCKDB_API bool duckdb::IsVirtualColumn ( column_t column_id )

private

                                         {
    return column_id >= VIRTUAL_COLUMN_START;
}

◆ ByteReverse()

static void duckdb::ByteReverse	(	unsigned char *	buf,
		unsigned	longs
	)

staticprivate

                                                            {
    uint32_t t;
    do {
        t = (uint32_t)((unsigned)buf[3] << 8 | buf[2]) << 16 | ((unsigned)buf[1] << 8 | buf[0]);
        *reinterpret_cast<uint32_t *>(buf) = t;
        buf += 4;
    } while (--longs);
}

◆ MD5Transform()

static void duckdb::MD5Transform	(	uint32_t	buf[4],
		const uint32_t	in[16]
	)

staticprivate

                                                                 {
    uint32_t a, b, c, d;
 
    a = buf[0];
    b = buf[1];
    c = buf[2];
    d = buf[3];
 
    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
 
    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
 
    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
 
    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
 
    buf[0] += a;
    buf[1] += b;
    buf[2] += c;
    buf[3] += d;
}

◆ TransformNewLine()

static string duckdb::TransformNewLine ( string new_line )

staticprotected

                                                {
    new_line = StringUtil::Replace(new_line, "\\r", "\r");
    return StringUtil::Replace(new_line, "\\n", "\n");
}

◆ GetFileSize()

static idx_t duckdb::GetFileSize	(	unique_ptr< BufferedFileWriter > &	file_writer,
		idx_t &	bytes_written
	)

staticprotected

                                                                                            {
    if (file_writer) {
        return file_writer->GetFileSize();
    }
    return bytes_written;
}

◆ DecryptBuffer()

static void duckdb::DecryptBuffer	(	EncryptionState &	encryption_state,
		const_data_ptr_t	temp_key,
		data_ptr_t	buffer,
		idx_t	buffer_size,
		data_ptr_t	metadata
	)

static

load the stored nonce and tag

Initialize the decryption

check the tag

                                                                  {
    EncryptionTag tag;
    EncryptionNonce nonce(encryption_state.metadata->GetCipher(), encryption_state.metadata->GetVersion());
    memcpy(nonce.data(), metadata, nonce.size());
    memcpy(tag.data(), metadata + nonce.size(), tag.size());
 
    encryption_state.InitializeDecryption(nonce, temp_key);
 
    auto aes_res = encryption_state.Process(buffer, buffer_size, buffer, buffer_size);
 
    if (aes_res != buffer_size) {
        throw IOException("Buffer decryption failure: in- and output size differ (%llu/%llu)", buffer_size, aes_res);
    }
 
    encryption_state.Finalize(buffer, 0, tag.data(), tag.size());
}

Here is the caller graph for this function:

◆ IsBigintDatepart()

bool duckdb::IsBigintDatepart ( DatePartSpecifier part_code )

inline

                                                          {
    return size_t(part_code) < size_t(DatePartSpecifier::BEGIN_DOUBLE);
}

◆ TryGetDatePartSpecifier()

bool duckdb::TryGetDatePartSpecifier	(	const string &	specifier,
		DatePartSpecifier &	result
	)

                                                                                   {
    auto specifier = StringUtil::Lower(specifier_p);
    if (specifier == "year" || specifier == "yr" || specifier == "y" || specifier == "years" || specifier == "yrs") {
        result = DatePartSpecifier::YEAR;
    } else if (specifier == "month" || specifier == "mon" || specifier == "months" || specifier == "mons") {
        result = DatePartSpecifier::MONTH;
    } else if (specifier == "day" || specifier == "days" || specifier == "d" || specifier == "dayofmonth") {
        result = DatePartSpecifier::DAY;
    } else if (specifier == "decade" || specifier == "dec" || specifier == "decades" || specifier == "decs") {
        result = DatePartSpecifier::DECADE;
    } else if (specifier == "century" || specifier == "cent" || specifier == "centuries" || specifier == "c") {
        result = DatePartSpecifier::CENTURY;
    } else if (specifier == "millennium" || specifier == "mil" || specifier == "millenniums" ||
               specifier == "millennia" || specifier == "mils" || specifier == "millenium") {
        result = DatePartSpecifier::MILLENNIUM;
    } else if (specifier == "microseconds" || specifier == "microsecond" || specifier == "us" || specifier == "usec" ||
               specifier == "usecs" || specifier == "usecond" || specifier == "useconds") {
        result = DatePartSpecifier::MICROSECONDS;
    } else if (specifier == "milliseconds" || specifier == "millisecond" || specifier == "ms" || specifier == "msec" ||
               specifier == "msecs" || specifier == "msecond" || specifier == "mseconds") {
        result = DatePartSpecifier::MILLISECONDS;
    } else if (specifier == "second" || specifier == "sec" || specifier == "seconds" || specifier == "secs" ||
               specifier == "s") {
        result = DatePartSpecifier::SECOND;
    } else if (specifier == "minute" || specifier == "min" || specifier == "minutes" || specifier == "mins" ||
               specifier == "m") {
        result = DatePartSpecifier::MINUTE;
    } else if (specifier == "hour" || specifier == "hr" || specifier == "hours" || specifier == "hrs" ||
               specifier == "h") {
        result = DatePartSpecifier::HOUR;
    } else if (specifier == "epoch") {
        // seconds since 1970-01-01
        result = DatePartSpecifier::EPOCH;
    } else if (specifier == "dow" || specifier == "dayofweek" || specifier == "weekday") {
        // day of the week (Sunday = 0, Saturday = 6)
        result = DatePartSpecifier::DOW;
    } else if (specifier == "isodow") {
        // isodow (Monday = 1, Sunday = 7)
        result = DatePartSpecifier::ISODOW;
    } else if (specifier == "week" || specifier == "weeks" || specifier == "w" || specifier == "weekofyear") {
        // ISO week number
        result = DatePartSpecifier::WEEK;
    } else if (specifier == "doy" || specifier == "dayofyear") {
        // day of the year (1-365/366)
        result = DatePartSpecifier::DOY;
    } else if (specifier == "quarter" || specifier == "quarters") {
        // quarter of the year (1-4)
        result = DatePartSpecifier::QUARTER;
    } else if (specifier == "yearweek") {
        // Combined isoyear and isoweek YYYYWW
        result = DatePartSpecifier::YEARWEEK;
    } else if (specifier == "isoyear") {
        // ISO year (first week of the year may be in previous year)
        result = DatePartSpecifier::ISOYEAR;
    } else if (specifier == "era") {
        result = DatePartSpecifier::ERA;
    } else if (specifier == "timezone") {
        result = DatePartSpecifier::TIMEZONE;
    } else if (specifier == "timezone_hour") {
        result = DatePartSpecifier::TIMEZONE_HOUR;
    } else if (specifier == "timezone_minute") {
        result = DatePartSpecifier::TIMEZONE_MINUTE;
    } else if (specifier == "julian" || specifier == "jd") {
        result = DatePartSpecifier::JULIAN_DAY;
    } else {
        return false;
    }
    return true;
}

◆ GetDatePartSpecifier()

DatePartSpecifier duckdb::GetDatePartSpecifier ( const string & specifier )

                                                                {
    DatePartSpecifier result;
    if (!TryGetDatePartSpecifier(specifier, result)) {
        throw ConversionException("extract specifier \"%s\" not recognized", specifier);
    }
    return result;
}

◆ IntegerCastLoop()

template<class T , bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation, char decimal_separator = '.'>

static bool duckdb::IntegerCastLoop	(	const char *	buf,
		idx_t	len,
		T &	result,
		bool	strict
	)

static

                                                                                {
    idx_t start_pos;
    if (NEGATIVE) {
        start_pos = 1;
    } else {
        if (*buf == '+') {
            if (strict) {
                // leading plus is not allowed in strict mode
                return false;
            }
            start_pos = 1;
        } else {
            start_pos = 0;
        }
    }
    idx_t pos = start_pos;
    while (pos < len) {
        if (!StringUtil::CharacterIsDigit(buf[pos])) {
            // not a digit!
            if (buf[pos] == decimal_separator) {
                if (strict) {
                    return false;
                }
                bool number_before_period = pos > start_pos;
                // decimal point: we accept decimal values for integers as well
                // we just truncate them
                // make sure everything after the period is a number
                pos++;
                idx_t start_digit = pos;
                while (pos < len) {
                    if (!StringUtil::CharacterIsDigit(buf[pos])) {
                        break;
                    }
                    if (!OP::template HandleDecimal<T, NEGATIVE, ALLOW_EXPONENT>(
                            result, UnsafeNumericCast<uint8_t>(buf[pos] - '0'))) {
                        return false;
                    }
                    pos++;
 
                    if (pos != len && buf[pos] == '_') {
                        // Skip one underscore if it is not the last character and followed by a digit
                        pos++;
                        if (pos == len || !StringUtil::CharacterIsDigit(buf[pos])) {
                            return false;
                        }
                    }
                }
                // make sure there is either (1) one number after the period, or (2) one number before the period
                // i.e. we accept "1." and ".1" as valid numbers, but not "."
                if (!(number_before_period || pos > start_digit)) {
                    return false;
                }
                if (pos >= len) {
                    break;
                }
            }
            if (StringUtil::CharacterIsSpace(buf[pos])) {
                // skip any trailing spaces
                while (++pos < len) {
                    if (!StringUtil::CharacterIsSpace(buf[pos])) {
                        return false;
                    }
                }
                break;
            }
            if (ALLOW_EXPONENT) {
                if (buf[pos] == 'e' || buf[pos] == 'E') {
                    if (strict) {
                        return false;
                    }
                    if (pos == start_pos) {
                        return false;
                    }
                    pos++;
                    if (pos >= len) {
                        return false;
                    }
                    using ExponentData = IntegerCastData<int16_t>;
                    ExponentData exponent {};
                    int negative = buf[pos] == '-';
                    if (negative) {
                        if (!IntegerCastLoop<ExponentData, true, false, IntegerCastOperation, decimal_separator>(
                                buf + pos, len - pos, exponent, strict)) {
                            return false;
                        }
                    } else {
                        if (!IntegerCastLoop<ExponentData, false, false, IntegerCastOperation, decimal_separator>(
                                buf + pos, len - pos, exponent, strict)) {
                            return false;
                        }
                    }
                    return OP::template HandleExponent<T, NEGATIVE>(result, exponent.result);
                }
            }
            return false;
        }
        auto digit = UnsafeNumericCast<uint8_t>(buf[pos++] - '0');
        if (!OP::template HandleDigit<T, NEGATIVE>(result, digit)) {
            return false;
        }
 
        if (pos != len && buf[pos] == '_' && !strict) {
            // Skip one underscore if it is not the last character and followed by a digit
            pos++;
            if (pos == len || !StringUtil::CharacterIsDigit(buf[pos])) {
                return false;
            }
        }
    }
    if (!OP::template Finalize<T, NEGATIVE>(result)) {
        return false;
    }
    return pos > start_pos;
}

◆ IntegerHexCastLoop()

template<class T , bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation>

static bool duckdb::IntegerHexCastLoop	(	const char *	buf,
		idx_t	len,
		T &	result,
		bool	strict
	)

static

                                                                                   {
    if (ALLOW_EXPONENT || NEGATIVE) {
        return false;
    }
    idx_t start_pos = 1;
    idx_t pos = start_pos;
    char current_char;
    while (pos < len) {
        current_char = StringUtil::CharacterToLower(buf[pos]);
        if (!StringUtil::CharacterIsHex(current_char)) {
            return false;
        }
        uint8_t digit;
        if (current_char >= 'a') {
            digit = UnsafeNumericCast<uint8_t>(current_char - 'a' + 10);
        } else {
            digit = UnsafeNumericCast<uint8_t>(current_char - '0');
        }
        pos++;
 
        if (pos != len && buf[pos] == '_') {
            // Skip one underscore if it is not the last character and followed by a hex
            pos++;
            if (pos == len || !StringUtil::CharacterIsHex(buf[pos])) {
                return false;
            }
        }
 
        if (!OP::template HandleHexDigit<T, NEGATIVE>(result, digit)) {
            return false;
        }
    }
    if (!OP::template Finalize<T, NEGATIVE>(result)) {
        return false;
    }
    return pos > start_pos;
}

◆ IntegerBinaryCastLoop()

template<class T , bool NEGATIVE, bool ALLOW_EXPONENT, class OP = IntegerCastOperation>

static bool duckdb::IntegerBinaryCastLoop	(	const char *	buf,
		idx_t	len,
		T &	result,
		bool	strict
	)

static

                                                                                      {
    if (ALLOW_EXPONENT || NEGATIVE) {
        return false;
    }
    idx_t start_pos = 1;
    idx_t pos = start_pos;
    uint8_t digit;
    char current_char;
    while (pos < len) {
        current_char = buf[pos];
        if (current_char == '0') {
            digit = 0;
        } else if (current_char == '1') {
            digit = 1;
        } else {
            return false;
        }
        pos++;
        if (pos != len && buf[pos] == '_') {
            // Skip one underscore if it is not the last character and followed by a digit
            pos++;
            if (pos == len || (buf[pos] != '0' && buf[pos] != '1')) {
                return false;
            }
        }
 
        if (!OP::template HandleBinaryDigit<T, NEGATIVE>(result, digit)) {
            return false;
        }
    }
    if (!OP::template Finalize<T, NEGATIVE>(result)) {
        return false;
    }
    return pos > start_pos;
}

◆ TryIntegerCast()

template<class T , bool IS_SIGNED = true, bool ALLOW_EXPONENT = true, class OP = IntegerCastOperation, bool ZERO_INITIALIZE = true, char decimal_separator = '.'>

static bool duckdb::TryIntegerCast	(	const char *	buf,
		idx_t	len,
		T &	result,
		bool	strict
	)

static

                                                                               {
    // skip any spaces at the start
    while (len > 0 && StringUtil::CharacterIsSpace(*buf)) {
        buf++;
        len--;
    }
    if (len == 0) {
        return false;
    }
    if (ZERO_INITIALIZE) {
        memset(&result, 0, sizeof(T));
    }
    // if the number is negative, we set the negative flag and skip the negative sign
    if (*buf == '-') {
        if (!IS_SIGNED) {
            // Need to check if its not -0
            idx_t pos = 1;
            while (pos < len) {
                if (buf[pos++] != '0') {
                    return false;
                }
            }
        }
        return IntegerCastLoop<T, true, ALLOW_EXPONENT, OP, decimal_separator>(buf, len, result, strict);
    }
    if (len > 1 && *buf == '0') {
        if (buf[1] == 'x' || buf[1] == 'X') {
            // If it starts with 0x or 0X, we parse it as a hex value
            buf++;
            len--;
            return IntegerHexCastLoop<T, false, false, OP>(buf, len, result, strict);
        } else if (buf[1] == 'b' || buf[1] == 'B') {
            // If it starts with 0b or 0B, we parse it as a binary value
            buf++;
            len--;
            return IntegerBinaryCastLoop<T, false, false, OP>(buf, len, result, strict);
        } else if (strict && StringUtil::CharacterIsDigit(buf[1])) {
            // leading zeros are not allowed in strict mode
            return false;
        }
    }
    return IntegerCastLoop<T, false, ALLOW_EXPONENT, OP, decimal_separator>(buf, len, result, strict);
}

◆ TrySimpleIntegerCast()

template<typename T , bool IS_SIGNED = true>

static bool duckdb::TrySimpleIntegerCast	(	const char *	buf,
		idx_t	len,
		T &	result,
		bool	strict
	)

inlinestatic

                                                                                            {
    IntegerCastData<T> simple_data;
    if (TryIntegerCast<IntegerCastData<T>, IS_SIGNED, false, IntegerCastOperation>(buf, len, simple_data, strict)) {
        result = (T)simple_data.result;
        return true;
    }
 
    // Simple integer cast failed, try again with decimals/exponents included
    // FIXME: This could definitely be improved as some extra work is being done here. It is more important that
    //  "normal" integers (without exponent/decimals) are still being parsed quickly.
    IntegerDecimalCastData<T> cast_data;
    if (TryIntegerCast<IntegerDecimalCastData<T>, IS_SIGNED, true, IntegerDecimalCastOperation>(buf, len, cast_data,
                                                                                                strict)) {
        result = (T)cast_data.result;
        return true;
    }
    return false;
}

◆ TryDecimalStringCast() [1/3]

template<class T , char decimal_separator = '.'>

bool duckdb::TryDecimalStringCast	(	string_t	input,
		T &	result,
		CastParameters &	parameters,
		uint8_t	width,
		uint8_t	scale
	)

                                                                                                               {
    return TryDecimalStringCast<T, decimal_separator>(input.GetData(), input.GetSize(), result, parameters, width,
                                                      scale);
}

◆ TryDecimalStringCast() [2/3]

template<class T , char decimal_separator = '.'>

bool duckdb::TryDecimalStringCast	(	const char *	string_ptr,
		idx_t	string_size,
		T &	result,
		CastParameters &	parameters,
		uint8_t	width,
		uint8_t	scale
	)

                                                        {
    DecimalCastData<T> state;
    state.result = 0;
    state.width = width;
    state.scale = scale;
    state.digit_count = 0;
    state.decimal_count = 0;
    state.excessive_decimals = 0;
    state.exponent_type = ExponentType::NONE;
    state.round_set = false;
    state.should_round = false;
    state.limit = UnsafeNumericCast<T>(DecimalCastTraits<T>::POWERS_OF_TEN_CLASS::POWERS_OF_TEN[width]);
    if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false, decimal_separator>(
            string_ptr, string_size, state, false)) {
        string_t value(string_ptr, (uint32_t)string_size);
        string error = StringUtil::Format("Could not convert string \"%s\" to DECIMAL(%d,%d)", value.GetString(),
                                          (int)width, (int)scale);
        HandleCastError::AssignError(error, parameters);
        return false;
    }
    result = state.result;
    return true;
}

◆ TryDecimalStringCast() [3/3]

template<class T , char decimal_separator = '.'>

bool duckdb::TryDecimalStringCast	(	const char *	string_ptr,
		idx_t	string_size,
		T &	result,
		uint8_t	width,
		uint8_t	scale
	)

                                                                                                              {
    DecimalCastData<T> state;
    state.result = 0;
    state.width = width;
    state.scale = scale;
    state.digit_count = 0;
    state.decimal_count = 0;
    state.excessive_decimals = 0;
    state.exponent_type = ExponentType::NONE;
    state.round_set = false;
    state.should_round = false;
    state.limit = UnsafeNumericCast<T>(DecimalCastTraits<T>::POWERS_OF_TEN_CLASS::POWERS_OF_TEN[width]);
    if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false, decimal_separator>(
            string_ptr, string_size, state, false)) {
        return false;
    }
    result = state.result;
    return true;
}

◆ SortKeyLessThan()

template<idx_t REMAINING>

static bool duckdb::SortKeyLessThan	(	const uint64_t *const &	lhs,
		const uint64_t *const &	rhs
	)

static

                                                                                    {
    return (*lhs < *rhs) || ((*lhs == *rhs) && SortKeyLessThan<REMAINING - 1>(lhs + 1, rhs + 1));
}

◆ SortKeyLessThan< 1 >()

template<>

bool duckdb::SortKeyLessThan< 1 >	(	const uint64_t *const &	lhs,
		const uint64_t *const &	rhs
	)

inline

                                                                                       {
    return *lhs < *rhs;
}

◆ GetARTConflictTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetARTConflictTypeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ARTConflictType::NO_CONFLICT), "NO_CONFLICT" },
        { static_cast<uint32_t>(ARTConflictType::CONSTRAINT), "CONSTRAINT" },
        { static_cast<uint32_t>(ARTConflictType::TRANSACTION), "TRANSACTION" }
    };
    return values;
}

◆ GetARTHandlingResultValues()

const StringUtil::EnumStringLiteral * duckdb::GetARTHandlingResultValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ARTHandlingResult::CONTINUE), "CONTINUE" },
        { static_cast<uint32_t>(ARTHandlingResult::SKIP), "SKIP" },
        { static_cast<uint32_t>(ARTHandlingResult::YIELD), "YIELD" },
        { static_cast<uint32_t>(ARTHandlingResult::NONE), "NONE" }
    };
    return values;
}

◆ GetARTScanHandlingValues()

const StringUtil::EnumStringLiteral * duckdb::GetARTScanHandlingValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ARTScanHandling::EMPLACE), "EMPLACE" },
        { static_cast<uint32_t>(ARTScanHandling::POP), "POP" }
    };
    return values;
}

◆ GetARTScanResultValues()

const StringUtil::EnumStringLiteral * duckdb::GetARTScanResultValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ARTScanResult::COMPLETED), "COMPLETED" },
        { static_cast<uint32_t>(ARTScanResult::PAUSED), "PAUSED" }
    };
    return values;
}

◆ GetAccessModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAccessModeValues ( )

private

                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AccessMode::UNDEFINED), "UNDEFINED" },
        { static_cast<uint32_t>(AccessMode::AUTOMATIC), "AUTOMATIC" },
        { static_cast<uint32_t>(AccessMode::READ_ONLY), "READ_ONLY" },
        { static_cast<uint32_t>(AccessMode::READ_WRITE), "READ_WRITE" }
    };
    return values;
}

◆ GetAggregateCombineTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAggregateCombineTypeValues ( )

private

                                                                   {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AggregateCombineType::PRESERVE_INPUT), "PRESERVE_INPUT" },
        { static_cast<uint32_t>(AggregateCombineType::ALLOW_DESTRUCTIVE), "ALLOW_DESTRUCTIVE" }
    };
    return values;
}

◆ GetAggregateDistinctDependentValues()

const StringUtil::EnumStringLiteral * duckdb::GetAggregateDistinctDependentValues ( )

private

                                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AggregateDistinctDependent::DISTINCT_DEPENDENT), "DISTINCT_DEPENDENT" },
        { static_cast<uint32_t>(AggregateDistinctDependent::NOT_DISTINCT_DEPENDENT), "NOT_DISTINCT_DEPENDENT" }
    };
    return values;
}

◆ GetAggregateHandlingValues()

const StringUtil::EnumStringLiteral * duckdb::GetAggregateHandlingValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AggregateHandling::STANDARD_HANDLING), "STANDARD_HANDLING" },
        { static_cast<uint32_t>(AggregateHandling::NO_AGGREGATES_ALLOWED), "NO_AGGREGATES_ALLOWED" },
        { static_cast<uint32_t>(AggregateHandling::FORCE_AGGREGATES), "FORCE_AGGREGATES" }
    };
    return values;
}

◆ GetAggregateOrderDependentValues()

const StringUtil::EnumStringLiteral * duckdb::GetAggregateOrderDependentValues ( )

private

                                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AggregateOrderDependent::ORDER_DEPENDENT), "ORDER_DEPENDENT" },
        { static_cast<uint32_t>(AggregateOrderDependent::NOT_ORDER_DEPENDENT), "NOT_ORDER_DEPENDENT" }
    };
    return values;
}

◆ GetAggregateTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAggregateTypeValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AggregateType::NON_DISTINCT), "NON_DISTINCT" },
        { static_cast<uint32_t>(AggregateType::DISTINCT), "DISTINCT" }
    };
    return values;
}

◆ GetAllowParserOverrideValues()

const StringUtil::EnumStringLiteral * duckdb::GetAllowParserOverrideValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AllowParserOverride::DEFAULT_OVERRIDE), "DEFAULT" },
        { static_cast<uint32_t>(AllowParserOverride::FALLBACK_OVERRIDE), "FALLBACK" },
        { static_cast<uint32_t>(AllowParserOverride::STRICT_OVERRIDE), "STRICT" }
    };
    return values;
}

◆ GetAlterDatabaseTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAlterDatabaseTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AlterDatabaseType::RENAME_DATABASE), "RENAME_DATABASE" }
    };
    return values;
}

◆ GetAlterForeignKeyTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAlterForeignKeyTypeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AlterForeignKeyType::AFT_ADD), "AFT_ADD" },
        { static_cast<uint32_t>(AlterForeignKeyType::AFT_DELETE), "AFT_DELETE" }
    };
    return values;
}

◆ GetAlterScalarFunctionTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAlterScalarFunctionTypeValues ( )

private

                                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AlterScalarFunctionType::INVALID), "INVALID" },
        { static_cast<uint32_t>(AlterScalarFunctionType::ADD_FUNCTION_OVERLOADS), "ADD_FUNCTION_OVERLOADS" }
    };
    return values;
}

◆ GetAlterTableFunctionTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAlterTableFunctionTypeValues ( )

private

                                                                     {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AlterTableFunctionType::INVALID), "INVALID" },
        { static_cast<uint32_t>(AlterTableFunctionType::ADD_FUNCTION_OVERLOADS), "ADD_FUNCTION_OVERLOADS" }
    };
    return values;
}

◆ GetAlterTableTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAlterTableTypeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AlterTableType::INVALID), "INVALID" },
        { static_cast<uint32_t>(AlterTableType::RENAME_COLUMN), "RENAME_COLUMN" },
        { static_cast<uint32_t>(AlterTableType::RENAME_TABLE), "RENAME_TABLE" },
        { static_cast<uint32_t>(AlterTableType::ADD_COLUMN), "ADD_COLUMN" },
        { static_cast<uint32_t>(AlterTableType::REMOVE_COLUMN), "REMOVE_COLUMN" },
        { static_cast<uint32_t>(AlterTableType::ALTER_COLUMN_TYPE), "ALTER_COLUMN_TYPE" },
        { static_cast<uint32_t>(AlterTableType::SET_DEFAULT), "SET_DEFAULT" },
        { static_cast<uint32_t>(AlterTableType::FOREIGN_KEY_CONSTRAINT), "FOREIGN_KEY_CONSTRAINT" },
        { static_cast<uint32_t>(AlterTableType::SET_NOT_NULL), "SET_NOT_NULL" },
        { static_cast<uint32_t>(AlterTableType::DROP_NOT_NULL), "DROP_NOT_NULL" },
        { static_cast<uint32_t>(AlterTableType::SET_COLUMN_COMMENT), "SET_COLUMN_COMMENT" },
        { static_cast<uint32_t>(AlterTableType::ADD_CONSTRAINT), "ADD_CONSTRAINT" },
        { static_cast<uint32_t>(AlterTableType::SET_PARTITIONED_BY), "SET_PARTITIONED_BY" },
        { static_cast<uint32_t>(AlterTableType::SET_SORTED_BY), "SET_SORTED_BY" },
        { static_cast<uint32_t>(AlterTableType::ADD_FIELD), "ADD_FIELD" },
        { static_cast<uint32_t>(AlterTableType::REMOVE_FIELD), "REMOVE_FIELD" },
        { static_cast<uint32_t>(AlterTableType::RENAME_FIELD), "RENAME_FIELD" },
        { static_cast<uint32_t>(AlterTableType::SET_TABLE_OPTIONS), "SET_TABLE_OPTIONS" },
        { static_cast<uint32_t>(AlterTableType::RESET_TABLE_OPTIONS), "RESET_TABLE_OPTIONS" }
    };
    return values;
}

◆ GetAlterTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAlterTypeValues ( )

private

                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AlterType::INVALID), "INVALID" },
        { static_cast<uint32_t>(AlterType::ALTER_TABLE), "ALTER_TABLE" },
        { static_cast<uint32_t>(AlterType::ALTER_VIEW), "ALTER_VIEW" },
        { static_cast<uint32_t>(AlterType::ALTER_SEQUENCE), "ALTER_SEQUENCE" },
        { static_cast<uint32_t>(AlterType::CHANGE_OWNERSHIP), "CHANGE_OWNERSHIP" },
        { static_cast<uint32_t>(AlterType::ALTER_SCALAR_FUNCTION), "ALTER_SCALAR_FUNCTION" },
        { static_cast<uint32_t>(AlterType::ALTER_TABLE_FUNCTION), "ALTER_TABLE_FUNCTION" },
        { static_cast<uint32_t>(AlterType::SET_COMMENT), "SET_COMMENT" },
        { static_cast<uint32_t>(AlterType::SET_COLUMN_COMMENT), "SET_COLUMN_COMMENT" },
        { static_cast<uint32_t>(AlterType::ALTER_DATABASE), "ALTER_DATABASE" }
    };
    return values;
}

◆ GetAlterViewTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAlterViewTypeValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AlterViewType::INVALID), "INVALID" },
        { static_cast<uint32_t>(AlterViewType::RENAME_VIEW), "RENAME_VIEW" }
    };
    return values;
}

◆ GetAppenderTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAppenderTypeValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AppenderType::LOGICAL), "LOGICAL" },
        { static_cast<uint32_t>(AppenderType::PHYSICAL), "PHYSICAL" }
    };
    return values;
}

◆ GetArrowArrayPhysicalTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetArrowArrayPhysicalTypeValues ( )

private

                                                                     {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ArrowArrayPhysicalType::DICTIONARY_ENCODED), "DICTIONARY_ENCODED" },
        { static_cast<uint32_t>(ArrowArrayPhysicalType::RUN_END_ENCODED), "RUN_END_ENCODED" },
        { static_cast<uint32_t>(ArrowArrayPhysicalType::DEFAULT), "DEFAULT" }
    };
    return values;
}

◆ GetArrowDateTimeTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetArrowDateTimeTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ArrowDateTimeType::MILLISECONDS), "MILLISECONDS" },
        { static_cast<uint32_t>(ArrowDateTimeType::MICROSECONDS), "MICROSECONDS" },
        { static_cast<uint32_t>(ArrowDateTimeType::NANOSECONDS), "NANOSECONDS" },
        { static_cast<uint32_t>(ArrowDateTimeType::SECONDS), "SECONDS" },
        { static_cast<uint32_t>(ArrowDateTimeType::DAYS), "DAYS" },
        { static_cast<uint32_t>(ArrowDateTimeType::MONTHS), "MONTHS" },
        { static_cast<uint32_t>(ArrowDateTimeType::MONTH_DAY_NANO), "MONTH_DAY_NANO" }
    };
    return values;
}

◆ GetArrowFormatVersionValues()

const StringUtil::EnumStringLiteral * duckdb::GetArrowFormatVersionValues ( )

private

                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ArrowFormatVersion::V1_0), "1.0" },
        { static_cast<uint32_t>(ArrowFormatVersion::V1_1), "1.1" },
        { static_cast<uint32_t>(ArrowFormatVersion::V1_2), "1.2" },
        { static_cast<uint32_t>(ArrowFormatVersion::V1_3), "1.3" },
        { static_cast<uint32_t>(ArrowFormatVersion::V1_4), "1.4" },
        { static_cast<uint32_t>(ArrowFormatVersion::V1_5), "1.5" }
    };
    return values;
}

◆ GetArrowOffsetSizeValues()

const StringUtil::EnumStringLiteral * duckdb::GetArrowOffsetSizeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ArrowOffsetSize::REGULAR), "REGULAR" },
        { static_cast<uint32_t>(ArrowOffsetSize::LARGE), "LARGE" }
    };
    return values;
}

◆ GetArrowTypeInfoTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetArrowTypeInfoTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ArrowTypeInfoType::LIST), "LIST" },
        { static_cast<uint32_t>(ArrowTypeInfoType::STRUCT), "STRUCT" },
        { static_cast<uint32_t>(ArrowTypeInfoType::DATE_TIME), "DATE_TIME" },
        { static_cast<uint32_t>(ArrowTypeInfoType::STRING), "STRING" },
        { static_cast<uint32_t>(ArrowTypeInfoType::ARRAY), "ARRAY" },
        { static_cast<uint32_t>(ArrowTypeInfoType::DECIMAL), "DECIMAL" }
    };
    return values;
}

◆ GetArrowVariableSizeTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetArrowVariableSizeTypeValues ( )

private

                                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ArrowVariableSizeType::NORMAL), "NORMAL" },
        { static_cast<uint32_t>(ArrowVariableSizeType::FIXED_SIZE), "FIXED_SIZE" },
        { static_cast<uint32_t>(ArrowVariableSizeType::SUPER_SIZE), "SUPER_SIZE" },
        { static_cast<uint32_t>(ArrowVariableSizeType::VIEW), "VIEW" }
    };
    return values;
}

◆ GetAsyncResultTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAsyncResultTypeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AsyncResultType::INVALID), "INVALID" },
        { static_cast<uint32_t>(AsyncResultType::IMPLICIT), "IMPLICIT" },
        { static_cast<uint32_t>(AsyncResultType::HAVE_MORE_OUTPUT), "HAVE_MORE_OUTPUT" },
        { static_cast<uint32_t>(AsyncResultType::FINISHED), "FINISHED" },
        { static_cast<uint32_t>(AsyncResultType::BLOCKED), "BLOCKED" }
    };
    return values;
}

◆ GetAsyncResultsExecutionModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetAsyncResultsExecutionModeValues ( )

private

                                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(AsyncResultsExecutionMode::SYNCHRONOUS), "SYNCHRONOUS" },
        { static_cast<uint32_t>(AsyncResultsExecutionMode::TASK_EXECUTOR), "TASK_EXECUTOR" }
    };
    return values;
}

◆ GetBaseColumnPrunerModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetBaseColumnPrunerModeValues ( )

private

                                                                   {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(BaseColumnPrunerMode::DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(BaseColumnPrunerMode::DISABLE_PUSHDOWN_EXTRACT), "DISABLE_PUSHDOWN_EXTRACT" }
    };
    return values;
}

◆ GetBinderTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetBinderTypeValues ( )

private

                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(BinderType::REGULAR_BINDER), "REGULAR_BINDER" },
        { static_cast<uint32_t>(BinderType::VIEW_BINDER), "VIEW_BINDER" }
    };
    return values;
}

◆ GetBindingModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetBindingModeValues ( )

private

                                                          {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(BindingMode::STANDARD_BINDING), "STANDARD_BINDING" },
        { static_cast<uint32_t>(BindingMode::EXTRACT_NAMES), "EXTRACT_NAMES" },
        { static_cast<uint32_t>(BindingMode::EXTRACT_REPLACEMENT_SCANS), "EXTRACT_REPLACEMENT_SCANS" },
        { static_cast<uint32_t>(BindingMode::EXTRACT_QUALIFIED_NAMES), "EXTRACT_QUALIFIED_NAMES" }
    };
    return values;
}

◆ GetBitpackingModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetBitpackingModeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(BitpackingMode::INVALID), "INVALID" },
        { static_cast<uint32_t>(BitpackingMode::AUTO), "AUTO" },
        { static_cast<uint32_t>(BitpackingMode::CONSTANT), "CONSTANT" },
        { static_cast<uint32_t>(BitpackingMode::CONSTANT_DELTA), "CONSTANT_DELTA" },
        { static_cast<uint32_t>(BitpackingMode::DELTA_FOR), "DELTA_FOR" },
        { static_cast<uint32_t>(BitpackingMode::FOR), "FOR" }
    };
    return values;
}

◆ GetBlockIteratorStateTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetBlockIteratorStateTypeValues ( )

private

                                                                     {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(BlockIteratorStateType::IN_MEMORY), "IN_MEMORY" },
        { static_cast<uint32_t>(BlockIteratorStateType::EXTERNAL), "EXTERNAL" }
    };
    return values;
}

◆ GetBlockStateValues()

const StringUtil::EnumStringLiteral * duckdb::GetBlockStateValues ( )

private

                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(BlockState::BLOCK_UNLOADED), "BLOCK_UNLOADED" },
        { static_cast<uint32_t>(BlockState::BLOCK_LOADED), "BLOCK_LOADED" }
    };
    return values;
}

◆ GetBufferedIndexReplayValues()

const StringUtil::EnumStringLiteral * duckdb::GetBufferedIndexReplayValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(BufferedIndexReplay::INSERT_ENTRY), "INSERT_ENTRY" },
        { static_cast<uint32_t>(BufferedIndexReplay::DEL_ENTRY), "DEL_ENTRY" }
    };
    return values;
}

◆ GetCAPIResultSetTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetCAPIResultSetTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CAPIResultSetType::CAPI_RESULT_TYPE_NONE), "CAPI_RESULT_TYPE_NONE" },
        { static_cast<uint32_t>(CAPIResultSetType::CAPI_RESULT_TYPE_MATERIALIZED), "CAPI_RESULT_TYPE_MATERIALIZED" },
        { static_cast<uint32_t>(CAPIResultSetType::CAPI_RESULT_TYPE_STREAMING), "CAPI_RESULT_TYPE_STREAMING" },
        { static_cast<uint32_t>(CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED), "CAPI_RESULT_TYPE_DEPRECATED" }
    };
    return values;
}

◆ GetCSVStateValues()

const StringUtil::EnumStringLiteral * duckdb::GetCSVStateValues ( )

private

                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CSVState::STANDARD), "STANDARD" },
        { static_cast<uint32_t>(CSVState::DELIMITER), "DELIMITER" },
        { static_cast<uint32_t>(CSVState::DELIMITER_FIRST_BYTE), "DELIMITER_FIRST_BYTE" },
        { static_cast<uint32_t>(CSVState::DELIMITER_SECOND_BYTE), "DELIMITER_SECOND_BYTE" },
        { static_cast<uint32_t>(CSVState::DELIMITER_THIRD_BYTE), "DELIMITER_THIRD_BYTE" },
        { static_cast<uint32_t>(CSVState::RECORD_SEPARATOR), "RECORD_SEPARATOR" },
        { static_cast<uint32_t>(CSVState::CARRIAGE_RETURN), "CARRIAGE_RETURN" },
        { static_cast<uint32_t>(CSVState::QUOTED), "QUOTED" },
        { static_cast<uint32_t>(CSVState::UNQUOTED), "UNQUOTED" },
        { static_cast<uint32_t>(CSVState::ESCAPE), "ESCAPE" },
        { static_cast<uint32_t>(CSVState::INVALID), "INVALID" },
        { static_cast<uint32_t>(CSVState::NOT_SET), "NOT_SET" },
        { static_cast<uint32_t>(CSVState::QUOTED_NEW_LINE), "QUOTED_NEW_LINE" },
        { static_cast<uint32_t>(CSVState::EMPTY_SPACE), "EMPTY_SPACE" },
        { static_cast<uint32_t>(CSVState::COMMENT), "COMMENT" },
        { static_cast<uint32_t>(CSVState::STANDARD_NEWLINE), "STANDARD_NEWLINE" },
        { static_cast<uint32_t>(CSVState::UNQUOTED_ESCAPE), "UNQUOTED_ESCAPE" },
        { static_cast<uint32_t>(CSVState::ESCAPED_RETURN), "ESCAPED_RETURN" },
        { static_cast<uint32_t>(CSVState::MAYBE_QUOTED), "MAYBE_QUOTED" }
    };
    return values;
}

◆ GetCTEMaterializeValues()

const StringUtil::EnumStringLiteral * duckdb::GetCTEMaterializeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CTEMaterialize::CTE_MATERIALIZE_DEFAULT), "CTE_MATERIALIZE_DEFAULT" },
        { static_cast<uint32_t>(CTEMaterialize::CTE_MATERIALIZE_ALWAYS), "CTE_MATERIALIZE_ALWAYS" },
        { static_cast<uint32_t>(CTEMaterialize::CTE_MATERIALIZE_NEVER), "CTE_MATERIALIZE_NEVER" }
    };
    return values;
}

◆ GetCacheValidationModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetCacheValidationModeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CacheValidationMode::VALIDATE_ALL), "VALIDATE_ALL" },
        { static_cast<uint32_t>(CacheValidationMode::VALIDATE_REMOTE), "VALIDATE_REMOTE" },
        { static_cast<uint32_t>(CacheValidationMode::NO_VALIDATION), "NO_VALIDATION" }
    };
    return values;
}

◆ GetCachingModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetCachingModeValues ( )

private

                                                          {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CachingMode::ALWAYS_CACHE), "ALWAYS_CACHE" },
        { static_cast<uint32_t>(CachingMode::CACHE_REMOTE_ONLY), "CACHE_REMOTE_ONLY" },
        { static_cast<uint32_t>(CachingMode::NO_CACHING), "NO_CACHING" }
    };
    return values;
}

◆ GetCatalogLookupBehaviorValues()

const StringUtil::EnumStringLiteral * duckdb::GetCatalogLookupBehaviorValues ( )

private

                                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CatalogLookupBehavior::STANDARD), "STANDARD" },
        { static_cast<uint32_t>(CatalogLookupBehavior::LOWER_PRIORITY), "LOWER_PRIORITY" },
        { static_cast<uint32_t>(CatalogLookupBehavior::NEVER_LOOKUP), "NEVER_LOOKUP" }
    };
    return values;
}

◆ GetCatalogTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetCatalogTypeValues ( )

private

                                                          {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CatalogType::INVALID), "INVALID" },
        { static_cast<uint32_t>(CatalogType::TABLE_ENTRY), "TABLE_ENTRY" },
        { static_cast<uint32_t>(CatalogType::SCHEMA_ENTRY), "SCHEMA_ENTRY" },
        { static_cast<uint32_t>(CatalogType::VIEW_ENTRY), "VIEW_ENTRY" },
        { static_cast<uint32_t>(CatalogType::INDEX_ENTRY), "INDEX_ENTRY" },
        { static_cast<uint32_t>(CatalogType::PREPARED_STATEMENT), "PREPARED_STATEMENT" },
        { static_cast<uint32_t>(CatalogType::SEQUENCE_ENTRY), "SEQUENCE_ENTRY" },
        { static_cast<uint32_t>(CatalogType::COLLATION_ENTRY), "COLLATION_ENTRY" },
        { static_cast<uint32_t>(CatalogType::TYPE_ENTRY), "TYPE_ENTRY" },
        { static_cast<uint32_t>(CatalogType::DATABASE_ENTRY), "DATABASE_ENTRY" },
        { static_cast<uint32_t>(CatalogType::COORDINATE_SYSTEM_ENTRY), "COORDINATE_SYSTEM_ENTRY" },
        { static_cast<uint32_t>(CatalogType::TABLE_FUNCTION_ENTRY), "TABLE_FUNCTION_ENTRY" },
        { static_cast<uint32_t>(CatalogType::SCALAR_FUNCTION_ENTRY), "SCALAR_FUNCTION_ENTRY" },
        { static_cast<uint32_t>(CatalogType::AGGREGATE_FUNCTION_ENTRY), "AGGREGATE_FUNCTION_ENTRY" },
        { static_cast<uint32_t>(CatalogType::PRAGMA_FUNCTION_ENTRY), "PRAGMA_FUNCTION_ENTRY" },
        { static_cast<uint32_t>(CatalogType::COPY_FUNCTION_ENTRY), "COPY_FUNCTION_ENTRY" },
        { static_cast<uint32_t>(CatalogType::MACRO_ENTRY), "MACRO_ENTRY" },
        { static_cast<uint32_t>(CatalogType::TABLE_MACRO_ENTRY), "TABLE_MACRO_ENTRY" },
        { static_cast<uint32_t>(CatalogType::DELETED_ENTRY), "DELETED_ENTRY" },
        { static_cast<uint32_t>(CatalogType::RENAMED_ENTRY), "RENAMED_ENTRY" },
        { static_cast<uint32_t>(CatalogType::SECRET_ENTRY), "SECRET_ENTRY" },
        { static_cast<uint32_t>(CatalogType::SECRET_TYPE_ENTRY), "SECRET_TYPE_ENTRY" },
        { static_cast<uint32_t>(CatalogType::SECRET_FUNCTION_ENTRY), "SECRET_FUNCTION_ENTRY" },
        { static_cast<uint32_t>(CatalogType::DEPENDENCY_ENTRY), "DEPENDENCY_ENTRY" }
    };
    return values;
}

◆ GetCheckpointAbortValues()

const StringUtil::EnumStringLiteral * duckdb::GetCheckpointAbortValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CheckpointAbort::NO_ABORT), "NONE" },
        { static_cast<uint32_t>(CheckpointAbort::DEBUG_ABORT_BEFORE_TRUNCATE), "BEFORE_TRUNCATE" },
        { static_cast<uint32_t>(CheckpointAbort::DEBUG_ABORT_BEFORE_HEADER), "BEFORE_HEADER" },
        { static_cast<uint32_t>(CheckpointAbort::DEBUG_ABORT_AFTER_FREE_LIST_WRITE), "AFTER_FREE_LIST_WRITE" },
        { static_cast<uint32_t>(CheckpointAbort::DEBUG_ABORT_BEFORE_WAL_FINISH), "BEFORE_WAL_FINISH" },
        { static_cast<uint32_t>(CheckpointAbort::DEBUG_ABORT_BEFORE_MOVING_RECOVERY), "BEFORE_MOVING_RECOVERY" },
        { static_cast<uint32_t>(CheckpointAbort::DEBUG_ABORT_BEFORE_DELETING_CHECKPOINT_WAL), "BEFORE_DELETING_CHECKPOINT_WAL" }
    };
    return values;
}

◆ GetChunkInfoTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetChunkInfoTypeValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ChunkInfoType::CONSTANT_INFO), "CONSTANT_INFO" },
        { static_cast<uint32_t>(ChunkInfoType::VECTOR_INFO), "VECTOR_INFO" },
        { static_cast<uint32_t>(ChunkInfoType::EMPTY_INFO), "EMPTY_INFO" }
    };
    return values;
}

◆ GetColumnDataAllocatorTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetColumnDataAllocatorTypeValues ( )

private

                                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR), "BUFFER_MANAGER_ALLOCATOR" },
        { static_cast<uint32_t>(ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR), "IN_MEMORY_ALLOCATOR" },
        { static_cast<uint32_t>(ColumnDataAllocatorType::HYBRID), "HYBRID" }
    };
    return values;
}

◆ GetColumnDataScanPropertiesValues()

const StringUtil::EnumStringLiteral * duckdb::GetColumnDataScanPropertiesValues ( )

private

                                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ColumnDataScanProperties::INVALID), "INVALID" },
        { static_cast<uint32_t>(ColumnDataScanProperties::ALLOW_ZERO_COPY), "ALLOW_ZERO_COPY" },
        { static_cast<uint32_t>(ColumnDataScanProperties::DISALLOW_ZERO_COPY), "DISALLOW_ZERO_COPY" }
    };
    return values;
}

◆ GetColumnIndexTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetColumnIndexTypeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ColumnIndexType::INVALID), "INVALID" },
        { static_cast<uint32_t>(ColumnIndexType::FULL_READ), "FULL_READ" },
        { static_cast<uint32_t>(ColumnIndexType::PUSHDOWN_EXTRACT), "PUSHDOWN_EXTRACT" }
    };
    return values;
}

◆ GetColumnSegmentTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetColumnSegmentTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ColumnSegmentType::TRANSIENT), "TRANSIENT" },
        { static_cast<uint32_t>(ColumnSegmentType::PERSISTENT), "PERSISTENT" }
    };
    return values;
}

◆ GetCompressedMaterializationDirectionValues()

const StringUtil::EnumStringLiteral * duckdb::GetCompressedMaterializationDirectionValues ( )

private

                                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CompressedMaterializationDirection::INVALID), "INVALID" },
        { static_cast<uint32_t>(CompressedMaterializationDirection::COMPRESS), "COMPRESS" },
        { static_cast<uint32_t>(CompressedMaterializationDirection::DECOMPRESS), "DECOMPRESS" }
    };
    return values;
}

◆ GetCompressionTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetCompressionTypeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CompressionType::COMPRESSION_AUTO), "AUTO" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_UNCOMPRESSED), "UNCOMPRESSED" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_CONSTANT), "CONSTANT" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_RLE), "RLE" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_DICTIONARY), "DICTIONARY" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_PFOR_DELTA), "PFOR" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_BITPACKING), "BITPACKING" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_FSST), "FSST" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_CHIMP), "CHIMP" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_PATAS), "PATAS" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_ALP), "ALP" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_ALPRD), "ALPRD" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_ZSTD), "ZSTD" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_ROARING), "ROARING" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_EMPTY), "EMPTY" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_DICT_FSST), "DICT_FSST" },
        { static_cast<uint32_t>(CompressionType::COMPRESSION_COUNT), "COMPRESSION_COUNT" }
    };
    return values;
}

◆ GetCompressionValidityValues()

const StringUtil::EnumStringLiteral * duckdb::GetCompressionValidityValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CompressionValidity::REQUIRES_VALIDITY), "REQUIRES_VALIDITY" },
        { static_cast<uint32_t>(CompressionValidity::NO_VALIDITY_REQUIRED), "NO_VALIDITY_REQUIRED" }
    };
    return values;
}

◆ GetConflictManagerModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetConflictManagerModeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ConflictManagerMode::SCAN), "SCAN" },
        { static_cast<uint32_t>(ConflictManagerMode::THROW), "THROW" }
    };
    return values;
}

◆ GetConstraintTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetConstraintTypeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ConstraintType::INVALID), "INVALID" },
        { static_cast<uint32_t>(ConstraintType::NOT_NULL), "NOT_NULL" },
        { static_cast<uint32_t>(ConstraintType::CHECK), "CHECK" },
        { static_cast<uint32_t>(ConstraintType::UNIQUE), "UNIQUE" },
        { static_cast<uint32_t>(ConstraintType::FOREIGN_KEY), "FOREIGN_KEY" }
    };
    return values;
}

◆ GetCoordinateReferenceSystemTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetCoordinateReferenceSystemTypeValues ( )

private

                                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CoordinateReferenceSystemType::INVALID), "INVALID" },
        { static_cast<uint32_t>(CoordinateReferenceSystemType::SRID), "SRID" },
        { static_cast<uint32_t>(CoordinateReferenceSystemType::AUTH_CODE), "AUTH_CODE" },
        { static_cast<uint32_t>(CoordinateReferenceSystemType::PROJJSON), "PROJJSON" },
        { static_cast<uint32_t>(CoordinateReferenceSystemType::WKT2_2019), "WKT2_2019" }
    };
    return values;
}

◆ GetCopyFunctionReturnTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetCopyFunctionReturnTypeValues ( )

private

                                                                     {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CopyFunctionReturnType::CHANGED_ROWS), "CHANGED_ROWS" },
        { static_cast<uint32_t>(CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST), "CHANGED_ROWS_AND_FILE_LIST" },
        { static_cast<uint32_t>(CopyFunctionReturnType::WRITTEN_FILE_STATISTICS), "WRITTEN_FILE_STATISTICS" }
    };
    return values;
}

◆ GetCopyOverwriteModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetCopyOverwriteModeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CopyOverwriteMode::COPY_ERROR_ON_CONFLICT), "COPY_ERROR_ON_CONFLICT" },
        { static_cast<uint32_t>(CopyOverwriteMode::COPY_OVERWRITE), "COPY_OVERWRITE" },
        { static_cast<uint32_t>(CopyOverwriteMode::COPY_OVERWRITE_OR_IGNORE), "COPY_OVERWRITE_OR_IGNORE" },
        { static_cast<uint32_t>(CopyOverwriteMode::COPY_APPEND), "COPY_APPEND" }
    };
    return values;
}

◆ GetCopyToTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetCopyToTypeValues ( )

private

                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(CopyToType::COPY_TO_FILE), "COPY_TO_FILE" },
        { static_cast<uint32_t>(CopyToType::EXPORT_DATABASE), "EXPORT_DATABASE" }
    };
    return values;
}

◆ GetDataFileTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetDataFileTypeValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DataFileType::FILE_DOES_NOT_EXIST), "FILE_DOES_NOT_EXIST" },
        { static_cast<uint32_t>(DataFileType::DUCKDB_FILE), "DUCKDB_FILE" },
        { static_cast<uint32_t>(DataFileType::SQLITE_FILE), "SQLITE_FILE" },
        { static_cast<uint32_t>(DataFileType::PARQUET_FILE), "PARQUET_FILE" },
        { static_cast<uint32_t>(DataFileType::UNKNOWN_FILE), "UNKNOWN_FILE" }
    };
    return values;
}

◆ GetDateCastResultValues()

const StringUtil::EnumStringLiteral * duckdb::GetDateCastResultValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DateCastResult::SUCCESS), "SUCCESS" },
        { static_cast<uint32_t>(DateCastResult::ERROR_INCORRECT_FORMAT), "ERROR_INCORRECT_FORMAT" },
        { static_cast<uint32_t>(DateCastResult::ERROR_RANGE), "ERROR_RANGE" }
    };
    return values;
}

◆ GetDatePartSpecifierValues()

const StringUtil::EnumStringLiteral * duckdb::GetDatePartSpecifierValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DatePartSpecifier::YEAR), "YEAR" },
        { static_cast<uint32_t>(DatePartSpecifier::MONTH), "MONTH" },
        { static_cast<uint32_t>(DatePartSpecifier::DAY), "DAY" },
        { static_cast<uint32_t>(DatePartSpecifier::DECADE), "DECADE" },
        { static_cast<uint32_t>(DatePartSpecifier::CENTURY), "CENTURY" },
        { static_cast<uint32_t>(DatePartSpecifier::MILLENNIUM), "MILLENNIUM" },
        { static_cast<uint32_t>(DatePartSpecifier::MICROSECONDS), "MICROSECONDS" },
        { static_cast<uint32_t>(DatePartSpecifier::MILLISECONDS), "MILLISECONDS" },
        { static_cast<uint32_t>(DatePartSpecifier::SECOND), "SECOND" },
        { static_cast<uint32_t>(DatePartSpecifier::MINUTE), "MINUTE" },
        { static_cast<uint32_t>(DatePartSpecifier::HOUR), "HOUR" },
        { static_cast<uint32_t>(DatePartSpecifier::DOW), "DOW" },
        { static_cast<uint32_t>(DatePartSpecifier::ISODOW), "ISODOW" },
        { static_cast<uint32_t>(DatePartSpecifier::WEEK), "WEEK" },
        { static_cast<uint32_t>(DatePartSpecifier::ISOYEAR), "ISOYEAR" },
        { static_cast<uint32_t>(DatePartSpecifier::QUARTER), "QUARTER" },
        { static_cast<uint32_t>(DatePartSpecifier::DOY), "DOY" },
        { static_cast<uint32_t>(DatePartSpecifier::YEARWEEK), "YEARWEEK" },
        { static_cast<uint32_t>(DatePartSpecifier::ERA), "ERA" },
        { static_cast<uint32_t>(DatePartSpecifier::TIMEZONE), "TIMEZONE" },
        { static_cast<uint32_t>(DatePartSpecifier::TIMEZONE_HOUR), "TIMEZONE_HOUR" },
        { static_cast<uint32_t>(DatePartSpecifier::TIMEZONE_MINUTE), "TIMEZONE_MINUTE" },
        { static_cast<uint32_t>(DatePartSpecifier::EPOCH), "EPOCH" },
        { static_cast<uint32_t>(DatePartSpecifier::JULIAN_DAY), "JULIAN_DAY" },
        { static_cast<uint32_t>(DatePartSpecifier::INVALID), "INVALID" }
    };
    return values;
}

◆ GetDebugInitializeValues()

const StringUtil::EnumStringLiteral * duckdb::GetDebugInitializeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DebugInitialize::NO_INITIALIZE), "NO_INITIALIZE" },
        { static_cast<uint32_t>(DebugInitialize::DEBUG_ZERO_INITIALIZE), "DEBUG_ZERO_INITIALIZE" },
        { static_cast<uint32_t>(DebugInitialize::DEBUG_ONE_INITIALIZE), "DEBUG_ONE_INITIALIZE" }
    };
    return values;
}

◆ GetDebugVectorVerificationValues()

const StringUtil::EnumStringLiteral * duckdb::GetDebugVectorVerificationValues ( )

private

                                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DebugVectorVerification::NONE), "NONE" },
        { static_cast<uint32_t>(DebugVectorVerification::DICTIONARY_EXPRESSION), "DICTIONARY_EXPRESSION" },
        { static_cast<uint32_t>(DebugVectorVerification::DICTIONARY_OPERATOR), "DICTIONARY_OPERATOR" },
        { static_cast<uint32_t>(DebugVectorVerification::CONSTANT_OPERATOR), "CONSTANT_OPERATOR" },
        { static_cast<uint32_t>(DebugVectorVerification::SEQUENCE_OPERATOR), "SEQUENCE_OPERATOR" },
        { static_cast<uint32_t>(DebugVectorVerification::NESTED_SHUFFLE), "NESTED_SHUFFLE" },
        { static_cast<uint32_t>(DebugVectorVerification::VARIANT_VECTOR), "VARIANT_VECTOR" }
    };
    return values;
}

◆ GetDecimalBitWidthValues()

const StringUtil::EnumStringLiteral * duckdb::GetDecimalBitWidthValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DecimalBitWidth::DECIMAL_32), "DECIMAL_32" },
        { static_cast<uint32_t>(DecimalBitWidth::DECIMAL_64), "DECIMAL_64" },
        { static_cast<uint32_t>(DecimalBitWidth::DECIMAL_128), "DECIMAL_128" },
        { static_cast<uint32_t>(DecimalBitWidth::DECIMAL_256), "DECIMAL_256" }
    };
    return values;
}

◆ GetDefaultOrderByNullTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetDefaultOrderByNullTypeValues ( )

private

                                                                     {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DefaultOrderByNullType::INVALID), "INVALID" },
        { static_cast<uint32_t>(DefaultOrderByNullType::NULLS_FIRST), "NULLS_FIRST" },
        { static_cast<uint32_t>(DefaultOrderByNullType::NULLS_LAST), "NULLS_LAST" },
        { static_cast<uint32_t>(DefaultOrderByNullType::NULLS_FIRST_ON_ASC_LAST_ON_DESC), "NULLS_FIRST_ON_ASC_LAST_ON_DESC" },
        { static_cast<uint32_t>(DefaultOrderByNullType::NULLS_LAST_ON_ASC_FIRST_ON_DESC), "NULLS_LAST_ON_ASC_FIRST_ON_DESC" }
    };
    return values;
}

◆ GetDependencyEntryTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetDependencyEntryTypeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DependencyEntryType::SUBJECT), "SUBJECT" },
        { static_cast<uint32_t>(DependencyEntryType::DEPENDENT), "DEPENDENT" }
    };
    return values;
}

◆ GetDeprecatedIndexTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetDeprecatedIndexTypeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DeprecatedIndexType::INVALID), "INVALID" },
        { static_cast<uint32_t>(DeprecatedIndexType::ART), "ART" },
        { static_cast<uint32_t>(DeprecatedIndexType::EXTENSION), "EXTENSION" }
    };
    return values;
}

◆ GetDeprecatedUsingKeySyntaxValues()

const StringUtil::EnumStringLiteral * duckdb::GetDeprecatedUsingKeySyntaxValues ( )

private

                                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DeprecatedUsingKeySyntax::DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(DeprecatedUsingKeySyntax::UNION_AS_UNION_ALL), "UNION_AS_UNION_ALL" }
    };
    return values;
}

◆ GetDestroyBufferUponValues()

const StringUtil::EnumStringLiteral * duckdb::GetDestroyBufferUponValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DestroyBufferUpon::BLOCK), "BLOCK" },
        { static_cast<uint32_t>(DestroyBufferUpon::EVICTION), "EVICTION" },
        { static_cast<uint32_t>(DestroyBufferUpon::UNPIN), "UNPIN" }
    };
    return values;
}

◆ GetDistinctTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetDistinctTypeValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(DistinctType::DISTINCT), "DISTINCT" },
        { static_cast<uint32_t>(DistinctType::DISTINCT_ON), "DISTINCT_ON" }
    };
    return values;
}

◆ GetErrorTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetErrorTypeValues ( )

private

                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ErrorType::UNSIGNED_EXTENSION), "UNSIGNED_EXTENSION" },
        { static_cast<uint32_t>(ErrorType::INVALIDATED_TRANSACTION), "INVALIDATED_TRANSACTION" },
        { static_cast<uint32_t>(ErrorType::INVALIDATED_DATABASE), "INVALIDATED_DATABASE" },
        { static_cast<uint32_t>(ErrorType::ERROR_COUNT), "ERROR_COUNT" },
        { static_cast<uint32_t>(ErrorType::INVALID), "INVALID" }
    };
    return values;
}

◆ GetExceptionFormatValueTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetExceptionFormatValueTypeValues ( )

private

                                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE), "FORMAT_VALUE_TYPE_DOUBLE" },
        { static_cast<uint32_t>(ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER), "FORMAT_VALUE_TYPE_INTEGER" },
        { static_cast<uint32_t>(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), "FORMAT_VALUE_TYPE_STRING" }
    };
    return values;
}

◆ GetExceptionTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetExceptionTypeValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExceptionType::INVALID), "INVALID" },
        { static_cast<uint32_t>(ExceptionType::OUT_OF_RANGE), "OUT_OF_RANGE" },
        { static_cast<uint32_t>(ExceptionType::CONVERSION), "CONVERSION" },
        { static_cast<uint32_t>(ExceptionType::UNKNOWN_TYPE), "UNKNOWN_TYPE" },
        { static_cast<uint32_t>(ExceptionType::DECIMAL), "DECIMAL" },
        { static_cast<uint32_t>(ExceptionType::MISMATCH_TYPE), "MISMATCH_TYPE" },
        { static_cast<uint32_t>(ExceptionType::DIVIDE_BY_ZERO), "DIVIDE_BY_ZERO" },
        { static_cast<uint32_t>(ExceptionType::OBJECT_SIZE), "OBJECT_SIZE" },
        { static_cast<uint32_t>(ExceptionType::INVALID_TYPE), "INVALID_TYPE" },
        { static_cast<uint32_t>(ExceptionType::SERIALIZATION), "SERIALIZATION" },
        { static_cast<uint32_t>(ExceptionType::TRANSACTION), "TRANSACTION" },
        { static_cast<uint32_t>(ExceptionType::NOT_IMPLEMENTED), "NOT_IMPLEMENTED" },
        { static_cast<uint32_t>(ExceptionType::EXPRESSION), "EXPRESSION" },
        { static_cast<uint32_t>(ExceptionType::CATALOG), "CATALOG" },
        { static_cast<uint32_t>(ExceptionType::PARSER), "PARSER" },
        { static_cast<uint32_t>(ExceptionType::PLANNER), "PLANNER" },
        { static_cast<uint32_t>(ExceptionType::SCHEDULER), "SCHEDULER" },
        { static_cast<uint32_t>(ExceptionType::EXECUTOR), "EXECUTOR" },
        { static_cast<uint32_t>(ExceptionType::CONSTRAINT), "CONSTRAINT" },
        { static_cast<uint32_t>(ExceptionType::INDEX), "INDEX" },
        { static_cast<uint32_t>(ExceptionType::STAT), "STAT" },
        { static_cast<uint32_t>(ExceptionType::CONNECTION), "CONNECTION" },
        { static_cast<uint32_t>(ExceptionType::SYNTAX), "SYNTAX" },
        { static_cast<uint32_t>(ExceptionType::SETTINGS), "SETTINGS" },
        { static_cast<uint32_t>(ExceptionType::BINDER), "BINDER" },
        { static_cast<uint32_t>(ExceptionType::NETWORK), "NETWORK" },
        { static_cast<uint32_t>(ExceptionType::OPTIMIZER), "OPTIMIZER" },
        { static_cast<uint32_t>(ExceptionType::NULL_POINTER), "NULL_POINTER" },
        { static_cast<uint32_t>(ExceptionType::IO), "IO" },
        { static_cast<uint32_t>(ExceptionType::INTERRUPT), "INTERRUPT" },
        { static_cast<uint32_t>(ExceptionType::FATAL), "FATAL" },
        { static_cast<uint32_t>(ExceptionType::INTERNAL), "INTERNAL" },
        { static_cast<uint32_t>(ExceptionType::INVALID_INPUT), "INVALID_INPUT" },
        { static_cast<uint32_t>(ExceptionType::OUT_OF_MEMORY), "OUT_OF_MEMORY" },
        { static_cast<uint32_t>(ExceptionType::PERMISSION), "PERMISSION" },
        { static_cast<uint32_t>(ExceptionType::PARAMETER_NOT_RESOLVED), "PARAMETER_NOT_RESOLVED" },
        { static_cast<uint32_t>(ExceptionType::PARAMETER_NOT_ALLOWED), "PARAMETER_NOT_ALLOWED" },
        { static_cast<uint32_t>(ExceptionType::DEPENDENCY), "DEPENDENCY" },
        { static_cast<uint32_t>(ExceptionType::HTTP), "HTTP" },
        { static_cast<uint32_t>(ExceptionType::MISSING_EXTENSION), "MISSING_EXTENSION" },
        { static_cast<uint32_t>(ExceptionType::AUTOLOAD), "AUTOLOAD" },
        { static_cast<uint32_t>(ExceptionType::SEQUENCE), "SEQUENCE" },
        { static_cast<uint32_t>(ExceptionType::INVALID_CONFIGURATION), "INVALID_CONFIGURATION" }
    };
    return values;
}

◆ GetExplainFormatValues()

const StringUtil::EnumStringLiteral * duckdb::GetExplainFormatValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExplainFormat::DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(ExplainFormat::TEXT), "TEXT" },
        { static_cast<uint32_t>(ExplainFormat::JSON), "JSON" },
        { static_cast<uint32_t>(ExplainFormat::HTML), "HTML" },
        { static_cast<uint32_t>(ExplainFormat::GRAPHVIZ), "GRAPHVIZ" },
        { static_cast<uint32_t>(ExplainFormat::YAML), "YAML" },
        { static_cast<uint32_t>(ExplainFormat::MERMAID), "MERMAID" }
    };
    return values;
}

◆ GetExplainOutputTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetExplainOutputTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExplainOutputType::ALL), "ALL" },
        { static_cast<uint32_t>(ExplainOutputType::OPTIMIZED_ONLY), "OPTIMIZED_ONLY" },
        { static_cast<uint32_t>(ExplainOutputType::PHYSICAL_ONLY), "PHYSICAL_ONLY" }
    };
    return values;
}

◆ GetExplainTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetExplainTypeValues ( )

private

                                                          {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExplainType::EXPLAIN_STANDARD), "EXPLAIN_STANDARD" },
        { static_cast<uint32_t>(ExplainType::EXPLAIN_ANALYZE), "EXPLAIN_ANALYZE" }
    };
    return values;
}

◆ GetExponentTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetExponentTypeValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExponentType::NONE), "NONE" },
        { static_cast<uint32_t>(ExponentType::POSITIVE), "POSITIVE" },
        { static_cast<uint32_t>(ExponentType::NEGATIVE), "NEGATIVE" }
    };
    return values;
}

◆ GetExpressionClassValues()

const StringUtil::EnumStringLiteral * duckdb::GetExpressionClassValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExpressionClass::INVALID), "INVALID" },
        { static_cast<uint32_t>(ExpressionClass::AGGREGATE), "AGGREGATE" },
        { static_cast<uint32_t>(ExpressionClass::CASE), "CASE" },
        { static_cast<uint32_t>(ExpressionClass::CAST), "CAST" },
        { static_cast<uint32_t>(ExpressionClass::COLUMN_REF), "COLUMN_REF" },
        { static_cast<uint32_t>(ExpressionClass::COMPARISON), "COMPARISON" },
        { static_cast<uint32_t>(ExpressionClass::CONJUNCTION), "CONJUNCTION" },
        { static_cast<uint32_t>(ExpressionClass::CONSTANT), "CONSTANT" },
        { static_cast<uint32_t>(ExpressionClass::DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(ExpressionClass::FUNCTION), "FUNCTION" },
        { static_cast<uint32_t>(ExpressionClass::OPERATOR), "OPERATOR" },
        { static_cast<uint32_t>(ExpressionClass::STAR), "STAR" },
        { static_cast<uint32_t>(ExpressionClass::SUBQUERY), "SUBQUERY" },
        { static_cast<uint32_t>(ExpressionClass::WINDOW), "WINDOW" },
        { static_cast<uint32_t>(ExpressionClass::PARAMETER), "PARAMETER" },
        { static_cast<uint32_t>(ExpressionClass::COLLATE), "COLLATE" },
        { static_cast<uint32_t>(ExpressionClass::LAMBDA), "LAMBDA" },
        { static_cast<uint32_t>(ExpressionClass::POSITIONAL_REFERENCE), "POSITIONAL_REFERENCE" },
        { static_cast<uint32_t>(ExpressionClass::BETWEEN), "BETWEEN" },
        { static_cast<uint32_t>(ExpressionClass::LAMBDA_REF), "LAMBDA_REF" },
        { static_cast<uint32_t>(ExpressionClass::TYPE), "TYPE" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_AGGREGATE), "BOUND_AGGREGATE" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_CASE), "BOUND_CASE" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_CAST), "BOUND_CAST" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_COLUMN_REF), "BOUND_COLUMN_REF" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_COMPARISON), "BOUND_COMPARISON" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_CONJUNCTION), "BOUND_CONJUNCTION" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_CONSTANT), "BOUND_CONSTANT" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_DEFAULT), "BOUND_DEFAULT" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_FUNCTION), "BOUND_FUNCTION" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_OPERATOR), "BOUND_OPERATOR" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_PARAMETER), "BOUND_PARAMETER" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_REF), "BOUND_REF" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_SUBQUERY), "BOUND_SUBQUERY" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_WINDOW), "BOUND_WINDOW" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_BETWEEN), "BOUND_BETWEEN" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_UNNEST), "BOUND_UNNEST" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_LAMBDA), "BOUND_LAMBDA" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_LAMBDA_REF), "BOUND_LAMBDA_REF" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_EXPRESSION), "BOUND_EXPRESSION" },
        { static_cast<uint32_t>(ExpressionClass::BOUND_EXPANDED), "BOUND_EXPANDED" }
    };
    return values;
}

◆ GetExpressionTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetExpressionTypeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExpressionType::INVALID), "INVALID" },
        { static_cast<uint32_t>(ExpressionType::OPERATOR_CAST), "OPERATOR_CAST" },
        { static_cast<uint32_t>(ExpressionType::OPERATOR_NOT), "OPERATOR_NOT" },
        { static_cast<uint32_t>(ExpressionType::OPERATOR_IS_NULL), "OPERATOR_IS_NULL" },
        { static_cast<uint32_t>(ExpressionType::OPERATOR_IS_NOT_NULL), "OPERATOR_IS_NOT_NULL" },
        { static_cast<uint32_t>(ExpressionType::OPERATOR_UNPACK), "OPERATOR_UNPACK" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_EQUAL), "COMPARE_EQUAL" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_NOTEQUAL), "COMPARE_NOTEQUAL" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_LESSTHAN), "COMPARE_LESSTHAN" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_GREATERTHAN), "COMPARE_GREATERTHAN" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_LESSTHANOREQUALTO), "COMPARE_LESSTHANOREQUALTO" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_GREATERTHANOREQUALTO), "COMPARE_GREATERTHANOREQUALTO" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_IN), "COMPARE_IN" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_NOT_IN), "COMPARE_NOT_IN" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_DISTINCT_FROM), "COMPARE_DISTINCT_FROM" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_BETWEEN), "COMPARE_BETWEEN" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_NOT_BETWEEN), "COMPARE_NOT_BETWEEN" },
        { static_cast<uint32_t>(ExpressionType::COMPARE_NOT_DISTINCT_FROM), "COMPARE_NOT_DISTINCT_FROM" },
        { static_cast<uint32_t>(ExpressionType::CONJUNCTION_AND), "CONJUNCTION_AND" },
        { static_cast<uint32_t>(ExpressionType::CONJUNCTION_OR), "CONJUNCTION_OR" },
        { static_cast<uint32_t>(ExpressionType::VALUE_CONSTANT), "VALUE_CONSTANT" },
        { static_cast<uint32_t>(ExpressionType::VALUE_PARAMETER), "VALUE_PARAMETER" },
        { static_cast<uint32_t>(ExpressionType::VALUE_TUPLE), "VALUE_TUPLE" },
        { static_cast<uint32_t>(ExpressionType::VALUE_TUPLE_ADDRESS), "VALUE_TUPLE_ADDRESS" },
        { static_cast<uint32_t>(ExpressionType::VALUE_NULL), "VALUE_NULL" },
        { static_cast<uint32_t>(ExpressionType::VALUE_VECTOR), "VALUE_VECTOR" },
        { static_cast<uint32_t>(ExpressionType::VALUE_SCALAR), "VALUE_SCALAR" },
        { static_cast<uint32_t>(ExpressionType::VALUE_DEFAULT), "VALUE_DEFAULT" },
        { static_cast<uint32_t>(ExpressionType::AGGREGATE), "AGGREGATE" },
        { static_cast<uint32_t>(ExpressionType::BOUND_AGGREGATE), "BOUND_AGGREGATE" },
        { static_cast<uint32_t>(ExpressionType::GROUPING_FUNCTION), "GROUPING_FUNCTION" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_AGGREGATE), "WINDOW_AGGREGATE" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_RANK), "WINDOW_RANK" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_RANK_DENSE), "WINDOW_RANK_DENSE" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_NTILE), "WINDOW_NTILE" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_PERCENT_RANK), "WINDOW_PERCENT_RANK" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_CUME_DIST), "WINDOW_CUME_DIST" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_ROW_NUMBER), "WINDOW_ROW_NUMBER" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_FIRST_VALUE), "WINDOW_FIRST_VALUE" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_LAST_VALUE), "WINDOW_LAST_VALUE" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_LEAD), "WINDOW_LEAD" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_LAG), "WINDOW_LAG" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_NTH_VALUE), "WINDOW_NTH_VALUE" },
        { static_cast<uint32_t>(ExpressionType::WINDOW_FILL), "WINDOW_FILL" },
        { static_cast<uint32_t>(ExpressionType::FUNCTION), "FUNCTION" },
        { static_cast<uint32_t>(ExpressionType::BOUND_FUNCTION), "BOUND_FUNCTION" },
        { static_cast<uint32_t>(ExpressionType::CASE_EXPR), "CASE_EXPR" },
        { static_cast<uint32_t>(ExpressionType::OPERATOR_NULLIF), "OPERATOR_NULLIF" },
        { static_cast<uint32_t>(ExpressionType::OPERATOR_COALESCE), "OPERATOR_COALESCE" },
        { static_cast<uint32_t>(ExpressionType::ARRAY_EXTRACT), "ARRAY_EXTRACT" },
        { static_cast<uint32_t>(ExpressionType::ARRAY_SLICE), "ARRAY_SLICE" },
        { static_cast<uint32_t>(ExpressionType::STRUCT_EXTRACT), "STRUCT_EXTRACT" },
        { static_cast<uint32_t>(ExpressionType::ARRAY_CONSTRUCTOR), "ARRAY_CONSTRUCTOR" },
        { static_cast<uint32_t>(ExpressionType::ARROW), "ARROW" },
        { static_cast<uint32_t>(ExpressionType::OPERATOR_TRY), "OPERATOR_TRY" },
        { static_cast<uint32_t>(ExpressionType::SUBQUERY), "SUBQUERY" },
        { static_cast<uint32_t>(ExpressionType::STAR), "STAR" },
        { static_cast<uint32_t>(ExpressionType::TABLE_STAR), "TABLE_STAR" },
        { static_cast<uint32_t>(ExpressionType::PLACEHOLDER), "PLACEHOLDER" },
        { static_cast<uint32_t>(ExpressionType::COLUMN_REF), "COLUMN_REF" },
        { static_cast<uint32_t>(ExpressionType::FUNCTION_REF), "FUNCTION_REF" },
        { static_cast<uint32_t>(ExpressionType::TABLE_REF), "TABLE_REF" },
        { static_cast<uint32_t>(ExpressionType::LAMBDA_REF), "LAMBDA_REF" },
        { static_cast<uint32_t>(ExpressionType::TYPE), "TYPE" },
        { static_cast<uint32_t>(ExpressionType::CAST), "CAST" },
        { static_cast<uint32_t>(ExpressionType::BOUND_REF), "BOUND_REF" },
        { static_cast<uint32_t>(ExpressionType::BOUND_COLUMN_REF), "BOUND_COLUMN_REF" },
        { static_cast<uint32_t>(ExpressionType::BOUND_UNNEST), "BOUND_UNNEST" },
        { static_cast<uint32_t>(ExpressionType::COLLATE), "COLLATE" },
        { static_cast<uint32_t>(ExpressionType::LAMBDA), "LAMBDA" },
        { static_cast<uint32_t>(ExpressionType::POSITIONAL_REFERENCE), "POSITIONAL_REFERENCE" },
        { static_cast<uint32_t>(ExpressionType::BOUND_LAMBDA_REF), "BOUND_LAMBDA_REF" },
        { static_cast<uint32_t>(ExpressionType::BOUND_EXPANDED), "BOUND_EXPANDED" }
    };
    return values;
}

◆ GetExtensionABITypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetExtensionABITypeValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExtensionABIType::UNKNOWN), "UNKNOWN" },
        { static_cast<uint32_t>(ExtensionABIType::CPP), "CPP" },
        { static_cast<uint32_t>(ExtensionABIType::C_STRUCT), "C_STRUCT" },
        { static_cast<uint32_t>(ExtensionABIType::C_STRUCT_UNSTABLE), "C_STRUCT_UNSTABLE" }
    };
    return values;
}

◆ GetExtensionInstallModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetExtensionInstallModeValues ( )

private

                                                                   {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExtensionInstallMode::UNKNOWN), "UNKNOWN" },
        { static_cast<uint32_t>(ExtensionInstallMode::REPOSITORY), "REPOSITORY" },
        { static_cast<uint32_t>(ExtensionInstallMode::CUSTOM_PATH), "CUSTOM_PATH" },
        { static_cast<uint32_t>(ExtensionInstallMode::STATICALLY_LINKED), "STATICALLY_LINKED" },
        { static_cast<uint32_t>(ExtensionInstallMode::NOT_INSTALLED), "NOT_INSTALLED" }
    };
    return values;
}

◆ GetExtensionLoadResultValues()

const StringUtil::EnumStringLiteral * duckdb::GetExtensionLoadResultValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExtensionLoadResult::LOADED_EXTENSION), "LOADED_EXTENSION" },
        { static_cast<uint32_t>(ExtensionLoadResult::EXTENSION_UNKNOWN), "EXTENSION_UNKNOWN" },
        { static_cast<uint32_t>(ExtensionLoadResult::NOT_LOADED), "NOT_LOADED" }
    };
    return values;
}

◆ GetExtensionUpdateResultTagValues()

const StringUtil::EnumStringLiteral * duckdb::GetExtensionUpdateResultTagValues ( )

private

                                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExtensionUpdateResultTag::UNKNOWN), "UNKNOWN" },
        { static_cast<uint32_t>(ExtensionUpdateResultTag::NO_UPDATE_AVAILABLE), "NO_UPDATE_AVAILABLE" },
        { static_cast<uint32_t>(ExtensionUpdateResultTag::NOT_A_REPOSITORY), "NOT_A_REPOSITORY" },
        { static_cast<uint32_t>(ExtensionUpdateResultTag::NOT_INSTALLED), "NOT_INSTALLED" },
        { static_cast<uint32_t>(ExtensionUpdateResultTag::STATICALLY_LOADED), "STATICALLY_LOADED" },
        { static_cast<uint32_t>(ExtensionUpdateResultTag::MISSING_INSTALL_INFO), "MISSING_INSTALL_INFO" },
        { static_cast<uint32_t>(ExtensionUpdateResultTag::REDOWNLOADED), "REDOWNLOADED" },
        { static_cast<uint32_t>(ExtensionUpdateResultTag::UPDATED), "UPDATED" }
    };
    return values;
}

◆ GetExtraDropInfoTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetExtraDropInfoTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExtraDropInfoType::INVALID), "INVALID" },
        { static_cast<uint32_t>(ExtraDropInfoType::SECRET_INFO), "SECRET_INFO" }
    };
    return values;
}

◆ GetExtraPersistentColumnDataTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetExtraPersistentColumnDataTypeValues ( )

private

                                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExtraPersistentColumnDataType::INVALID), "INVALID" },
        { static_cast<uint32_t>(ExtraPersistentColumnDataType::VARIANT), "VARIANT" },
        { static_cast<uint32_t>(ExtraPersistentColumnDataType::GEOMETRY), "GEOMETRY" }
    };
    return values;
}

◆ GetExtraTypeInfoTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetExtraTypeInfoTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ExtraTypeInfoType::INVALID_TYPE_INFO), "INVALID_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::GENERIC_TYPE_INFO), "GENERIC_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::DECIMAL_TYPE_INFO), "DECIMAL_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::STRING_TYPE_INFO), "STRING_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::LIST_TYPE_INFO), "LIST_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::STRUCT_TYPE_INFO), "STRUCT_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::ENUM_TYPE_INFO), "ENUM_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::UNBOUND_TYPE_INFO), "UNBOUND_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO), "AGGREGATE_STATE_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::ARRAY_TYPE_INFO), "ARRAY_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::ANY_TYPE_INFO), "ANY_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::INTEGER_LITERAL_TYPE_INFO), "INTEGER_LITERAL_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::TEMPLATE_TYPE_INFO), "TEMPLATE_TYPE_INFO" },
        { static_cast<uint32_t>(ExtraTypeInfoType::GEO_TYPE_INFO), "GEO_TYPE_INFO" }
    };
    return values;
}

◆ GetFileBufferTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetFileBufferTypeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(FileBufferType::BLOCK), "BLOCK" },
        { static_cast<uint32_t>(FileBufferType::MANAGED_BUFFER), "MANAGED_BUFFER" },
        { static_cast<uint32_t>(FileBufferType::TINY_BUFFER), "TINY_BUFFER" },
        { static_cast<uint32_t>(FileBufferType::EXTERNAL_FILE), "EXTERNAL_FILE" }
    };
    return values;
}

◆ GetFileCompressionTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetFileCompressionTypeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(FileCompressionType::AUTO_DETECT), "AUTO_DETECT" },
        { static_cast<uint32_t>(FileCompressionType::UNCOMPRESSED), "UNCOMPRESSED" },
        { static_cast<uint32_t>(FileCompressionType::GZIP), "GZIP" },
        { static_cast<uint32_t>(FileCompressionType::ZSTD), "ZSTD" }
    };
    return values;
}

◆ GetFileExpandResultValues()

const StringUtil::EnumStringLiteral * duckdb::GetFileExpandResultValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(FileExpandResult::NO_FILES), "NO_FILES" },
        { static_cast<uint32_t>(FileExpandResult::SINGLE_FILE), "SINGLE_FILE" },
        { static_cast<uint32_t>(FileExpandResult::MULTIPLE_FILES), "MULTIPLE_FILES" }
    };
    return values;
}

◆ GetFileGlobOptionsValues()

const StringUtil::EnumStringLiteral * duckdb::GetFileGlobOptionsValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(FileGlobOptions::DISALLOW_EMPTY), "DISALLOW_EMPTY" },
        { static_cast<uint32_t>(FileGlobOptions::ALLOW_EMPTY), "ALLOW_EMPTY" },
        { static_cast<uint32_t>(FileGlobOptions::FALLBACK_GLOB), "FALLBACK_GLOB" }
    };
    return values;
}

◆ GetFileLockTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetFileLockTypeValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(FileLockType::NO_LOCK), "NO_LOCK" },
        { static_cast<uint32_t>(FileLockType::READ_LOCK), "READ_LOCK" },
        { static_cast<uint32_t>(FileLockType::WRITE_LOCK), "WRITE_LOCK" }
    };
    return values;
}

◆ GetFileNameSegmentTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetFileNameSegmentTypeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(FileNameSegmentType::LITERAL), "LITERAL" },
        { static_cast<uint32_t>(FileNameSegmentType::UUID_V4), "UUID_V4" },
        { static_cast<uint32_t>(FileNameSegmentType::UUID_V7), "UUID_V7" },
        { static_cast<uint32_t>(FileNameSegmentType::OFFSET), "OFFSET" }
    };
    return values;
}

◆ GetFilterPropagateResultValues()

const StringUtil::EnumStringLiteral * duckdb::GetFilterPropagateResultValues ( )

private

                                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(FilterPropagateResult::NO_PRUNING_POSSIBLE), "NO_PRUNING_POSSIBLE" },
        { static_cast<uint32_t>(FilterPropagateResult::FILTER_ALWAYS_TRUE), "FILTER_ALWAYS_TRUE" },
        { static_cast<uint32_t>(FilterPropagateResult::FILTER_ALWAYS_FALSE), "FILTER_ALWAYS_FALSE" },
        { static_cast<uint32_t>(FilterPropagateResult::FILTER_TRUE_OR_NULL), "FILTER_TRUE_OR_NULL" },
        { static_cast<uint32_t>(FilterPropagateResult::FILTER_FALSE_OR_NULL), "FILTER_FALSE_OR_NULL" }
    };
    return values;
}

◆ GetForeignKeyTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetForeignKeyTypeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE), "FK_TYPE_PRIMARY_KEY_TABLE" },
        { static_cast<uint32_t>(ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE), "FK_TYPE_FOREIGN_KEY_TABLE" },
        { static_cast<uint32_t>(ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE), "FK_TYPE_SELF_REFERENCE_TABLE" }
    };
    return values;
}

◆ GetFunctionCollationHandlingValues()

const StringUtil::EnumStringLiteral * duckdb::GetFunctionCollationHandlingValues ( )

private

                                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(FunctionCollationHandling::PROPAGATE_COLLATIONS), "PROPAGATE_COLLATIONS" },
        { static_cast<uint32_t>(FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS), "PUSH_COMBINABLE_COLLATIONS" },
        { static_cast<uint32_t>(FunctionCollationHandling::IGNORE_COLLATIONS), "IGNORE_COLLATIONS" }
    };
    return values;
}

◆ GetFunctionErrorsValues()

const StringUtil::EnumStringLiteral * duckdb::GetFunctionErrorsValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(FunctionErrors::CANNOT_ERROR), "CANNOT_ERROR" },
        { static_cast<uint32_t>(FunctionErrors::CAN_THROW_RUNTIME_ERROR), "CAN_THROW_RUNTIME_ERROR" }
    };
    return values;
}

◆ GetFunctionNullHandlingValues()

const StringUtil::EnumStringLiteral * duckdb::GetFunctionNullHandlingValues ( )

private

                                                                   {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(FunctionNullHandling::DEFAULT_NULL_HANDLING), "DEFAULT_NULL_HANDLING" },
        { static_cast<uint32_t>(FunctionNullHandling::SPECIAL_HANDLING), "SPECIAL_HANDLING" }
    };
    return values;
}

◆ GetFunctionStabilityValues()

const StringUtil::EnumStringLiteral * duckdb::GetFunctionStabilityValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(FunctionStability::CONSISTENT), "CONSISTENT" },
        { static_cast<uint32_t>(FunctionStability::VOLATILE), "VOLATILE" },
        { static_cast<uint32_t>(FunctionStability::CONSISTENT_WITHIN_QUERY), "CONSISTENT_WITHIN_QUERY" }
    };
    return values;
}

◆ GetGateStatusValues()

const StringUtil::EnumStringLiteral * duckdb::GetGateStatusValues ( )

private

                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(GateStatus::GATE_NOT_SET), "GATE_NOT_SET" },
        { static_cast<uint32_t>(GateStatus::GATE_SET), "GATE_SET" }
    };
    return values;
}

◆ GetGeometryStorageTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetGeometryStorageTypeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(GeometryStorageType::SPATIAL), "SPATIAL" },
        { static_cast<uint32_t>(GeometryStorageType::WKB), "WKB" },
        { static_cast<uint32_t>(GeometryStorageType::POINT_XY), "POINT_XY" },
        { static_cast<uint32_t>(GeometryStorageType::LINESTRING_XY), "LINESTRING_XY" },
        { static_cast<uint32_t>(GeometryStorageType::POLYGON_XY), "POLYGON_XY" },
        { static_cast<uint32_t>(GeometryStorageType::MULTIPOINT_XY), "MULTIPOINT_XY" },
        { static_cast<uint32_t>(GeometryStorageType::MULTILINESTRING_XY), "MULTILINESTRING_XY" },
        { static_cast<uint32_t>(GeometryStorageType::MULTIPOLYGON_XY), "MULTIPOLYGON_XY" },
        { static_cast<uint32_t>(GeometryStorageType::POINT_XYZ), "POINT_XYZ" },
        { static_cast<uint32_t>(GeometryStorageType::LINESTRING_XYZ), "LINESTRING_XYZ" },
        { static_cast<uint32_t>(GeometryStorageType::POLYGON_XYZ), "POLYGON_XYZ" },
        { static_cast<uint32_t>(GeometryStorageType::MULTIPOINT_XYZ), "MULTIPOINT_XYZ" },
        { static_cast<uint32_t>(GeometryStorageType::MULTILINESTRING_XYZ), "MULTILINESTRING_XYZ" },
        { static_cast<uint32_t>(GeometryStorageType::MULTIPOLYGON_XYZ), "MULTIPOLYGON_XYZ" },
        { static_cast<uint32_t>(GeometryStorageType::POINT_XYM), "POINT_XYM" },
        { static_cast<uint32_t>(GeometryStorageType::LINESTRING_XYM), "LINESTRING_XYM" },
        { static_cast<uint32_t>(GeometryStorageType::POLYGON_XYM), "POLYGON_XYM" },
        { static_cast<uint32_t>(GeometryStorageType::MULTIPOINT_XYM), "MULTIPOINT_XYM" },
        { static_cast<uint32_t>(GeometryStorageType::MULTILINESTRING_XYM), "MULTILINESTRING_XYM" },
        { static_cast<uint32_t>(GeometryStorageType::MULTIPOLYGON_XYM), "MULTIPOLYGON_XYM" },
        { static_cast<uint32_t>(GeometryStorageType::POINT_XYZM), "POINT_XYZM" },
        { static_cast<uint32_t>(GeometryStorageType::LINESTRING_XYZM), "LINESTRING_XYZM" },
        { static_cast<uint32_t>(GeometryStorageType::POLYGON_XYZM), "POLYGON_XYZM" },
        { static_cast<uint32_t>(GeometryStorageType::MULTIPOINT_XYZM), "MULTIPOINT_XYZM" },
        { static_cast<uint32_t>(GeometryStorageType::MULTILINESTRING_XYZM), "MULTILINESTRING_XYZM" },
        { static_cast<uint32_t>(GeometryStorageType::MULTIPOLYGON_XYZM), "MULTIPOLYGON_XYZM" }
    };
    return values;
}

◆ GetGeometryTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetGeometryTypeValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(GeometryType::INVALID), "INVALID" },
        { static_cast<uint32_t>(GeometryType::POINT), "POINT" },
        { static_cast<uint32_t>(GeometryType::LINESTRING), "LINESTRING" },
        { static_cast<uint32_t>(GeometryType::POLYGON), "POLYGON" },
        { static_cast<uint32_t>(GeometryType::MULTIPOINT), "MULTIPOINT" },
        { static_cast<uint32_t>(GeometryType::MULTILINESTRING), "MULTILINESTRING" },
        { static_cast<uint32_t>(GeometryType::MULTIPOLYGON), "MULTIPOLYGON" },
        { static_cast<uint32_t>(GeometryType::GEOMETRYCOLLECTION), "GEOMETRYCOLLECTION" }
    };
    return values;
}

◆ GetHLLStorageTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetHLLStorageTypeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(HLLStorageType::HLL_V1), "HLL_V1" },
        { static_cast<uint32_t>(HLLStorageType::HLL_V2), "HLL_V2" }
    };
    return values;
}

◆ GetHTTPStatusCodeValues()

const StringUtil::EnumStringLiteral * duckdb::GetHTTPStatusCodeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(HTTPStatusCode::INVALID), "INVALID" },
        { static_cast<uint32_t>(HTTPStatusCode::Continue_100), "Continue_100" },
        { static_cast<uint32_t>(HTTPStatusCode::SwitchingProtocol_101), "SwitchingProtocol_101" },
        { static_cast<uint32_t>(HTTPStatusCode::Processing_102), "Processing_102" },
        { static_cast<uint32_t>(HTTPStatusCode::EarlyHints_103), "EarlyHints_103" },
        { static_cast<uint32_t>(HTTPStatusCode::OK_200), "OK_200" },
        { static_cast<uint32_t>(HTTPStatusCode::Created_201), "Created_201" },
        { static_cast<uint32_t>(HTTPStatusCode::Accepted_202), "Accepted_202" },
        { static_cast<uint32_t>(HTTPStatusCode::NonAuthoritativeInformation_203), "NonAuthoritativeInformation_203" },
        { static_cast<uint32_t>(HTTPStatusCode::NoContent_204), "NoContent_204" },
        { static_cast<uint32_t>(HTTPStatusCode::ResetContent_205), "ResetContent_205" },
        { static_cast<uint32_t>(HTTPStatusCode::PartialContent_206), "PartialContent_206" },
        { static_cast<uint32_t>(HTTPStatusCode::MultiStatus_207), "MultiStatus_207" },
        { static_cast<uint32_t>(HTTPStatusCode::AlreadyReported_208), "AlreadyReported_208" },
        { static_cast<uint32_t>(HTTPStatusCode::IMUsed_226), "IMUsed_226" },
        { static_cast<uint32_t>(HTTPStatusCode::MultipleChoices_300), "MultipleChoices_300" },
        { static_cast<uint32_t>(HTTPStatusCode::MovedPermanently_301), "MovedPermanently_301" },
        { static_cast<uint32_t>(HTTPStatusCode::Found_302), "Found_302" },
        { static_cast<uint32_t>(HTTPStatusCode::SeeOther_303), "SeeOther_303" },
        { static_cast<uint32_t>(HTTPStatusCode::NotModified_304), "NotModified_304" },
        { static_cast<uint32_t>(HTTPStatusCode::UseProxy_305), "UseProxy_305" },
        { static_cast<uint32_t>(HTTPStatusCode::unused_306), "unused_306" },
        { static_cast<uint32_t>(HTTPStatusCode::TemporaryRedirect_307), "TemporaryRedirect_307" },
        { static_cast<uint32_t>(HTTPStatusCode::PermanentRedirect_308), "PermanentRedirect_308" },
        { static_cast<uint32_t>(HTTPStatusCode::BadRequest_400), "BadRequest_400" },
        { static_cast<uint32_t>(HTTPStatusCode::Unauthorized_401), "Unauthorized_401" },
        { static_cast<uint32_t>(HTTPStatusCode::PaymentRequired_402), "PaymentRequired_402" },
        { static_cast<uint32_t>(HTTPStatusCode::Forbidden_403), "Forbidden_403" },
        { static_cast<uint32_t>(HTTPStatusCode::NotFound_404), "NotFound_404" },
        { static_cast<uint32_t>(HTTPStatusCode::MethodNotAllowed_405), "MethodNotAllowed_405" },
        { static_cast<uint32_t>(HTTPStatusCode::NotAcceptable_406), "NotAcceptable_406" },
        { static_cast<uint32_t>(HTTPStatusCode::ProxyAuthenticationRequired_407), "ProxyAuthenticationRequired_407" },
        { static_cast<uint32_t>(HTTPStatusCode::RequestTimeout_408), "RequestTimeout_408" },
        { static_cast<uint32_t>(HTTPStatusCode::Conflict_409), "Conflict_409" },
        { static_cast<uint32_t>(HTTPStatusCode::Gone_410), "Gone_410" },
        { static_cast<uint32_t>(HTTPStatusCode::LengthRequired_411), "LengthRequired_411" },
        { static_cast<uint32_t>(HTTPStatusCode::PreconditionFailed_412), "PreconditionFailed_412" },
        { static_cast<uint32_t>(HTTPStatusCode::PayloadTooLarge_413), "PayloadTooLarge_413" },
        { static_cast<uint32_t>(HTTPStatusCode::UriTooLong_414), "UriTooLong_414" },
        { static_cast<uint32_t>(HTTPStatusCode::UnsupportedMediaType_415), "UnsupportedMediaType_415" },
        { static_cast<uint32_t>(HTTPStatusCode::RangeNotSatisfiable_416), "RangeNotSatisfiable_416" },
        { static_cast<uint32_t>(HTTPStatusCode::ExpectationFailed_417), "ExpectationFailed_417" },
        { static_cast<uint32_t>(HTTPStatusCode::ImATeapot_418), "ImATeapot_418" },
        { static_cast<uint32_t>(HTTPStatusCode::MisdirectedRequest_421), "MisdirectedRequest_421" },
        { static_cast<uint32_t>(HTTPStatusCode::UnprocessableContent_422), "UnprocessableContent_422" },
        { static_cast<uint32_t>(HTTPStatusCode::Locked_423), "Locked_423" },
        { static_cast<uint32_t>(HTTPStatusCode::FailedDependency_424), "FailedDependency_424" },
        { static_cast<uint32_t>(HTTPStatusCode::TooEarly_425), "TooEarly_425" },
        { static_cast<uint32_t>(HTTPStatusCode::UpgradeRequired_426), "UpgradeRequired_426" },
        { static_cast<uint32_t>(HTTPStatusCode::PreconditionRequired_428), "PreconditionRequired_428" },
        { static_cast<uint32_t>(HTTPStatusCode::TooManyRequests_429), "TooManyRequests_429" },
        { static_cast<uint32_t>(HTTPStatusCode::RequestHeaderFieldsTooLarge_431), "RequestHeaderFieldsTooLarge_431" },
        { static_cast<uint32_t>(HTTPStatusCode::UnavailableForLegalReasons_451), "UnavailableForLegalReasons_451" },
        { static_cast<uint32_t>(HTTPStatusCode::InternalServerError_500), "InternalServerError_500" },
        { static_cast<uint32_t>(HTTPStatusCode::NotImplemented_501), "NotImplemented_501" },
        { static_cast<uint32_t>(HTTPStatusCode::BadGateway_502), "BadGateway_502" },
        { static_cast<uint32_t>(HTTPStatusCode::ServiceUnavailable_503), "ServiceUnavailable_503" },
        { static_cast<uint32_t>(HTTPStatusCode::GatewayTimeout_504), "GatewayTimeout_504" },
        { static_cast<uint32_t>(HTTPStatusCode::HttpVersionNotSupported_505), "HttpVersionNotSupported_505" },
        { static_cast<uint32_t>(HTTPStatusCode::VariantAlsoNegotiates_506), "VariantAlsoNegotiates_506" },
        { static_cast<uint32_t>(HTTPStatusCode::InsufficientStorage_507), "InsufficientStorage_507" },
        { static_cast<uint32_t>(HTTPStatusCode::LoopDetected_508), "LoopDetected_508" },
        { static_cast<uint32_t>(HTTPStatusCode::NotExtended_510), "NotExtended_510" },
        { static_cast<uint32_t>(HTTPStatusCode::NetworkAuthenticationRequired_511), "NetworkAuthenticationRequired_511" }
    };
    return values;
}

◆ GetIndexAppendModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetIndexAppendModeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(IndexAppendMode::DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(IndexAppendMode::IGNORE_DUPLICATES), "IGNORE_DUPLICATES" },
        { static_cast<uint32_t>(IndexAppendMode::INSERT_DUPLICATES), "INSERT_DUPLICATES" }
    };
    return values;
}

◆ GetIndexBindStateValues()

const StringUtil::EnumStringLiteral * duckdb::GetIndexBindStateValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(IndexBindState::UNBOUND), "UNBOUND" },
        { static_cast<uint32_t>(IndexBindState::BINDING), "BINDING" },
        { static_cast<uint32_t>(IndexBindState::BOUND), "BOUND" }
    };
    return values;
}

◆ GetIndexConstraintTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetIndexConstraintTypeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(IndexConstraintType::NONE), "NONE" },
        { static_cast<uint32_t>(IndexConstraintType::UNIQUE), "UNIQUE" },
        { static_cast<uint32_t>(IndexConstraintType::PRIMARY), "PRIMARY" },
        { static_cast<uint32_t>(IndexConstraintType::FOREIGN), "FOREIGN" }
    };
    return values;
}

◆ GetInsertColumnOrderValues()

const StringUtil::EnumStringLiteral * duckdb::GetInsertColumnOrderValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(InsertColumnOrder::INSERT_BY_POSITION), "INSERT_BY_POSITION" },
        { static_cast<uint32_t>(InsertColumnOrder::INSERT_BY_NAME), "INSERT_BY_NAME" }
    };
    return values;
}

◆ GetInterruptModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetInterruptModeValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(InterruptMode::NO_INTERRUPTS), "NO_INTERRUPTS" },
        { static_cast<uint32_t>(InterruptMode::TASK), "TASK" },
        { static_cast<uint32_t>(InterruptMode::BLOCKING), "BLOCKING" }
    };
    return values;
}

◆ GetJoinRefTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetJoinRefTypeValues ( )

private

                                                          {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(JoinRefType::REGULAR), "REGULAR" },
        { static_cast<uint32_t>(JoinRefType::NATURAL), "NATURAL" },
        { static_cast<uint32_t>(JoinRefType::CROSS), "CROSS" },
        { static_cast<uint32_t>(JoinRefType::POSITIONAL), "POSITIONAL" },
        { static_cast<uint32_t>(JoinRefType::ASOF), "ASOF" },
        { static_cast<uint32_t>(JoinRefType::DEPENDENT), "DEPENDENT" }
    };
    return values;
}

◆ GetJoinTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetJoinTypeValues ( )

private

                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(JoinType::INVALID), "INVALID" },
        { static_cast<uint32_t>(JoinType::LEFT), "LEFT" },
        { static_cast<uint32_t>(JoinType::RIGHT), "RIGHT" },
        { static_cast<uint32_t>(JoinType::INNER), "INNER" },
        { static_cast<uint32_t>(JoinType::OUTER), "FULL" },
        { static_cast<uint32_t>(JoinType::SEMI), "SEMI" },
        { static_cast<uint32_t>(JoinType::ANTI), "ANTI" },
        { static_cast<uint32_t>(JoinType::MARK), "MARK" },
        { static_cast<uint32_t>(JoinType::SINGLE), "SINGLE" },
        { static_cast<uint32_t>(JoinType::RIGHT_SEMI), "RIGHT_SEMI" },
        { static_cast<uint32_t>(JoinType::RIGHT_ANTI), "RIGHT_ANTI" }
    };
    return values;
}

◆ GetKeywordCategoryValues()

const StringUtil::EnumStringLiteral * duckdb::GetKeywordCategoryValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(KeywordCategory::KEYWORD_RESERVED), "KEYWORD_RESERVED" },
        { static_cast<uint32_t>(KeywordCategory::KEYWORD_UNRESERVED), "KEYWORD_UNRESERVED" },
        { static_cast<uint32_t>(KeywordCategory::KEYWORD_TYPE_FUNC), "KEYWORD_TYPE_FUNC" },
        { static_cast<uint32_t>(KeywordCategory::KEYWORD_COL_NAME), "KEYWORD_COL_NAME" },
        { static_cast<uint32_t>(KeywordCategory::KEYWORD_NONE), "KEYWORD_NONE" }
    };
    return values;
}

◆ GetLambdaSyntaxValues()

const StringUtil::EnumStringLiteral * duckdb::GetLambdaSyntaxValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(LambdaSyntax::DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(LambdaSyntax::ENABLE_SINGLE_ARROW), "ENABLE_SINGLE_ARROW" },
        { static_cast<uint32_t>(LambdaSyntax::DISABLE_SINGLE_ARROW), "DISABLE_SINGLE_ARROW" }
    };
    return values;
}

◆ GetLambdaSyntaxTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetLambdaSyntaxTypeValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(LambdaSyntaxType::SINGLE_ARROW_STORAGE), "SINGLE_ARROW_STORAGE" },
        { static_cast<uint32_t>(LambdaSyntaxType::SINGLE_ARROW), "SINGLE_ARROW" },
        { static_cast<uint32_t>(LambdaSyntaxType::LAMBDA_KEYWORD), "LAMBDA_KEYWORD" }
    };
    return values;
}

◆ GetLimitNodeTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetLimitNodeTypeValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(LimitNodeType::UNSET), "UNSET" },
        { static_cast<uint32_t>(LimitNodeType::CONSTANT_VALUE), "CONSTANT_VALUE" },
        { static_cast<uint32_t>(LimitNodeType::CONSTANT_PERCENTAGE), "CONSTANT_PERCENTAGE" },
        { static_cast<uint32_t>(LimitNodeType::EXPRESSION_VALUE), "EXPRESSION_VALUE" },
        { static_cast<uint32_t>(LimitNodeType::EXPRESSION_PERCENTAGE), "EXPRESSION_PERCENTAGE" }
    };
    return values;
}

◆ GetLoadTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetLoadTypeValues ( )

private

                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(LoadType::LOAD), "LOAD" },
        { static_cast<uint32_t>(LoadType::INSTALL), "INSTALL" },
        { static_cast<uint32_t>(LoadType::FORCE_INSTALL), "FORCE_INSTALL" }
    };
    return values;
}

◆ GetLogContextScopeValues()

const StringUtil::EnumStringLiteral * duckdb::GetLogContextScopeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(LogContextScope::DATABASE), "DATABASE" },
        { static_cast<uint32_t>(LogContextScope::CONNECTION), "CONNECTION" },
        { static_cast<uint32_t>(LogContextScope::THREAD), "THREAD" }
    };
    return values;
}

◆ GetLogLevelValues()

const StringUtil::EnumStringLiteral * duckdb::GetLogLevelValues ( )

private

                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(LogLevel::LOG_TRACE), "TRACE" },
        { static_cast<uint32_t>(LogLevel::LOG_DEBUG), "DEBUG" },
        { static_cast<uint32_t>(LogLevel::LOG_INFO), "INFO" },
        { static_cast<uint32_t>(LogLevel::LOG_WARNING), "WARNING" },
        { static_cast<uint32_t>(LogLevel::LOG_ERROR), "ERROR" },
        { static_cast<uint32_t>(LogLevel::LOG_FATAL), "FATAL" }
    };
    return values;
}

◆ GetLogModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetLogModeValues ( )

private

                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(LogMode::LEVEL_ONLY), "LEVEL_ONLY" },
        { static_cast<uint32_t>(LogMode::DISABLE_SELECTED), "DISABLE_SELECTED" },
        { static_cast<uint32_t>(LogMode::ENABLE_SELECTED), "ENABLE_SELECTED" }
    };
    return values;
}

◆ GetLoggingTargetTableValues()

const StringUtil::EnumStringLiteral * duckdb::GetLoggingTargetTableValues ( )

private

                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(LoggingTargetTable::ALL_LOGS), "ALL_LOGS" },
        { static_cast<uint32_t>(LoggingTargetTable::LOG_ENTRIES), "LOG_ENTRIES" },
        { static_cast<uint32_t>(LoggingTargetTable::LOG_CONTEXTS), "LOG_CONTEXTS" }
    };
    return values;
}

◆ GetLogicalOperatorTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetLogicalOperatorTypeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_INVALID), "LOGICAL_INVALID" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_PROJECTION), "LOGICAL_PROJECTION" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_FILTER), "LOGICAL_FILTER" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY), "LOGICAL_AGGREGATE_AND_GROUP_BY" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_WINDOW), "LOGICAL_WINDOW" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_UNNEST), "LOGICAL_UNNEST" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_LIMIT), "LOGICAL_LIMIT" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_ORDER_BY), "LOGICAL_ORDER_BY" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_TOP_N), "LOGICAL_TOP_N" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_COPY_TO_FILE), "LOGICAL_COPY_TO_FILE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DISTINCT), "LOGICAL_DISTINCT" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_SAMPLE), "LOGICAL_SAMPLE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_PIVOT), "LOGICAL_PIVOT" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_COPY_DATABASE), "LOGICAL_COPY_DATABASE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_GET), "LOGICAL_GET" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CHUNK_GET), "LOGICAL_CHUNK_GET" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DELIM_GET), "LOGICAL_DELIM_GET" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXPRESSION_GET), "LOGICAL_EXPRESSION_GET" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DUMMY_SCAN), "LOGICAL_DUMMY_SCAN" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EMPTY_RESULT), "LOGICAL_EMPTY_RESULT" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CTE_REF), "LOGICAL_CTE_REF" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_JOIN), "LOGICAL_JOIN" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DELIM_JOIN), "LOGICAL_DELIM_JOIN" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_COMPARISON_JOIN), "LOGICAL_COMPARISON_JOIN" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_ANY_JOIN), "LOGICAL_ANY_JOIN" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CROSS_PRODUCT), "LOGICAL_CROSS_PRODUCT" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_POSITIONAL_JOIN), "LOGICAL_POSITIONAL_JOIN" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_ASOF_JOIN), "LOGICAL_ASOF_JOIN" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DEPENDENT_JOIN), "LOGICAL_DEPENDENT_JOIN" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_UNION), "LOGICAL_UNION" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXCEPT), "LOGICAL_EXCEPT" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_INTERSECT), "LOGICAL_INTERSECT" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), "LOGICAL_RECURSIVE_CTE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_MATERIALIZED_CTE), "LOGICAL_MATERIALIZED_CTE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_INSERT), "LOGICAL_INSERT" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DELETE), "LOGICAL_DELETE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_UPDATE), "LOGICAL_UPDATE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_MERGE_INTO), "LOGICAL_MERGE_INTO" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_ALTER), "LOGICAL_ALTER" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_TABLE), "LOGICAL_CREATE_TABLE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_INDEX), "LOGICAL_CREATE_INDEX" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_SEQUENCE), "LOGICAL_CREATE_SEQUENCE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_VIEW), "LOGICAL_CREATE_VIEW" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_SCHEMA), "LOGICAL_CREATE_SCHEMA" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_MACRO), "LOGICAL_CREATE_MACRO" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DROP), "LOGICAL_DROP" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_PRAGMA), "LOGICAL_PRAGMA" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_TRANSACTION), "LOGICAL_TRANSACTION" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_TYPE), "LOGICAL_CREATE_TYPE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_ATTACH), "LOGICAL_ATTACH" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_DETACH), "LOGICAL_DETACH" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXPLAIN), "LOGICAL_EXPLAIN" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_PREPARE), "LOGICAL_PREPARE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXECUTE), "LOGICAL_EXECUTE" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXPORT), "LOGICAL_EXPORT" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_VACUUM), "LOGICAL_VACUUM" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_SET), "LOGICAL_SET" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_LOAD), "LOGICAL_LOAD" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_RESET), "LOGICAL_RESET" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_UPDATE_EXTENSIONS), "LOGICAL_UPDATE_EXTENSIONS" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_CREATE_SECRET), "LOGICAL_CREATE_SECRET" },
        { static_cast<uint32_t>(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR), "LOGICAL_EXTENSION_OPERATOR" }
    };
    return values;
}

◆ GetLogicalTypeIdValues()

const StringUtil::EnumStringLiteral * duckdb::GetLogicalTypeIdValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(LogicalTypeId::INVALID), "INVALID" },
        { static_cast<uint32_t>(LogicalTypeId::SQLNULL), "NULL" },
        { static_cast<uint32_t>(LogicalTypeId::UNKNOWN), "UNKNOWN" },
        { static_cast<uint32_t>(LogicalTypeId::ANY), "ANY" },
        { static_cast<uint32_t>(LogicalTypeId::UNBOUND), "UNBOUND" },
        { static_cast<uint32_t>(LogicalTypeId::TEMPLATE), "TEMPLATE" },
        { static_cast<uint32_t>(LogicalTypeId::TYPE), "TYPE" },
        { static_cast<uint32_t>(LogicalTypeId::BOOLEAN), "BOOLEAN" },
        { static_cast<uint32_t>(LogicalTypeId::TINYINT), "TINYINT" },
        { static_cast<uint32_t>(LogicalTypeId::SMALLINT), "SMALLINT" },
        { static_cast<uint32_t>(LogicalTypeId::INTEGER), "INTEGER" },
        { static_cast<uint32_t>(LogicalTypeId::BIGINT), "BIGINT" },
        { static_cast<uint32_t>(LogicalTypeId::DATE), "DATE" },
        { static_cast<uint32_t>(LogicalTypeId::TIME), "TIME" },
        { static_cast<uint32_t>(LogicalTypeId::TIMESTAMP_SEC), "TIMESTAMP_S" },
        { static_cast<uint32_t>(LogicalTypeId::TIMESTAMP_MS), "TIMESTAMP_MS" },
        { static_cast<uint32_t>(LogicalTypeId::TIMESTAMP), "TIMESTAMP" },
        { static_cast<uint32_t>(LogicalTypeId::TIMESTAMP_NS), "TIMESTAMP_NS" },
        { static_cast<uint32_t>(LogicalTypeId::DECIMAL), "DECIMAL" },
        { static_cast<uint32_t>(LogicalTypeId::FLOAT), "FLOAT" },
        { static_cast<uint32_t>(LogicalTypeId::DOUBLE), "DOUBLE" },
        { static_cast<uint32_t>(LogicalTypeId::CHAR), "CHAR" },
        { static_cast<uint32_t>(LogicalTypeId::VARCHAR), "VARCHAR" },
        { static_cast<uint32_t>(LogicalTypeId::BLOB), "BLOB" },
        { static_cast<uint32_t>(LogicalTypeId::INTERVAL), "INTERVAL" },
        { static_cast<uint32_t>(LogicalTypeId::UTINYINT), "UTINYINT" },
        { static_cast<uint32_t>(LogicalTypeId::USMALLINT), "USMALLINT" },
        { static_cast<uint32_t>(LogicalTypeId::UINTEGER), "UINTEGER" },
        { static_cast<uint32_t>(LogicalTypeId::UBIGINT), "UBIGINT" },
        { static_cast<uint32_t>(LogicalTypeId::TIMESTAMP_TZ), "TIMESTAMP WITH TIME ZONE" },
        { static_cast<uint32_t>(LogicalTypeId::TIME_TZ), "TIME WITH TIME ZONE" },
        { static_cast<uint32_t>(LogicalTypeId::TIME_NS), "TIME_NS" },
        { static_cast<uint32_t>(LogicalTypeId::BIT), "BIT" },
        { static_cast<uint32_t>(LogicalTypeId::STRING_LITERAL), "STRING_LITERAL" },
        { static_cast<uint32_t>(LogicalTypeId::INTEGER_LITERAL), "INTEGER_LITERAL" },
        { static_cast<uint32_t>(LogicalTypeId::BIGNUM), "BIGNUM" },
        { static_cast<uint32_t>(LogicalTypeId::UHUGEINT), "UHUGEINT" },
        { static_cast<uint32_t>(LogicalTypeId::HUGEINT), "HUGEINT" },
        { static_cast<uint32_t>(LogicalTypeId::POINTER), "POINTER" },
        { static_cast<uint32_t>(LogicalTypeId::VALIDITY), "VALIDITY" },
        { static_cast<uint32_t>(LogicalTypeId::UUID), "UUID" },
        { static_cast<uint32_t>(LogicalTypeId::GEOMETRY), "GEOMETRY" },
        { static_cast<uint32_t>(LogicalTypeId::STRUCT), "STRUCT" },
        { static_cast<uint32_t>(LogicalTypeId::LIST), "LIST" },
        { static_cast<uint32_t>(LogicalTypeId::MAP), "MAP" },
        { static_cast<uint32_t>(LogicalTypeId::TABLE), "TABLE" },
        { static_cast<uint32_t>(LogicalTypeId::ENUM), "ENUM" },
        { static_cast<uint32_t>(LogicalTypeId::AGGREGATE_STATE), "AGGREGATE_STATE" },
        { static_cast<uint32_t>(LogicalTypeId::LAMBDA), "LAMBDA" },
        { static_cast<uint32_t>(LogicalTypeId::UNION), "UNION" },
        { static_cast<uint32_t>(LogicalTypeId::ARRAY), "ARRAY" },
        { static_cast<uint32_t>(LogicalTypeId::VARIANT), "VARIANT" }
    };
    return values;
}

◆ GetLookupResultTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetLookupResultTypeValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(LookupResultType::LOOKUP_MISS), "LOOKUP_MISS" },
        { static_cast<uint32_t>(LookupResultType::LOOKUP_HIT), "LOOKUP_HIT" },
        { static_cast<uint32_t>(LookupResultType::LOOKUP_NULL), "LOOKUP_NULL" }
    };
    return values;
}

◆ GetMacroTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetMacroTypeValues ( )

private

                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(MacroType::VOID_MACRO), "VOID_MACRO" },
        { static_cast<uint32_t>(MacroType::TABLE_MACRO), "TABLE_MACRO" },
        { static_cast<uint32_t>(MacroType::SCALAR_MACRO), "SCALAR_MACRO" }
    };
    return values;
}

◆ GetMapInvalidReasonValues()

const StringUtil::EnumStringLiteral * duckdb::GetMapInvalidReasonValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(MapInvalidReason::VALID), "VALID" },
        { static_cast<uint32_t>(MapInvalidReason::NULL_KEY), "NULL_KEY" },
        { static_cast<uint32_t>(MapInvalidReason::DUPLICATE_KEY), "DUPLICATE_KEY" },
        { static_cast<uint32_t>(MapInvalidReason::NOT_ALIGNED), "NOT_ALIGNED" },
        { static_cast<uint32_t>(MapInvalidReason::INVALID_PARAMS), "INVALID_PARAMS" }
    };
    return values;
}

◆ GetMemoryTagValues()

const StringUtil::EnumStringLiteral * duckdb::GetMemoryTagValues ( )

private

                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(MemoryTag::BASE_TABLE), "BASE_TABLE" },
        { static_cast<uint32_t>(MemoryTag::HASH_TABLE), "HASH_TABLE" },
        { static_cast<uint32_t>(MemoryTag::PARQUET_READER), "PARQUET_READER" },
        { static_cast<uint32_t>(MemoryTag::CSV_READER), "CSV_READER" },
        { static_cast<uint32_t>(MemoryTag::ORDER_BY), "ORDER_BY" },
        { static_cast<uint32_t>(MemoryTag::ART_INDEX), "ART_INDEX" },
        { static_cast<uint32_t>(MemoryTag::COLUMN_DATA), "COLUMN_DATA" },
        { static_cast<uint32_t>(MemoryTag::METADATA), "METADATA" },
        { static_cast<uint32_t>(MemoryTag::OVERFLOW_STRINGS), "OVERFLOW_STRINGS" },
        { static_cast<uint32_t>(MemoryTag::IN_MEMORY_TABLE), "IN_MEMORY_TABLE" },
        { static_cast<uint32_t>(MemoryTag::ALLOCATOR), "ALLOCATOR" },
        { static_cast<uint32_t>(MemoryTag::EXTENSION), "EXTENSION" },
        { static_cast<uint32_t>(MemoryTag::TRANSACTION), "TRANSACTION" },
        { static_cast<uint32_t>(MemoryTag::EXTERNAL_FILE_CACHE), "EXTERNAL_FILE_CACHE" },
        { static_cast<uint32_t>(MemoryTag::WINDOW), "WINDOW" },
        { static_cast<uint32_t>(MemoryTag::OBJECT_CACHE), "OBJECT_CACHE" },
        { static_cast<uint32_t>(MemoryTag::UNKNOWN), "UNKNOWN" }
    };
    return values;
}

◆ GetMergeActionConditionValues()

const StringUtil::EnumStringLiteral * duckdb::GetMergeActionConditionValues ( )

private

                                                                   {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(MergeActionCondition::WHEN_MATCHED), "WHEN_MATCHED" },
        { static_cast<uint32_t>(MergeActionCondition::WHEN_NOT_MATCHED_BY_SOURCE), "WHEN_NOT_MATCHED_BY_SOURCE" },
        { static_cast<uint32_t>(MergeActionCondition::WHEN_NOT_MATCHED_BY_TARGET), "WHEN_NOT_MATCHED_BY_TARGET" }
    };
    return values;
}

◆ GetMergeActionTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetMergeActionTypeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(MergeActionType::MERGE_UPDATE), "MERGE_UPDATE" },
        { static_cast<uint32_t>(MergeActionType::MERGE_DELETE), "MERGE_DELETE" },
        { static_cast<uint32_t>(MergeActionType::MERGE_INSERT), "MERGE_INSERT" },
        { static_cast<uint32_t>(MergeActionType::MERGE_DO_NOTHING), "MERGE_DO_NOTHING" },
        { static_cast<uint32_t>(MergeActionType::MERGE_ERROR), "MERGE_ERROR" }
    };
    return values;
}

◆ GetMetaPipelineTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetMetaPipelineTypeValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(MetaPipelineType::REGULAR), "REGULAR" },
        { static_cast<uint32_t>(MetaPipelineType::JOIN_BUILD), "JOIN_BUILD" }
    };
    return values;
}

◆ GetMetricGroupValues()

const StringUtil::EnumStringLiteral * duckdb::GetMetricGroupValues ( )

private

                                                          {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(MetricGroup::ALL), "ALL" },
        { static_cast<uint32_t>(MetricGroup::CORE), "CORE" },
        { static_cast<uint32_t>(MetricGroup::DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(MetricGroup::EXECUTION), "EXECUTION" },
        { static_cast<uint32_t>(MetricGroup::FILE), "FILE" },
        { static_cast<uint32_t>(MetricGroup::OPERATOR), "OPERATOR" },
        { static_cast<uint32_t>(MetricGroup::OPTIMIZER), "OPTIMIZER" },
        { static_cast<uint32_t>(MetricGroup::PHASE_TIMING), "PHASE_TIMING" },
        { static_cast<uint32_t>(MetricGroup::INVALID), "INVALID" }
    };
    return values;
}

◆ GetMetricTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetMetricTypeValues ( )

private

                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(MetricType::CPU_TIME), "CPU_TIME" },
        { static_cast<uint32_t>(MetricType::CUMULATIVE_CARDINALITY), "CUMULATIVE_CARDINALITY" },
        { static_cast<uint32_t>(MetricType::CUMULATIVE_ROWS_SCANNED), "CUMULATIVE_ROWS_SCANNED" },
        { static_cast<uint32_t>(MetricType::EXTRA_INFO), "EXTRA_INFO" },
        { static_cast<uint32_t>(MetricType::LATENCY), "LATENCY" },
        { static_cast<uint32_t>(MetricType::QUERY_NAME), "QUERY_NAME" },
        { static_cast<uint32_t>(MetricType::RESULT_SET_SIZE), "RESULT_SET_SIZE" },
        { static_cast<uint32_t>(MetricType::ROWS_RETURNED), "ROWS_RETURNED" },
        { static_cast<uint32_t>(MetricType::BLOCKED_THREAD_TIME), "BLOCKED_THREAD_TIME" },
        { static_cast<uint32_t>(MetricType::SYSTEM_PEAK_BUFFER_MEMORY), "SYSTEM_PEAK_BUFFER_MEMORY" },
        { static_cast<uint32_t>(MetricType::SYSTEM_PEAK_TEMP_DIR_SIZE), "SYSTEM_PEAK_TEMP_DIR_SIZE" },
        { static_cast<uint32_t>(MetricType::TOTAL_MEMORY_ALLOCATED), "TOTAL_MEMORY_ALLOCATED" },
        { static_cast<uint32_t>(MetricType::ATTACH_LOAD_STORAGE_LATENCY), "ATTACH_LOAD_STORAGE_LATENCY" },
        { static_cast<uint32_t>(MetricType::ATTACH_REPLAY_WAL_LATENCY), "ATTACH_REPLAY_WAL_LATENCY" },
        { static_cast<uint32_t>(MetricType::CHECKPOINT_LATENCY), "CHECKPOINT_LATENCY" },
        { static_cast<uint32_t>(MetricType::COMMIT_LOCAL_STORAGE_LATENCY), "COMMIT_LOCAL_STORAGE_LATENCY" },
        { static_cast<uint32_t>(MetricType::TOTAL_BYTES_READ), "TOTAL_BYTES_READ" },
        { static_cast<uint32_t>(MetricType::TOTAL_BYTES_WRITTEN), "TOTAL_BYTES_WRITTEN" },
        { static_cast<uint32_t>(MetricType::WAITING_TO_ATTACH_LATENCY), "WAITING_TO_ATTACH_LATENCY" },
        { static_cast<uint32_t>(MetricType::WAL_REPLAY_ENTRY_COUNT), "WAL_REPLAY_ENTRY_COUNT" },
        { static_cast<uint32_t>(MetricType::WRITE_TO_WAL_LATENCY), "WRITE_TO_WAL_LATENCY" },
        { static_cast<uint32_t>(MetricType::OPERATOR_CARDINALITY), "OPERATOR_CARDINALITY" },
        { static_cast<uint32_t>(MetricType::OPERATOR_NAME), "OPERATOR_NAME" },
        { static_cast<uint32_t>(MetricType::OPERATOR_ROWS_SCANNED), "OPERATOR_ROWS_SCANNED" },
        { static_cast<uint32_t>(MetricType::OPERATOR_TIMING), "OPERATOR_TIMING" },
        { static_cast<uint32_t>(MetricType::OPERATOR_TYPE), "OPERATOR_TYPE" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_EXPRESSION_REWRITER), "OPTIMIZER_EXPRESSION_REWRITER" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_FILTER_PULLUP), "OPTIMIZER_FILTER_PULLUP" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_FILTER_PUSHDOWN), "OPTIMIZER_FILTER_PUSHDOWN" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_EMPTY_RESULT_PULLUP), "OPTIMIZER_EMPTY_RESULT_PULLUP" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_CTE_FILTER_PUSHER), "OPTIMIZER_CTE_FILTER_PUSHER" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_REGEX_RANGE), "OPTIMIZER_REGEX_RANGE" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_IN_CLAUSE), "OPTIMIZER_IN_CLAUSE" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_JOIN_ORDER), "OPTIMIZER_JOIN_ORDER" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_DELIMINATOR), "OPTIMIZER_DELIMINATOR" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_UNNEST_REWRITER), "OPTIMIZER_UNNEST_REWRITER" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_UNUSED_COLUMNS), "OPTIMIZER_UNUSED_COLUMNS" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_STATISTICS_PROPAGATION), "OPTIMIZER_STATISTICS_PROPAGATION" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_COMMON_SUBEXPRESSIONS), "OPTIMIZER_COMMON_SUBEXPRESSIONS" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_COMMON_AGGREGATE), "OPTIMIZER_COMMON_AGGREGATE" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_COLUMN_LIFETIME), "OPTIMIZER_COLUMN_LIFETIME" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_BUILD_SIDE_PROBE_SIDE), "OPTIMIZER_BUILD_SIDE_PROBE_SIDE" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_LIMIT_PUSHDOWN), "OPTIMIZER_LIMIT_PUSHDOWN" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_TOP_N), "OPTIMIZER_TOP_N" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_COMPRESSED_MATERIALIZATION), "OPTIMIZER_COMPRESSED_MATERIALIZATION" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_DUPLICATE_GROUPS), "OPTIMIZER_DUPLICATE_GROUPS" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_REORDER_FILTER), "OPTIMIZER_REORDER_FILTER" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_SAMPLING_PUSHDOWN), "OPTIMIZER_SAMPLING_PUSHDOWN" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_JOIN_FILTER_PUSHDOWN), "OPTIMIZER_JOIN_FILTER_PUSHDOWN" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_EXTENSION), "OPTIMIZER_EXTENSION" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_MATERIALIZED_CTE), "OPTIMIZER_MATERIALIZED_CTE" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_SUM_REWRITER), "OPTIMIZER_SUM_REWRITER" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_LATE_MATERIALIZATION), "OPTIMIZER_LATE_MATERIALIZATION" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_CTE_INLINING), "OPTIMIZER_CTE_INLINING" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_ROW_GROUP_PRUNER), "OPTIMIZER_ROW_GROUP_PRUNER" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_TOP_N_WINDOW_ELIMINATION), "OPTIMIZER_TOP_N_WINDOW_ELIMINATION" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_COMMON_SUBPLAN), "OPTIMIZER_COMMON_SUBPLAN" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_JOIN_ELIMINATION), "OPTIMIZER_JOIN_ELIMINATION" },
        { static_cast<uint32_t>(MetricType::OPTIMIZER_WINDOW_SELF_JOIN), "OPTIMIZER_WINDOW_SELF_JOIN" },
        { static_cast<uint32_t>(MetricType::ALL_OPTIMIZERS), "ALL_OPTIMIZERS" },
        { static_cast<uint32_t>(MetricType::CUMULATIVE_OPTIMIZER_TIMING), "CUMULATIVE_OPTIMIZER_TIMING" },
        { static_cast<uint32_t>(MetricType::PHYSICAL_PLANNER), "PHYSICAL_PLANNER" },
        { static_cast<uint32_t>(MetricType::PHYSICAL_PLANNER_COLUMN_BINDING), "PHYSICAL_PLANNER_COLUMN_BINDING" },
        { static_cast<uint32_t>(MetricType::PHYSICAL_PLANNER_CREATE_PLAN), "PHYSICAL_PLANNER_CREATE_PLAN" },
        { static_cast<uint32_t>(MetricType::PHYSICAL_PLANNER_RESOLVE_TYPES), "PHYSICAL_PLANNER_RESOLVE_TYPES" },
        { static_cast<uint32_t>(MetricType::PLANNER), "PLANNER" },
        { static_cast<uint32_t>(MetricType::PLANNER_BINDING), "PLANNER_BINDING" }
    };
    return values;
}

◆ GetMultiFileColumnMappingModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetMultiFileColumnMappingModeValues ( )

private

                                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(MultiFileColumnMappingMode::BY_NAME), "BY_NAME" },
        { static_cast<uint32_t>(MultiFileColumnMappingMode::BY_FIELD_ID), "BY_FIELD_ID" }
    };
    return values;
}

◆ GetMultiFileFileStateValues()

const StringUtil::EnumStringLiteral * duckdb::GetMultiFileFileStateValues ( )

private

                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(MultiFileFileState::UNOPENED), "UNOPENED" },
        { static_cast<uint32_t>(MultiFileFileState::OPENING), "OPENING" },
        { static_cast<uint32_t>(MultiFileFileState::OPEN), "OPEN" },
        { static_cast<uint32_t>(MultiFileFileState::SKIPPED), "SKIPPED" },
        { static_cast<uint32_t>(MultiFileFileState::CLOSED), "CLOSED" }
    };
    return values;
}

◆ GetNTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetNTypeValues ( )

private

                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(NType::PREFIX), "PREFIX" },
        { static_cast<uint32_t>(NType::LEAF), "LEAF" },
        { static_cast<uint32_t>(NType::NODE_4), "NODE_4" },
        { static_cast<uint32_t>(NType::NODE_16), "NODE_16" },
        { static_cast<uint32_t>(NType::NODE_48), "NODE_48" },
        { static_cast<uint32_t>(NType::NODE_256), "NODE_256" },
        { static_cast<uint32_t>(NType::LEAF_INLINED), "LEAF_INLINED" },
        { static_cast<uint32_t>(NType::NODE_7_LEAF), "NODE_7_LEAF" },
        { static_cast<uint32_t>(NType::NODE_15_LEAF), "NODE_15_LEAF" },
        { static_cast<uint32_t>(NType::NODE_256_LEAF), "NODE_256_LEAF" }
    };
    return values;
}

◆ GetNewLineIdentifierValues()

const StringUtil::EnumStringLiteral * duckdb::GetNewLineIdentifierValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(NewLineIdentifier::SINGLE_N), "SINGLE_N" },
        { static_cast<uint32_t>(NewLineIdentifier::CARRY_ON), "CARRY_ON" },
        { static_cast<uint32_t>(NewLineIdentifier::NOT_SET), "NOT_SET" },
        { static_cast<uint32_t>(NewLineIdentifier::SINGLE_R), "SINGLE_R" }
    };
    return values;
}

◆ GetOnConflictActionValues()

const StringUtil::EnumStringLiteral * duckdb::GetOnConflictActionValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OnConflictAction::THROW), "THROW" },
        { static_cast<uint32_t>(OnConflictAction::NOTHING), "NOTHING" },
        { static_cast<uint32_t>(OnConflictAction::UPDATE), "UPDATE" },
        { static_cast<uint32_t>(OnConflictAction::REPLACE), "REPLACE" }
    };
    return values;
}

◆ GetOnCreateConflictValues()

const StringUtil::EnumStringLiteral * duckdb::GetOnCreateConflictValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OnCreateConflict::ERROR_ON_CONFLICT), "ERROR_ON_CONFLICT" },
        { static_cast<uint32_t>(OnCreateConflict::IGNORE_ON_CONFLICT), "IGNORE_ON_CONFLICT" },
        { static_cast<uint32_t>(OnCreateConflict::REPLACE_ON_CONFLICT), "REPLACE_ON_CONFLICT" },
        { static_cast<uint32_t>(OnCreateConflict::ALTER_ON_CONFLICT), "ALTER_ON_CONFLICT" }
    };
    return values;
}

◆ GetOnEntryNotFoundValues()

const StringUtil::EnumStringLiteral * duckdb::GetOnEntryNotFoundValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OnEntryNotFound::THROW_EXCEPTION), "THROW_EXCEPTION" },
        { static_cast<uint32_t>(OnEntryNotFound::RETURN_NULL), "RETURN_NULL" }
    };
    return values;
}

◆ GetOperatorCachingModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetOperatorCachingModeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OperatorCachingMode::NONE), "NONE" },
        { static_cast<uint32_t>(OperatorCachingMode::PARTITIONED), "PARTITIONED" },
        { static_cast<uint32_t>(OperatorCachingMode::ORDERED), "ORDERED" },
        { static_cast<uint32_t>(OperatorCachingMode::UNORDERED), "UNORDERED" }
    };
    return values;
}

◆ GetOperatorFinalResultTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetOperatorFinalResultTypeValues ( )

private

                                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OperatorFinalResultType::FINISHED), "FINISHED" },
        { static_cast<uint32_t>(OperatorFinalResultType::BLOCKED), "BLOCKED" }
    };
    return values;
}

◆ GetOperatorFinalizeResultTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetOperatorFinalizeResultTypeValues ( )

private

                                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OperatorFinalizeResultType::HAVE_MORE_OUTPUT), "HAVE_MORE_OUTPUT" },
        { static_cast<uint32_t>(OperatorFinalizeResultType::FINISHED), "FINISHED" }
    };
    return values;
}

◆ GetOperatorResultTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetOperatorResultTypeValues ( )

private

                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OperatorResultType::NEED_MORE_INPUT), "NEED_MORE_INPUT" },
        { static_cast<uint32_t>(OperatorResultType::HAVE_MORE_OUTPUT), "HAVE_MORE_OUTPUT" },
        { static_cast<uint32_t>(OperatorResultType::FINISHED), "FINISHED" },
        { static_cast<uint32_t>(OperatorResultType::BLOCKED), "BLOCKED" }
    };
    return values;
}

◆ GetOptimizerTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetOptimizerTypeValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OptimizerType::INVALID), "INVALID" },
        { static_cast<uint32_t>(OptimizerType::EXPRESSION_REWRITER), "EXPRESSION_REWRITER" },
        { static_cast<uint32_t>(OptimizerType::FILTER_PULLUP), "FILTER_PULLUP" },
        { static_cast<uint32_t>(OptimizerType::FILTER_PUSHDOWN), "FILTER_PUSHDOWN" },
        { static_cast<uint32_t>(OptimizerType::EMPTY_RESULT_PULLUP), "EMPTY_RESULT_PULLUP" },
        { static_cast<uint32_t>(OptimizerType::CTE_FILTER_PUSHER), "CTE_FILTER_PUSHER" },
        { static_cast<uint32_t>(OptimizerType::REGEX_RANGE), "REGEX_RANGE" },
        { static_cast<uint32_t>(OptimizerType::IN_CLAUSE), "IN_CLAUSE" },
        { static_cast<uint32_t>(OptimizerType::JOIN_ORDER), "JOIN_ORDER" },
        { static_cast<uint32_t>(OptimizerType::DELIMINATOR), "DELIMINATOR" },
        { static_cast<uint32_t>(OptimizerType::UNNEST_REWRITER), "UNNEST_REWRITER" },
        { static_cast<uint32_t>(OptimizerType::UNUSED_COLUMNS), "UNUSED_COLUMNS" },
        { static_cast<uint32_t>(OptimizerType::STATISTICS_PROPAGATION), "STATISTICS_PROPAGATION" },
        { static_cast<uint32_t>(OptimizerType::COMMON_SUBEXPRESSIONS), "COMMON_SUBEXPRESSIONS" },
        { static_cast<uint32_t>(OptimizerType::COMMON_AGGREGATE), "COMMON_AGGREGATE" },
        { static_cast<uint32_t>(OptimizerType::COLUMN_LIFETIME), "COLUMN_LIFETIME" },
        { static_cast<uint32_t>(OptimizerType::BUILD_SIDE_PROBE_SIDE), "BUILD_SIDE_PROBE_SIDE" },
        { static_cast<uint32_t>(OptimizerType::LIMIT_PUSHDOWN), "LIMIT_PUSHDOWN" },
        { static_cast<uint32_t>(OptimizerType::TOP_N), "TOP_N" },
        { static_cast<uint32_t>(OptimizerType::COMPRESSED_MATERIALIZATION), "COMPRESSED_MATERIALIZATION" },
        { static_cast<uint32_t>(OptimizerType::DUPLICATE_GROUPS), "DUPLICATE_GROUPS" },
        { static_cast<uint32_t>(OptimizerType::REORDER_FILTER), "REORDER_FILTER" },
        { static_cast<uint32_t>(OptimizerType::SAMPLING_PUSHDOWN), "SAMPLING_PUSHDOWN" },
        { static_cast<uint32_t>(OptimizerType::JOIN_FILTER_PUSHDOWN), "JOIN_FILTER_PUSHDOWN" },
        { static_cast<uint32_t>(OptimizerType::EXTENSION), "EXTENSION" },
        { static_cast<uint32_t>(OptimizerType::MATERIALIZED_CTE), "MATERIALIZED_CTE" },
        { static_cast<uint32_t>(OptimizerType::SUM_REWRITER), "SUM_REWRITER" },
        { static_cast<uint32_t>(OptimizerType::LATE_MATERIALIZATION), "LATE_MATERIALIZATION" },
        { static_cast<uint32_t>(OptimizerType::CTE_INLINING), "CTE_INLINING" },
        { static_cast<uint32_t>(OptimizerType::ROW_GROUP_PRUNER), "ROW_GROUP_PRUNER" },
        { static_cast<uint32_t>(OptimizerType::TOP_N_WINDOW_ELIMINATION), "TOP_N_WINDOW_ELIMINATION" },
        { static_cast<uint32_t>(OptimizerType::COMMON_SUBPLAN), "COMMON_SUBPLAN" },
        { static_cast<uint32_t>(OptimizerType::JOIN_ELIMINATION), "JOIN_ELIMINATION" },
        { static_cast<uint32_t>(OptimizerType::WINDOW_SELF_JOIN), "WINDOW_SELF_JOIN" }
    };
    return values;
}

◆ GetOrderByColumnTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetOrderByColumnTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OrderByColumnType::NUMERIC), "NUMERIC" },
        { static_cast<uint32_t>(OrderByColumnType::STRING), "STRING" }
    };
    return values;
}

◆ GetOrderByNullTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetOrderByNullTypeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OrderByNullType::INVALID), "INVALID" },
        { static_cast<uint32_t>(OrderByNullType::ORDER_DEFAULT), "ORDER_DEFAULT" },
        { static_cast<uint32_t>(OrderByNullType::ORDER_DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(OrderByNullType::NULLS_FIRST), "NULLS FIRST" },
        { static_cast<uint32_t>(OrderByNullType::NULLS_FIRST), "NULLS_FIRST" },
        { static_cast<uint32_t>(OrderByNullType::NULLS_LAST), "NULLS LAST" },
        { static_cast<uint32_t>(OrderByNullType::NULLS_LAST), "NULLS_LAST" }
    };
    return values;
}

◆ GetOrderByStatisticsValues()

const StringUtil::EnumStringLiteral * duckdb::GetOrderByStatisticsValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OrderByStatistics::MIN), "MIN" },
        { static_cast<uint32_t>(OrderByStatistics::MAX), "MAX" }
    };
    return values;
}

◆ GetOrderPreservationTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetOrderPreservationTypeValues ( )

private

                                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OrderPreservationType::NO_ORDER), "NO_ORDER" },
        { static_cast<uint32_t>(OrderPreservationType::INSERTION_ORDER), "INSERTION_ORDER" },
        { static_cast<uint32_t>(OrderPreservationType::FIXED_ORDER), "FIXED_ORDER" }
    };
    return values;
}

◆ GetOrderTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetOrderTypeValues ( )

private

                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OrderType::INVALID), "INVALID" },
        { static_cast<uint32_t>(OrderType::ORDER_DEFAULT), "ORDER_DEFAULT" },
        { static_cast<uint32_t>(OrderType::ORDER_DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(OrderType::ASCENDING), "ASCENDING" },
        { static_cast<uint32_t>(OrderType::ASCENDING), "ASC" },
        { static_cast<uint32_t>(OrderType::DESCENDING), "DESCENDING" },
        { static_cast<uint32_t>(OrderType::DESCENDING), "DESC" }
    };
    return values;
}

◆ GetOrdinalityTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetOrdinalityTypeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OrdinalityType::WITHOUT_ORDINALITY), "WITHOUT_ORDINALITY" },
        { static_cast<uint32_t>(OrdinalityType::WITH_ORDINALITY), "WITH_ORDINALITY" }
    };
    return values;
}

◆ GetOutputStreamValues()

const StringUtil::EnumStringLiteral * duckdb::GetOutputStreamValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(OutputStream::STREAM_STDOUT), "STREAM_STDOUT" },
        { static_cast<uint32_t>(OutputStream::STREAM_STDERR), "STREAM_STDERR" }
    };
    return values;
}

◆ GetParseInfoTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetParseInfoTypeValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ParseInfoType::ALTER_INFO), "ALTER_INFO" },
        { static_cast<uint32_t>(ParseInfoType::ATTACH_INFO), "ATTACH_INFO" },
        { static_cast<uint32_t>(ParseInfoType::COPY_INFO), "COPY_INFO" },
        { static_cast<uint32_t>(ParseInfoType::CREATE_INFO), "CREATE_INFO" },
        { static_cast<uint32_t>(ParseInfoType::CREATE_SECRET_INFO), "CREATE_SECRET_INFO" },
        { static_cast<uint32_t>(ParseInfoType::DETACH_INFO), "DETACH_INFO" },
        { static_cast<uint32_t>(ParseInfoType::DROP_INFO), "DROP_INFO" },
        { static_cast<uint32_t>(ParseInfoType::BOUND_EXPORT_DATA), "BOUND_EXPORT_DATA" },
        { static_cast<uint32_t>(ParseInfoType::LOAD_INFO), "LOAD_INFO" },
        { static_cast<uint32_t>(ParseInfoType::PRAGMA_INFO), "PRAGMA_INFO" },
        { static_cast<uint32_t>(ParseInfoType::SHOW_SELECT_INFO), "SHOW_SELECT_INFO" },
        { static_cast<uint32_t>(ParseInfoType::TRANSACTION_INFO), "TRANSACTION_INFO" },
        { static_cast<uint32_t>(ParseInfoType::VACUUM_INFO), "VACUUM_INFO" },
        { static_cast<uint32_t>(ParseInfoType::COMMENT_ON_INFO), "COMMENT_ON_INFO" },
        { static_cast<uint32_t>(ParseInfoType::COMMENT_ON_COLUMN_INFO), "COMMENT_ON_COLUMN_INFO" },
        { static_cast<uint32_t>(ParseInfoType::COPY_DATABASE_INFO), "COPY_DATABASE_INFO" },
        { static_cast<uint32_t>(ParseInfoType::UPDATE_EXTENSIONS_INFO), "UPDATE_EXTENSIONS_INFO" }
    };
    return values;
}

◆ GetParserExtensionResultTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetParserExtensionResultTypeValues ( )

private

                                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ParserExtensionResultType::PARSE_SUCCESSFUL), "PARSE_SUCCESSFUL" },
        { static_cast<uint32_t>(ParserExtensionResultType::DISPLAY_ORIGINAL_ERROR), "DISPLAY_ORIGINAL_ERROR" },
        { static_cast<uint32_t>(ParserExtensionResultType::DISPLAY_EXTENSION_ERROR), "DISPLAY_EXTENSION_ERROR" }
    };
    return values;
}

◆ GetPartitionedColumnDataTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetPartitionedColumnDataTypeValues ( )

private

                                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(PartitionedColumnDataType::INVALID), "INVALID" },
        { static_cast<uint32_t>(PartitionedColumnDataType::RADIX), "RADIX" },
        { static_cast<uint32_t>(PartitionedColumnDataType::HIVE), "HIVE" }
    };
    return values;
}

◆ GetPartitionedTupleDataTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetPartitionedTupleDataTypeValues ( )

private

                                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(PartitionedTupleDataType::INVALID), "INVALID" },
        { static_cast<uint32_t>(PartitionedTupleDataType::RADIX), "RADIX" }
    };
    return values;
}

◆ GetPendingExecutionResultValues()

const StringUtil::EnumStringLiteral * duckdb::GetPendingExecutionResultValues ( )

private

                                                                     {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(PendingExecutionResult::RESULT_READY), "RESULT_READY" },
        { static_cast<uint32_t>(PendingExecutionResult::RESULT_NOT_READY), "RESULT_NOT_READY" },
        { static_cast<uint32_t>(PendingExecutionResult::EXECUTION_ERROR), "EXECUTION_ERROR" },
        { static_cast<uint32_t>(PendingExecutionResult::BLOCKED), "BLOCKED" },
        { static_cast<uint32_t>(PendingExecutionResult::NO_TASKS_AVAILABLE), "NO_TASKS_AVAILABLE" },
        { static_cast<uint32_t>(PendingExecutionResult::EXECUTION_FINISHED), "EXECUTION_FINISHED" }
    };
    return values;
}

◆ GetPhysicalOperatorTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetPhysicalOperatorTypeValues ( )

private

                                                                   {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(PhysicalOperatorType::INVALID), "INVALID" },
        { static_cast<uint32_t>(PhysicalOperatorType::ORDER_BY), "ORDER_BY" },
        { static_cast<uint32_t>(PhysicalOperatorType::LIMIT), "LIMIT" },
        { static_cast<uint32_t>(PhysicalOperatorType::STREAMING_LIMIT), "STREAMING_LIMIT" },
        { static_cast<uint32_t>(PhysicalOperatorType::LIMIT_PERCENT), "LIMIT_PERCENT" },
        { static_cast<uint32_t>(PhysicalOperatorType::TOP_N), "TOP_N" },
        { static_cast<uint32_t>(PhysicalOperatorType::WINDOW), "WINDOW" },
        { static_cast<uint32_t>(PhysicalOperatorType::UNNEST), "UNNEST" },
        { static_cast<uint32_t>(PhysicalOperatorType::UNGROUPED_AGGREGATE), "UNGROUPED_AGGREGATE" },
        { static_cast<uint32_t>(PhysicalOperatorType::HASH_GROUP_BY), "HASH_GROUP_BY" },
        { static_cast<uint32_t>(PhysicalOperatorType::PERFECT_HASH_GROUP_BY), "PERFECT_HASH_GROUP_BY" },
        { static_cast<uint32_t>(PhysicalOperatorType::PARTITIONED_AGGREGATE), "PARTITIONED_AGGREGATE" },
        { static_cast<uint32_t>(PhysicalOperatorType::FILTER), "FILTER" },
        { static_cast<uint32_t>(PhysicalOperatorType::PROJECTION), "PROJECTION" },
        { static_cast<uint32_t>(PhysicalOperatorType::COPY_TO_FILE), "COPY_TO_FILE" },
        { static_cast<uint32_t>(PhysicalOperatorType::BATCH_COPY_TO_FILE), "BATCH_COPY_TO_FILE" },
        { static_cast<uint32_t>(PhysicalOperatorType::RESERVOIR_SAMPLE), "RESERVOIR_SAMPLE" },
        { static_cast<uint32_t>(PhysicalOperatorType::STREAMING_SAMPLE), "STREAMING_SAMPLE" },
        { static_cast<uint32_t>(PhysicalOperatorType::STREAMING_WINDOW), "STREAMING_WINDOW" },
        { static_cast<uint32_t>(PhysicalOperatorType::PIVOT), "PIVOT" },
        { static_cast<uint32_t>(PhysicalOperatorType::COPY_DATABASE), "COPY_DATABASE" },
        { static_cast<uint32_t>(PhysicalOperatorType::TABLE_SCAN), "TABLE_SCAN" },
        { static_cast<uint32_t>(PhysicalOperatorType::DUMMY_SCAN), "DUMMY_SCAN" },
        { static_cast<uint32_t>(PhysicalOperatorType::COLUMN_DATA_SCAN), "COLUMN_DATA_SCAN" },
        { static_cast<uint32_t>(PhysicalOperatorType::CHUNK_SCAN), "CHUNK_SCAN" },
        { static_cast<uint32_t>(PhysicalOperatorType::RECURSIVE_CTE_SCAN), "RECURSIVE_CTE_SCAN" },
        { static_cast<uint32_t>(PhysicalOperatorType::RECURSIVE_RECURRING_CTE_SCAN), "RECURSIVE_RECURRING_CTE_SCAN" },
        { static_cast<uint32_t>(PhysicalOperatorType::CTE_SCAN), "CTE_SCAN" },
        { static_cast<uint32_t>(PhysicalOperatorType::DELIM_SCAN), "DELIM_SCAN" },
        { static_cast<uint32_t>(PhysicalOperatorType::EXPRESSION_SCAN), "EXPRESSION_SCAN" },
        { static_cast<uint32_t>(PhysicalOperatorType::POSITIONAL_SCAN), "POSITIONAL_SCAN" },
        { static_cast<uint32_t>(PhysicalOperatorType::BLOCKWISE_NL_JOIN), "BLOCKWISE_NL_JOIN" },
        { static_cast<uint32_t>(PhysicalOperatorType::NESTED_LOOP_JOIN), "NESTED_LOOP_JOIN" },
        { static_cast<uint32_t>(PhysicalOperatorType::HASH_JOIN), "HASH_JOIN" },
        { static_cast<uint32_t>(PhysicalOperatorType::CROSS_PRODUCT), "CROSS_PRODUCT" },
        { static_cast<uint32_t>(PhysicalOperatorType::PIECEWISE_MERGE_JOIN), "PIECEWISE_MERGE_JOIN" },
        { static_cast<uint32_t>(PhysicalOperatorType::IE_JOIN), "IE_JOIN" },
        { static_cast<uint32_t>(PhysicalOperatorType::LEFT_DELIM_JOIN), "LEFT_DELIM_JOIN" },
        { static_cast<uint32_t>(PhysicalOperatorType::RIGHT_DELIM_JOIN), "RIGHT_DELIM_JOIN" },
        { static_cast<uint32_t>(PhysicalOperatorType::POSITIONAL_JOIN), "POSITIONAL_JOIN" },
        { static_cast<uint32_t>(PhysicalOperatorType::ASOF_JOIN), "ASOF_JOIN" },
        { static_cast<uint32_t>(PhysicalOperatorType::UNION), "UNION" },
        { static_cast<uint32_t>(PhysicalOperatorType::RECURSIVE_CTE), "RECURSIVE_CTE" },
        { static_cast<uint32_t>(PhysicalOperatorType::RECURSIVE_KEY_CTE), "RECURSIVE_KEY_CTE" },
        { static_cast<uint32_t>(PhysicalOperatorType::CTE), "CTE" },
        { static_cast<uint32_t>(PhysicalOperatorType::INSERT), "INSERT" },
        { static_cast<uint32_t>(PhysicalOperatorType::BATCH_INSERT), "BATCH_INSERT" },
        { static_cast<uint32_t>(PhysicalOperatorType::DELETE_OPERATOR), "DELETE_OPERATOR" },
        { static_cast<uint32_t>(PhysicalOperatorType::UPDATE), "UPDATE" },
        { static_cast<uint32_t>(PhysicalOperatorType::MERGE_INTO), "MERGE_INTO" },
        { static_cast<uint32_t>(PhysicalOperatorType::CREATE_TABLE), "CREATE_TABLE" },
        { static_cast<uint32_t>(PhysicalOperatorType::CREATE_TABLE_AS), "CREATE_TABLE_AS" },
        { static_cast<uint32_t>(PhysicalOperatorType::BATCH_CREATE_TABLE_AS), "BATCH_CREATE_TABLE_AS" },
        { static_cast<uint32_t>(PhysicalOperatorType::CREATE_INDEX), "CREATE_INDEX" },
        { static_cast<uint32_t>(PhysicalOperatorType::ALTER), "ALTER" },
        { static_cast<uint32_t>(PhysicalOperatorType::CREATE_SEQUENCE), "CREATE_SEQUENCE" },
        { static_cast<uint32_t>(PhysicalOperatorType::CREATE_VIEW), "CREATE_VIEW" },
        { static_cast<uint32_t>(PhysicalOperatorType::CREATE_SCHEMA), "CREATE_SCHEMA" },
        { static_cast<uint32_t>(PhysicalOperatorType::CREATE_MACRO), "CREATE_MACRO" },
        { static_cast<uint32_t>(PhysicalOperatorType::DROP), "DROP" },
        { static_cast<uint32_t>(PhysicalOperatorType::PRAGMA), "PRAGMA" },
        { static_cast<uint32_t>(PhysicalOperatorType::TRANSACTION), "TRANSACTION" },
        { static_cast<uint32_t>(PhysicalOperatorType::CREATE_TYPE), "CREATE_TYPE" },
        { static_cast<uint32_t>(PhysicalOperatorType::ATTACH), "ATTACH" },
        { static_cast<uint32_t>(PhysicalOperatorType::DETACH), "DETACH" },
        { static_cast<uint32_t>(PhysicalOperatorType::EXPLAIN), "EXPLAIN" },
        { static_cast<uint32_t>(PhysicalOperatorType::EXPLAIN_ANALYZE), "EXPLAIN_ANALYZE" },
        { static_cast<uint32_t>(PhysicalOperatorType::EMPTY_RESULT), "EMPTY_RESULT" },
        { static_cast<uint32_t>(PhysicalOperatorType::EXECUTE), "EXECUTE" },
        { static_cast<uint32_t>(PhysicalOperatorType::PREPARE), "PREPARE" },
        { static_cast<uint32_t>(PhysicalOperatorType::VACUUM), "VACUUM" },
        { static_cast<uint32_t>(PhysicalOperatorType::EXPORT), "EXPORT" },
        { static_cast<uint32_t>(PhysicalOperatorType::SET), "SET" },
        { static_cast<uint32_t>(PhysicalOperatorType::SET_VARIABLE), "SET_VARIABLE" },
        { static_cast<uint32_t>(PhysicalOperatorType::LOAD), "LOAD" },
        { static_cast<uint32_t>(PhysicalOperatorType::INOUT_FUNCTION), "INOUT_FUNCTION" },
        { static_cast<uint32_t>(PhysicalOperatorType::RESULT_COLLECTOR), "RESULT_COLLECTOR" },
        { static_cast<uint32_t>(PhysicalOperatorType::RESET), "RESET" },
        { static_cast<uint32_t>(PhysicalOperatorType::EXTENSION), "EXTENSION" },
        { static_cast<uint32_t>(PhysicalOperatorType::VERIFY_VECTOR), "VERIFY_VECTOR" },
        { static_cast<uint32_t>(PhysicalOperatorType::UPDATE_EXTENSIONS), "UPDATE_EXTENSIONS" },
        { static_cast<uint32_t>(PhysicalOperatorType::CREATE_SECRET), "CREATE_SECRET" }
    };
    return values;
}

◆ GetPhysicalTableScanExecutionStrategyValues()

const StringUtil::EnumStringLiteral * duckdb::GetPhysicalTableScanExecutionStrategyValues ( )

private

                                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(PhysicalTableScanExecutionStrategy::DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(PhysicalTableScanExecutionStrategy::TASK_EXECUTOR), "TASK_EXECUTOR" },
        { static_cast<uint32_t>(PhysicalTableScanExecutionStrategy::SYNCHRONOUS), "SYNCHRONOUS" },
        { static_cast<uint32_t>(PhysicalTableScanExecutionStrategy::TASK_EXECUTOR_BUT_FORCE_SYNC_CHECKS), "TASK_EXECUTOR_BUT_FORCE_SYNC_CHECKS" }
    };
    return values;
}

◆ GetPhysicalTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetPhysicalTypeValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(PhysicalType::BOOL), "BOOL" },
        { static_cast<uint32_t>(PhysicalType::UINT8), "UINT8" },
        { static_cast<uint32_t>(PhysicalType::INT8), "INT8" },
        { static_cast<uint32_t>(PhysicalType::UINT16), "UINT16" },
        { static_cast<uint32_t>(PhysicalType::INT16), "INT16" },
        { static_cast<uint32_t>(PhysicalType::UINT32), "UINT32" },
        { static_cast<uint32_t>(PhysicalType::INT32), "INT32" },
        { static_cast<uint32_t>(PhysicalType::UINT64), "UINT64" },
        { static_cast<uint32_t>(PhysicalType::INT64), "INT64" },
        { static_cast<uint32_t>(PhysicalType::FLOAT), "FLOAT" },
        { static_cast<uint32_t>(PhysicalType::DOUBLE), "DOUBLE" },
        { static_cast<uint32_t>(PhysicalType::INTERVAL), "INTERVAL" },
        { static_cast<uint32_t>(PhysicalType::LIST), "LIST" },
        { static_cast<uint32_t>(PhysicalType::STRUCT), "STRUCT" },
        { static_cast<uint32_t>(PhysicalType::ARRAY), "ARRAY" },
        { static_cast<uint32_t>(PhysicalType::VARCHAR), "VARCHAR" },
        { static_cast<uint32_t>(PhysicalType::UINT128), "UINT128" },
        { static_cast<uint32_t>(PhysicalType::INT128), "INT128" },
        { static_cast<uint32_t>(PhysicalType::UNKNOWN), "UNKNOWN" },
        { static_cast<uint32_t>(PhysicalType::BIT), "BIT" },
        { static_cast<uint32_t>(PhysicalType::INVALID), "INVALID" }
    };
    return values;
}

◆ GetPragmaTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetPragmaTypeValues ( )

private

                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(PragmaType::PRAGMA_STATEMENT), "PRAGMA_STATEMENT" },
        { static_cast<uint32_t>(PragmaType::PRAGMA_CALL), "PRAGMA_CALL" }
    };
    return values;
}

◆ GetPreparedParamTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetPreparedParamTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(PreparedParamType::AUTO_INCREMENT), "AUTO_INCREMENT" },
        { static_cast<uint32_t>(PreparedParamType::POSITIONAL), "POSITIONAL" },
        { static_cast<uint32_t>(PreparedParamType::NAMED), "NAMED" },
        { static_cast<uint32_t>(PreparedParamType::INVALID), "INVALID" }
    };
    return values;
}

◆ GetPreparedStatementModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetPreparedStatementModeValues ( )

private

                                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(PreparedStatementMode::PREPARE_ONLY), "PREPARE_ONLY" },
        { static_cast<uint32_t>(PreparedStatementMode::PREPARE_AND_EXECUTE), "PREPARE_AND_EXECUTE" }
    };
    return values;
}

◆ GetPreserveOrderTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetPreserveOrderTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(PreserveOrderType::AUTOMATIC), "AUTOMATIC" },
        { static_cast<uint32_t>(PreserveOrderType::PRESERVE_ORDER), "PRESERVE_ORDER" },
        { static_cast<uint32_t>(PreserveOrderType::DONT_PRESERVE_ORDER), "DONT_PRESERVE_ORDER" }
    };
    return values;
}

◆ GetProfilerPrintFormatValues()

const StringUtil::EnumStringLiteral * duckdb::GetProfilerPrintFormatValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ProfilerPrintFormat::QUERY_TREE), "QUERY_TREE" },
        { static_cast<uint32_t>(ProfilerPrintFormat::JSON), "JSON" },
        { static_cast<uint32_t>(ProfilerPrintFormat::QUERY_TREE_OPTIMIZER), "QUERY_TREE_OPTIMIZER" },
        { static_cast<uint32_t>(ProfilerPrintFormat::NO_OUTPUT), "NO_OUTPUT" },
        { static_cast<uint32_t>(ProfilerPrintFormat::HTML), "HTML" },
        { static_cast<uint32_t>(ProfilerPrintFormat::GRAPHVIZ), "GRAPHVIZ" },
        { static_cast<uint32_t>(ProfilerPrintFormat::MERMAID), "MERMAID" }
    };
    return values;
}

◆ GetProfilingCoverageValues()

const StringUtil::EnumStringLiteral * duckdb::GetProfilingCoverageValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ProfilingCoverage::SELECT), "SELECT" },
        { static_cast<uint32_t>(ProfilingCoverage::ALL), "ALL" }
    };
    return values;
}

◆ GetProfilingParameterNamesValues()

const StringUtil::EnumStringLiteral * duckdb::GetProfilingParameterNamesValues ( )

private

                                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ProfilingParameterNames::FORMAT), "FORMAT" },
        { static_cast<uint32_t>(ProfilingParameterNames::COVERAGE), "COVERAGE" },
        { static_cast<uint32_t>(ProfilingParameterNames::SAVE_LOCATION), "SAVE_LOCATION" },
        { static_cast<uint32_t>(ProfilingParameterNames::MODE), "MODE" },
        { static_cast<uint32_t>(ProfilingParameterNames::METRICS), "METRICS" }
    };
    return values;
}

◆ GetPushdownExtractSupportValues()

const StringUtil::EnumStringLiteral * duckdb::GetPushdownExtractSupportValues ( )

private

                                                                     {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(PushdownExtractSupport::UNCHECKED), "UNCHECKED" },
        { static_cast<uint32_t>(PushdownExtractSupport::DISABLED), "DISABLED" },
        { static_cast<uint32_t>(PushdownExtractSupport::ENABLED), "ENABLED" }
    };
    return values;
}

◆ GetQuantileSerializationTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetQuantileSerializationTypeValues ( )

private

                                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(QuantileSerializationType::NON_DECIMAL), "NON_DECIMAL" },
        { static_cast<uint32_t>(QuantileSerializationType::DECIMAL_DISCRETE), "DECIMAL_DISCRETE" },
        { static_cast<uint32_t>(QuantileSerializationType::DECIMAL_DISCRETE_LIST), "DECIMAL_DISCRETE_LIST" },
        { static_cast<uint32_t>(QuantileSerializationType::DECIMAL_CONTINUOUS), "DECIMAL_CONTINUOUS" },
        { static_cast<uint32_t>(QuantileSerializationType::DECIMAL_CONTINUOUS_LIST), "DECIMAL_CONTINUOUS_LIST" }
    };
    return values;
}

◆ GetQueryNodeTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetQueryNodeTypeValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(QueryNodeType::SELECT_NODE), "SELECT_NODE" },
        { static_cast<uint32_t>(QueryNodeType::SET_OPERATION_NODE), "SET_OPERATION_NODE" },
        { static_cast<uint32_t>(QueryNodeType::BOUND_SUBQUERY_NODE), "BOUND_SUBQUERY_NODE" },
        { static_cast<uint32_t>(QueryNodeType::RECURSIVE_CTE_NODE), "RECURSIVE_CTE_NODE" },
        { static_cast<uint32_t>(QueryNodeType::CTE_NODE), "CTE_NODE" },
        { static_cast<uint32_t>(QueryNodeType::STATEMENT_NODE), "STATEMENT_NODE" }
    };
    return values;
}

◆ GetQueryResultMemoryTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetQueryResultMemoryTypeValues ( )

private

                                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(QueryResultMemoryType::IN_MEMORY), "IN_MEMORY" },
        { static_cast<uint32_t>(QueryResultMemoryType::BUFFER_MANAGED), "BUFFER_MANAGED" }
    };
    return values;
}

◆ GetQueryResultOutputTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetQueryResultOutputTypeValues ( )

private

                                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(QueryResultOutputType::FORCE_MATERIALIZED), "FORCE_MATERIALIZED" },
        { static_cast<uint32_t>(QueryResultOutputType::ALLOW_STREAMING), "ALLOW_STREAMING" }
    };
    return values;
}

◆ GetQueryResultTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetQueryResultTypeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(QueryResultType::MATERIALIZED_RESULT), "MATERIALIZED_RESULT" },
        { static_cast<uint32_t>(QueryResultType::STREAM_RESULT), "STREAM_RESULT" },
        { static_cast<uint32_t>(QueryResultType::PENDING_RESULT), "PENDING_RESULT" },
        { static_cast<uint32_t>(QueryResultType::ARROW_RESULT), "ARROW_RESULT" }
    };
    return values;
}

◆ GetRecoveryModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetRecoveryModeValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(RecoveryMode::DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(RecoveryMode::NO_WAL_WRITES), "NO_WAL_WRITES" }
    };
    return values;
}

◆ GetRelationTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetRelationTypeValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(RelationType::INVALID_RELATION), "INVALID_RELATION" },
        { static_cast<uint32_t>(RelationType::TABLE_RELATION), "TABLE_RELATION" },
        { static_cast<uint32_t>(RelationType::PROJECTION_RELATION), "PROJECTION_RELATION" },
        { static_cast<uint32_t>(RelationType::FILTER_RELATION), "FILTER_RELATION" },
        { static_cast<uint32_t>(RelationType::EXPLAIN_RELATION), "EXPLAIN_RELATION" },
        { static_cast<uint32_t>(RelationType::CROSS_PRODUCT_RELATION), "CROSS_PRODUCT_RELATION" },
        { static_cast<uint32_t>(RelationType::JOIN_RELATION), "JOIN_RELATION" },
        { static_cast<uint32_t>(RelationType::AGGREGATE_RELATION), "AGGREGATE_RELATION" },
        { static_cast<uint32_t>(RelationType::SET_OPERATION_RELATION), "SET_OPERATION_RELATION" },
        { static_cast<uint32_t>(RelationType::DISTINCT_RELATION), "DISTINCT_RELATION" },
        { static_cast<uint32_t>(RelationType::LIMIT_RELATION), "LIMIT_RELATION" },
        { static_cast<uint32_t>(RelationType::ORDER_RELATION), "ORDER_RELATION" },
        { static_cast<uint32_t>(RelationType::CREATE_VIEW_RELATION), "CREATE_VIEW_RELATION" },
        { static_cast<uint32_t>(RelationType::CREATE_TABLE_RELATION), "CREATE_TABLE_RELATION" },
        { static_cast<uint32_t>(RelationType::INSERT_RELATION), "INSERT_RELATION" },
        { static_cast<uint32_t>(RelationType::VALUE_LIST_RELATION), "VALUE_LIST_RELATION" },
        { static_cast<uint32_t>(RelationType::MATERIALIZED_RELATION), "MATERIALIZED_RELATION" },
        { static_cast<uint32_t>(RelationType::DELETE_RELATION), "DELETE_RELATION" },
        { static_cast<uint32_t>(RelationType::UPDATE_RELATION), "UPDATE_RELATION" },
        { static_cast<uint32_t>(RelationType::WRITE_CSV_RELATION), "WRITE_CSV_RELATION" },
        { static_cast<uint32_t>(RelationType::WRITE_PARQUET_RELATION), "WRITE_PARQUET_RELATION" },
        { static_cast<uint32_t>(RelationType::READ_CSV_RELATION), "READ_CSV_RELATION" },
        { static_cast<uint32_t>(RelationType::SUBQUERY_RELATION), "SUBQUERY_RELATION" },
        { static_cast<uint32_t>(RelationType::TABLE_FUNCTION_RELATION), "TABLE_FUNCTION_RELATION" },
        { static_cast<uint32_t>(RelationType::VIEW_RELATION), "VIEW_RELATION" },
        { static_cast<uint32_t>(RelationType::QUERY_RELATION), "QUERY_RELATION" },
        { static_cast<uint32_t>(RelationType::DELIM_JOIN_RELATION), "DELIM_JOIN_RELATION" },
        { static_cast<uint32_t>(RelationType::DELIM_GET_RELATION), "DELIM_GET_RELATION" },
        { static_cast<uint32_t>(RelationType::EXTENSION_RELATION), "EXTENSION_RELATION" }
    };
    return values;
}

◆ GetRenderModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetRenderModeValues ( )

private

                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(RenderMode::ROWS), "ROWS" },
        { static_cast<uint32_t>(RenderMode::COLUMNS), "COLUMNS" }
    };
    return values;
}

◆ GetRequestTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetRequestTypeValues ( )

private

                                                          {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(RequestType::GET_REQUEST), "GET" },
        { static_cast<uint32_t>(RequestType::PUT_REQUEST), "PUT" },
        { static_cast<uint32_t>(RequestType::HEAD_REQUEST), "HEAD" },
        { static_cast<uint32_t>(RequestType::DELETE_REQUEST), "DELETE" },
        { static_cast<uint32_t>(RequestType::POST_REQUEST), "POST" }
    };
    return values;
}

◆ GetResultModifierTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetResultModifierTypeValues ( )

private

                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ResultModifierType::LIMIT_MODIFIER), "LIMIT_MODIFIER" },
        { static_cast<uint32_t>(ResultModifierType::ORDER_MODIFIER), "ORDER_MODIFIER" },
        { static_cast<uint32_t>(ResultModifierType::DISTINCT_MODIFIER), "DISTINCT_MODIFIER" },
        { static_cast<uint32_t>(ResultModifierType::LIMIT_PERCENT_MODIFIER), "LIMIT_PERCENT_MODIFIER" }
    };
    return values;
}

◆ GetSampleMethodValues()

const StringUtil::EnumStringLiteral * duckdb::GetSampleMethodValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SampleMethod::SYSTEM_SAMPLE), "System" },
        { static_cast<uint32_t>(SampleMethod::BERNOULLI_SAMPLE), "Bernoulli" },
        { static_cast<uint32_t>(SampleMethod::RESERVOIR_SAMPLE), "Reservoir" },
        { static_cast<uint32_t>(SampleMethod::INVALID), "INVALID" }
    };
    return values;
}

◆ GetSampleTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSampleTypeValues ( )

private

                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SampleType::BLOCKING_SAMPLE), "BLOCKING_SAMPLE" },
        { static_cast<uint32_t>(SampleType::RESERVOIR_SAMPLE), "RESERVOIR_SAMPLE" },
        { static_cast<uint32_t>(SampleType::RESERVOIR_PERCENTAGE_SAMPLE), "RESERVOIR_PERCENTAGE_SAMPLE" }
    };
    return values;
}

◆ GetSamplingStateValues()

const StringUtil::EnumStringLiteral * duckdb::GetSamplingStateValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SamplingState::RANDOM), "RANDOM" },
        { static_cast<uint32_t>(SamplingState::RESERVOIR), "RESERVOIR" }
    };
    return values;
}

◆ GetScanTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetScanTypeValues ( )

private

                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ScanType::TABLE), "TABLE" },
        { static_cast<uint32_t>(ScanType::PARQUET), "PARQUET" },
        { static_cast<uint32_t>(ScanType::EXTERNAL), "EXTERNAL" }
    };
    return values;
}

◆ GetSecretDisplayTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSecretDisplayTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SecretDisplayType::REDACTED), "REDACTED" },
        { static_cast<uint32_t>(SecretDisplayType::UNREDACTED), "UNREDACTED" }
    };
    return values;
}

◆ GetSecretPersistTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSecretPersistTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SecretPersistType::DEFAULT), "DEFAULT" },
        { static_cast<uint32_t>(SecretPersistType::TEMPORARY), "TEMPORARY" },
        { static_cast<uint32_t>(SecretPersistType::PERSISTENT), "PERSISTENT" }
    };
    return values;
}

◆ GetSecretSerializationTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSecretSerializationTypeValues ( )

private

                                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SecretSerializationType::CUSTOM), "CUSTOM" },
        { static_cast<uint32_t>(SecretSerializationType::KEY_VALUE_SECRET), "KEY_VALUE_SECRET" }
    };
    return values;
}

◆ GetSequenceInfoValues()

const StringUtil::EnumStringLiteral * duckdb::GetSequenceInfoValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SequenceInfo::SEQ_START), "SEQ_START" },
        { static_cast<uint32_t>(SequenceInfo::SEQ_INC), "SEQ_INC" },
        { static_cast<uint32_t>(SequenceInfo::SEQ_MIN), "SEQ_MIN" },
        { static_cast<uint32_t>(SequenceInfo::SEQ_MAX), "SEQ_MAX" },
        { static_cast<uint32_t>(SequenceInfo::SEQ_CYCLE), "SEQ_CYCLE" },
        { static_cast<uint32_t>(SequenceInfo::SEQ_OWN), "SEQ_OWN" }
    };
    return values;
}

◆ GetSetOperationTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSetOperationTypeValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SetOperationType::NONE), "NONE" },
        { static_cast<uint32_t>(SetOperationType::UNION), "UNION" },
        { static_cast<uint32_t>(SetOperationType::EXCEPT), "EXCEPT" },
        { static_cast<uint32_t>(SetOperationType::INTERSECT), "INTERSECT" },
        { static_cast<uint32_t>(SetOperationType::UNION_BY_NAME), "UNION_BY_NAME" }
    };
    return values;
}

◆ GetSetScopeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSetScopeValues ( )

private

                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SetScope::AUTOMATIC), "AUTOMATIC" },
        { static_cast<uint32_t>(SetScope::LOCAL), "LOCAL" },
        { static_cast<uint32_t>(SetScope::SESSION), "SESSION" },
        { static_cast<uint32_t>(SetScope::GLOBAL), "GLOBAL" },
        { static_cast<uint32_t>(SetScope::VARIABLE), "VARIABLE" }
    };
    return values;
}

◆ GetSetTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSetTypeValues ( )

private

                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SetType::SET), "SET" },
        { static_cast<uint32_t>(SetType::RESET), "RESET" }
    };
    return values;
}

◆ GetSettingScopeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSettingScopeValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SettingScope::GLOBAL), "GLOBAL" },
        { static_cast<uint32_t>(SettingScope::LOCAL), "LOCAL" },
        { static_cast<uint32_t>(SettingScope::SECRET), "SECRET" },
        { static_cast<uint32_t>(SettingScope::INVALID), "INVALID" }
    };
    return values;
}

◆ GetShowTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetShowTypeValues ( )

private

                                                       {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ShowType::SUMMARY), "SUMMARY" },
        { static_cast<uint32_t>(ShowType::DESCRIBE), "DESCRIBE" },
        { static_cast<uint32_t>(ShowType::SHOW_FROM), "SHOW_FROM" },
        { static_cast<uint32_t>(ShowType::SHOW_UNQUALIFIED), "SHOW_UNQUALIFIED" }
    };
    return values;
}

◆ GetSimplifiedTokenTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSimplifiedTokenTypeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_IDENTIFIER), "SIMPLIFIED_TOKEN_IDENTIFIER" },
        { static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_NUMERIC_CONSTANT), "SIMPLIFIED_TOKEN_NUMERIC_CONSTANT" },
        { static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_STRING_CONSTANT), "SIMPLIFIED_TOKEN_STRING_CONSTANT" },
        { static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_OPERATOR), "SIMPLIFIED_TOKEN_OPERATOR" },
        { static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_KEYWORD), "SIMPLIFIED_TOKEN_KEYWORD" },
        { static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_COMMENT), "SIMPLIFIED_TOKEN_COMMENT" },
        { static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_ERROR), "SIMPLIFIED_TOKEN_ERROR" },
        { static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_ERROR_EMPHASIS), "SIMPLIFIED_TOKEN_ERROR_EMPHASIS" },
        { static_cast<uint32_t>(SimplifiedTokenType::SIMPLIFIED_TOKEN_ERROR_SUGGESTION), "SIMPLIFIED_TOKEN_ERROR_SUGGESTION" }
    };
    return values;
}

◆ GetSinkCombineResultTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSinkCombineResultTypeValues ( )

private

                                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SinkCombineResultType::FINISHED), "FINISHED" },
        { static_cast<uint32_t>(SinkCombineResultType::BLOCKED), "BLOCKED" }
    };
    return values;
}

◆ GetSinkFinalizeTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSinkFinalizeTypeValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SinkFinalizeType::READY), "READY" },
        { static_cast<uint32_t>(SinkFinalizeType::NO_OUTPUT_POSSIBLE), "NO_OUTPUT_POSSIBLE" },
        { static_cast<uint32_t>(SinkFinalizeType::BLOCKED), "BLOCKED" }
    };
    return values;
}

◆ GetSinkNextBatchTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSinkNextBatchTypeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SinkNextBatchType::READY), "READY" },
        { static_cast<uint32_t>(SinkNextBatchType::BLOCKED), "BLOCKED" }
    };
    return values;
}

◆ GetSinkResultTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSinkResultTypeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SinkResultType::NEED_MORE_INPUT), "NEED_MORE_INPUT" },
        { static_cast<uint32_t>(SinkResultType::FINISHED), "FINISHED" },
        { static_cast<uint32_t>(SinkResultType::BLOCKED), "BLOCKED" }
    };
    return values;
}

◆ GetSortKeyTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSortKeyTypeValues ( )

private

                                                          {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SortKeyType::INVALID), "INVALID" },
        { static_cast<uint32_t>(SortKeyType::NO_PAYLOAD_FIXED_8), "NO_PAYLOAD_FIXED_8" },
        { static_cast<uint32_t>(SortKeyType::NO_PAYLOAD_FIXED_16), "NO_PAYLOAD_FIXED_16" },
        { static_cast<uint32_t>(SortKeyType::NO_PAYLOAD_FIXED_24), "NO_PAYLOAD_FIXED_24" },
        { static_cast<uint32_t>(SortKeyType::NO_PAYLOAD_FIXED_32), "NO_PAYLOAD_FIXED_32" },
        { static_cast<uint32_t>(SortKeyType::NO_PAYLOAD_VARIABLE_32), "NO_PAYLOAD_VARIABLE_32" },
        { static_cast<uint32_t>(SortKeyType::PAYLOAD_FIXED_16), "PAYLOAD_FIXED_16" },
        { static_cast<uint32_t>(SortKeyType::PAYLOAD_FIXED_24), "PAYLOAD_FIXED_24" },
        { static_cast<uint32_t>(SortKeyType::PAYLOAD_FIXED_32), "PAYLOAD_FIXED_32" },
        { static_cast<uint32_t>(SortKeyType::PAYLOAD_VARIABLE_32), "PAYLOAD_VARIABLE_32" }
    };
    return values;
}

◆ GetSourceResultTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSourceResultTypeValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SourceResultType::HAVE_MORE_OUTPUT), "HAVE_MORE_OUTPUT" },
        { static_cast<uint32_t>(SourceResultType::FINISHED), "FINISHED" },
        { static_cast<uint32_t>(SourceResultType::BLOCKED), "BLOCKED" }
    };
    return values;
}

◆ GetStarExpressionTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetStarExpressionTypeValues ( )

private

                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(StarExpressionType::STAR), "STAR" },
        { static_cast<uint32_t>(StarExpressionType::COLUMNS), "COLUMNS" },
        { static_cast<uint32_t>(StarExpressionType::UNPACKED), "UNPACKED" },
        { static_cast<uint32_t>(StarExpressionType::NONE), "NONE" }
    };
    return values;
}

◆ GetStatementReturnTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetStatementReturnTypeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(StatementReturnType::QUERY_RESULT), "QUERY_RESULT" },
        { static_cast<uint32_t>(StatementReturnType::CHANGED_ROWS), "CHANGED_ROWS" },
        { static_cast<uint32_t>(StatementReturnType::NOTHING), "NOTHING" }
    };
    return values;
}

◆ GetStatementTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetStatementTypeValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(StatementType::INVALID_STATEMENT), "INVALID_STATEMENT" },
        { static_cast<uint32_t>(StatementType::SELECT_STATEMENT), "SELECT_STATEMENT" },
        { static_cast<uint32_t>(StatementType::INSERT_STATEMENT), "INSERT_STATEMENT" },
        { static_cast<uint32_t>(StatementType::UPDATE_STATEMENT), "UPDATE_STATEMENT" },
        { static_cast<uint32_t>(StatementType::CREATE_STATEMENT), "CREATE_STATEMENT" },
        { static_cast<uint32_t>(StatementType::DELETE_STATEMENT), "DELETE_STATEMENT" },
        { static_cast<uint32_t>(StatementType::PREPARE_STATEMENT), "PREPARE_STATEMENT" },
        { static_cast<uint32_t>(StatementType::EXECUTE_STATEMENT), "EXECUTE_STATEMENT" },
        { static_cast<uint32_t>(StatementType::ALTER_STATEMENT), "ALTER_STATEMENT" },
        { static_cast<uint32_t>(StatementType::TRANSACTION_STATEMENT), "TRANSACTION_STATEMENT" },
        { static_cast<uint32_t>(StatementType::COPY_STATEMENT), "COPY_STATEMENT" },
        { static_cast<uint32_t>(StatementType::ANALYZE_STATEMENT), "ANALYZE_STATEMENT" },
        { static_cast<uint32_t>(StatementType::VARIABLE_SET_STATEMENT), "VARIABLE_SET_STATEMENT" },
        { static_cast<uint32_t>(StatementType::CREATE_FUNC_STATEMENT), "CREATE_FUNC_STATEMENT" },
        { static_cast<uint32_t>(StatementType::EXPLAIN_STATEMENT), "EXPLAIN_STATEMENT" },
        { static_cast<uint32_t>(StatementType::DROP_STATEMENT), "DROP_STATEMENT" },
        { static_cast<uint32_t>(StatementType::EXPORT_STATEMENT), "EXPORT_STATEMENT" },
        { static_cast<uint32_t>(StatementType::PRAGMA_STATEMENT), "PRAGMA_STATEMENT" },
        { static_cast<uint32_t>(StatementType::VACUUM_STATEMENT), "VACUUM_STATEMENT" },
        { static_cast<uint32_t>(StatementType::CALL_STATEMENT), "CALL_STATEMENT" },
        { static_cast<uint32_t>(StatementType::SET_STATEMENT), "SET_STATEMENT" },
        { static_cast<uint32_t>(StatementType::LOAD_STATEMENT), "LOAD_STATEMENT" },
        { static_cast<uint32_t>(StatementType::RELATION_STATEMENT), "RELATION_STATEMENT" },
        { static_cast<uint32_t>(StatementType::EXTENSION_STATEMENT), "EXTENSION_STATEMENT" },
        { static_cast<uint32_t>(StatementType::LOGICAL_PLAN_STATEMENT), "LOGICAL_PLAN_STATEMENT" },
        { static_cast<uint32_t>(StatementType::ATTACH_STATEMENT), "ATTACH_STATEMENT" },
        { static_cast<uint32_t>(StatementType::DETACH_STATEMENT), "DETACH_STATEMENT" },
        { static_cast<uint32_t>(StatementType::MULTI_STATEMENT), "MULTI_STATEMENT" },
        { static_cast<uint32_t>(StatementType::COPY_DATABASE_STATEMENT), "COPY_DATABASE_STATEMENT" },
        { static_cast<uint32_t>(StatementType::UPDATE_EXTENSIONS_STATEMENT), "UPDATE_EXTENSIONS_STATEMENT" },
        { static_cast<uint32_t>(StatementType::MERGE_INTO_STATEMENT), "MERGE_INTO_STATEMENT" }
    };
    return values;
}

◆ GetStatisticsTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetStatisticsTypeValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(StatisticsType::NUMERIC_STATS), "NUMERIC_STATS" },
        { static_cast<uint32_t>(StatisticsType::STRING_STATS), "STRING_STATS" },
        { static_cast<uint32_t>(StatisticsType::LIST_STATS), "LIST_STATS" },
        { static_cast<uint32_t>(StatisticsType::STRUCT_STATS), "STRUCT_STATS" },
        { static_cast<uint32_t>(StatisticsType::BASE_STATS), "BASE_STATS" },
        { static_cast<uint32_t>(StatisticsType::ARRAY_STATS), "ARRAY_STATS" },
        { static_cast<uint32_t>(StatisticsType::GEOMETRY_STATS), "GEOMETRY_STATS" },
        { static_cast<uint32_t>(StatisticsType::VARIANT_STATS), "VARIANT_STATS" }
    };
    return values;
}

◆ GetStatsInfoValues()

const StringUtil::EnumStringLiteral * duckdb::GetStatsInfoValues ( )

private

                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(StatsInfo::CAN_HAVE_NULL_VALUES), "CAN_HAVE_NULL_VALUES" },
        { static_cast<uint32_t>(StatsInfo::CANNOT_HAVE_NULL_VALUES), "CANNOT_HAVE_NULL_VALUES" },
        { static_cast<uint32_t>(StatsInfo::CAN_HAVE_VALID_VALUES), "CAN_HAVE_VALID_VALUES" },
        { static_cast<uint32_t>(StatsInfo::CANNOT_HAVE_VALID_VALUES), "CANNOT_HAVE_VALID_VALUES" },
        { static_cast<uint32_t>(StatsInfo::CAN_HAVE_NULL_AND_VALID_VALUES), "CAN_HAVE_NULL_AND_VALID_VALUES" }
    };
    return values;
}

◆ GetStorageBlockPrefetchValues()

const StringUtil::EnumStringLiteral * duckdb::GetStorageBlockPrefetchValues ( )

private

                                                                   {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(StorageBlockPrefetch::REMOTE_ONLY), "REMOTE_ONLY" },
        { static_cast<uint32_t>(StorageBlockPrefetch::NEVER), "NEVER" },
        { static_cast<uint32_t>(StorageBlockPrefetch::ALWAYS_PREFETCH), "ALWAYS_PREFETCH" },
        { static_cast<uint32_t>(StorageBlockPrefetch::DEBUG_FORCE_ALWAYS), "DEBUG_FORCE_ALWAYS" }
    };
    return values;
}

◆ GetStorageIndexTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetStorageIndexTypeValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(StorageIndexType::FULL_READ), "FULL_READ" },
        { static_cast<uint32_t>(StorageIndexType::PUSHDOWN_EXTRACT), "PUSHDOWN_EXTRACT" }
    };
    return values;
}

◆ GetStrTimeSpecifierValues()

const StringUtil::EnumStringLiteral * duckdb::GetStrTimeSpecifierValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(StrTimeSpecifier::ABBREVIATED_WEEKDAY_NAME), "ABBREVIATED_WEEKDAY_NAME" },
        { static_cast<uint32_t>(StrTimeSpecifier::FULL_WEEKDAY_NAME), "FULL_WEEKDAY_NAME" },
        { static_cast<uint32_t>(StrTimeSpecifier::WEEKDAY_DECIMAL), "WEEKDAY_DECIMAL" },
        { static_cast<uint32_t>(StrTimeSpecifier::DAY_OF_MONTH_PADDED), "DAY_OF_MONTH_PADDED" },
        { static_cast<uint32_t>(StrTimeSpecifier::DAY_OF_MONTH), "DAY_OF_MONTH" },
        { static_cast<uint32_t>(StrTimeSpecifier::ABBREVIATED_MONTH_NAME), "ABBREVIATED_MONTH_NAME" },
        { static_cast<uint32_t>(StrTimeSpecifier::FULL_MONTH_NAME), "FULL_MONTH_NAME" },
        { static_cast<uint32_t>(StrTimeSpecifier::MONTH_DECIMAL_PADDED), "MONTH_DECIMAL_PADDED" },
        { static_cast<uint32_t>(StrTimeSpecifier::MONTH_DECIMAL), "MONTH_DECIMAL" },
        { static_cast<uint32_t>(StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED), "YEAR_WITHOUT_CENTURY_PADDED" },
        { static_cast<uint32_t>(StrTimeSpecifier::YEAR_WITHOUT_CENTURY), "YEAR_WITHOUT_CENTURY" },
        { static_cast<uint32_t>(StrTimeSpecifier::YEAR_DECIMAL), "YEAR_DECIMAL" },
        { static_cast<uint32_t>(StrTimeSpecifier::HOUR_24_PADDED), "HOUR_24_PADDED" },
        { static_cast<uint32_t>(StrTimeSpecifier::HOUR_24_DECIMAL), "HOUR_24_DECIMAL" },
        { static_cast<uint32_t>(StrTimeSpecifier::HOUR_12_PADDED), "HOUR_12_PADDED" },
        { static_cast<uint32_t>(StrTimeSpecifier::HOUR_12_DECIMAL), "HOUR_12_DECIMAL" },
        { static_cast<uint32_t>(StrTimeSpecifier::AM_PM), "AM_PM" },
        { static_cast<uint32_t>(StrTimeSpecifier::MINUTE_PADDED), "MINUTE_PADDED" },
        { static_cast<uint32_t>(StrTimeSpecifier::MINUTE_DECIMAL), "MINUTE_DECIMAL" },
        { static_cast<uint32_t>(StrTimeSpecifier::SECOND_PADDED), "SECOND_PADDED" },
        { static_cast<uint32_t>(StrTimeSpecifier::SECOND_DECIMAL), "SECOND_DECIMAL" },
        { static_cast<uint32_t>(StrTimeSpecifier::MICROSECOND_PADDED), "MICROSECOND_PADDED" },
        { static_cast<uint32_t>(StrTimeSpecifier::MILLISECOND_PADDED), "MILLISECOND_PADDED" },
        { static_cast<uint32_t>(StrTimeSpecifier::UTC_OFFSET), "UTC_OFFSET" },
        { static_cast<uint32_t>(StrTimeSpecifier::TZ_NAME), "TZ_NAME" },
        { static_cast<uint32_t>(StrTimeSpecifier::DAY_OF_YEAR_PADDED), "DAY_OF_YEAR_PADDED" },
        { static_cast<uint32_t>(StrTimeSpecifier::DAY_OF_YEAR_DECIMAL), "DAY_OF_YEAR_DECIMAL" },
        { static_cast<uint32_t>(StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST), "WEEK_NUMBER_PADDED_SUN_FIRST" },
        { static_cast<uint32_t>(StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST), "WEEK_NUMBER_PADDED_MON_FIRST" },
        { static_cast<uint32_t>(StrTimeSpecifier::LOCALE_APPROPRIATE_DATE_AND_TIME), "LOCALE_APPROPRIATE_DATE_AND_TIME" },
        { static_cast<uint32_t>(StrTimeSpecifier::LOCALE_APPROPRIATE_DATE), "LOCALE_APPROPRIATE_DATE" },
        { static_cast<uint32_t>(StrTimeSpecifier::LOCALE_APPROPRIATE_TIME), "LOCALE_APPROPRIATE_TIME" },
        { static_cast<uint32_t>(StrTimeSpecifier::NANOSECOND_PADDED), "NANOSECOND_PADDED" },
        { static_cast<uint32_t>(StrTimeSpecifier::YEAR_ISO), "YEAR_ISO" },
        { static_cast<uint32_t>(StrTimeSpecifier::WEEKDAY_ISO), "WEEKDAY_ISO" },
        { static_cast<uint32_t>(StrTimeSpecifier::WEEK_NUMBER_ISO), "WEEK_NUMBER_ISO" }
    };
    return values;
}

◆ GetStreamExecutionResultValues()

const StringUtil::EnumStringLiteral * duckdb::GetStreamExecutionResultValues ( )

private

                                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(StreamExecutionResult::CHUNK_READY), "CHUNK_READY" },
        { static_cast<uint32_t>(StreamExecutionResult::CHUNK_NOT_READY), "CHUNK_NOT_READY" },
        { static_cast<uint32_t>(StreamExecutionResult::EXECUTION_ERROR), "EXECUTION_ERROR" },
        { static_cast<uint32_t>(StreamExecutionResult::EXECUTION_CANCELLED), "EXECUTION_CANCELLED" },
        { static_cast<uint32_t>(StreamExecutionResult::BLOCKED), "BLOCKED" },
        { static_cast<uint32_t>(StreamExecutionResult::NO_TASKS_AVAILABLE), "NO_TASKS_AVAILABLE" },
        { static_cast<uint32_t>(StreamExecutionResult::EXECUTION_FINISHED), "EXECUTION_FINISHED" }
    };
    return values;
}

◆ GetSubqueryTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetSubqueryTypeValues ( )

private

                                                           {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(SubqueryType::INVALID), "INVALID" },
        { static_cast<uint32_t>(SubqueryType::SCALAR), "SCALAR" },
        { static_cast<uint32_t>(SubqueryType::EXISTS), "EXISTS" },
        { static_cast<uint32_t>(SubqueryType::NOT_EXISTS), "NOT_EXISTS" },
        { static_cast<uint32_t>(SubqueryType::ANY), "ANY" }
    };
    return values;
}

◆ GetTableColumnTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetTableColumnTypeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TableColumnType::STANDARD), "STANDARD" },
        { static_cast<uint32_t>(TableColumnType::GENERATED), "GENERATED" }
    };
    return values;
}

◆ GetTableFilterTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetTableFilterTypeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TableFilterType::CONSTANT_COMPARISON), "CONSTANT_COMPARISON" },
        { static_cast<uint32_t>(TableFilterType::IS_NULL), "IS_NULL" },
        { static_cast<uint32_t>(TableFilterType::IS_NOT_NULL), "IS_NOT_NULL" },
        { static_cast<uint32_t>(TableFilterType::CONJUNCTION_OR), "CONJUNCTION_OR" },
        { static_cast<uint32_t>(TableFilterType::CONJUNCTION_AND), "CONJUNCTION_AND" },
        { static_cast<uint32_t>(TableFilterType::STRUCT_EXTRACT), "STRUCT_EXTRACT" },
        { static_cast<uint32_t>(TableFilterType::OPTIONAL_FILTER), "OPTIONAL_FILTER" },
        { static_cast<uint32_t>(TableFilterType::IN_FILTER), "IN_FILTER" },
        { static_cast<uint32_t>(TableFilterType::DYNAMIC_FILTER), "DYNAMIC_FILTER" },
        { static_cast<uint32_t>(TableFilterType::EXPRESSION_FILTER), "EXPRESSION_FILTER" },
        { static_cast<uint32_t>(TableFilterType::BLOOM_FILTER), "BLOOM_FILTER" }
    };
    return values;
}

◆ GetTablePartitionInfoValues()

const StringUtil::EnumStringLiteral * duckdb::GetTablePartitionInfoValues ( )

private

                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TablePartitionInfo::NOT_PARTITIONED), "NOT_PARTITIONED" },
        { static_cast<uint32_t>(TablePartitionInfo::SINGLE_VALUE_PARTITIONS), "SINGLE_VALUE_PARTITIONS" },
        { static_cast<uint32_t>(TablePartitionInfo::OVERLAPPING_PARTITIONS), "OVERLAPPING_PARTITIONS" },
        { static_cast<uint32_t>(TablePartitionInfo::DISJOINT_PARTITIONS), "DISJOINT_PARTITIONS" }
    };
    return values;
}

◆ GetTableReferenceTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetTableReferenceTypeValues ( )

private

                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TableReferenceType::INVALID), "INVALID" },
        { static_cast<uint32_t>(TableReferenceType::BASE_TABLE), "BASE_TABLE" },
        { static_cast<uint32_t>(TableReferenceType::SUBQUERY), "SUBQUERY" },
        { static_cast<uint32_t>(TableReferenceType::JOIN), "JOIN" },
        { static_cast<uint32_t>(TableReferenceType::TABLE_FUNCTION), "TABLE_FUNCTION" },
        { static_cast<uint32_t>(TableReferenceType::EXPRESSION_LIST), "EXPRESSION_LIST" },
        { static_cast<uint32_t>(TableReferenceType::CTE), "CTE" },
        { static_cast<uint32_t>(TableReferenceType::EMPTY_FROM), "EMPTY" },
        { static_cast<uint32_t>(TableReferenceType::PIVOT), "PIVOT" },
        { static_cast<uint32_t>(TableReferenceType::SHOW_REF), "SHOW_REF" },
        { static_cast<uint32_t>(TableReferenceType::COLUMN_DATA), "COLUMN_DATA" },
        { static_cast<uint32_t>(TableReferenceType::DELIM_GET), "DELIM_GET" },
        { static_cast<uint32_t>(TableReferenceType::BOUND_TABLE_REF), "BOUND_TABLE_REF" }
    };
    return values;
}

◆ GetTaskExecutionModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetTaskExecutionModeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TaskExecutionMode::PROCESS_ALL), "PROCESS_ALL" },
        { static_cast<uint32_t>(TaskExecutionMode::PROCESS_PARTIAL), "PROCESS_PARTIAL" }
    };
    return values;
}

◆ GetTaskExecutionResultValues()

const StringUtil::EnumStringLiteral * duckdb::GetTaskExecutionResultValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TaskExecutionResult::TASK_FINISHED), "TASK_FINISHED" },
        { static_cast<uint32_t>(TaskExecutionResult::TASK_NOT_FINISHED), "TASK_NOT_FINISHED" },
        { static_cast<uint32_t>(TaskExecutionResult::TASK_ERROR), "TASK_ERROR" },
        { static_cast<uint32_t>(TaskExecutionResult::TASK_BLOCKED), "TASK_BLOCKED" }
    };
    return values;
}

◆ GetTemporaryBufferSizeValues()

const StringUtil::EnumStringLiteral * duckdb::GetTemporaryBufferSizeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TemporaryBufferSize::INVALID), "INVALID" },
        { static_cast<uint32_t>(TemporaryBufferSize::S32K), "S32K" },
        { static_cast<uint32_t>(TemporaryBufferSize::S64K), "S64K" },
        { static_cast<uint32_t>(TemporaryBufferSize::S96K), "S96K" },
        { static_cast<uint32_t>(TemporaryBufferSize::S128K), "S128K" },
        { static_cast<uint32_t>(TemporaryBufferSize::S160K), "S160K" },
        { static_cast<uint32_t>(TemporaryBufferSize::S192K), "S192K" },
        { static_cast<uint32_t>(TemporaryBufferSize::S224K), "S224K" },
        { static_cast<uint32_t>(TemporaryBufferSize::DEFAULT), "DEFAULT" }
    };
    return values;
}

◆ GetTemporaryCompressionLevelValues()

const StringUtil::EnumStringLiteral * duckdb::GetTemporaryCompressionLevelValues ( )

private

                                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_MINUS_FIVE), "ZSTD_MINUS_FIVE" },
        { static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_MINUS_THREE), "ZSTD_MINUS_THREE" },
        { static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_MINUS_ONE), "ZSTD_MINUS_ONE" },
        { static_cast<uint32_t>(TemporaryCompressionLevel::UNCOMPRESSED), "UNCOMPRESSED" },
        { static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_ONE), "ZSTD_ONE" },
        { static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_THREE), "ZSTD_THREE" },
        { static_cast<uint32_t>(TemporaryCompressionLevel::ZSTD_FIVE), "ZSTD_FIVE" }
    };
    return values;
}

◆ GetThreadPinModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetThreadPinModeValues ( )

private

                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(ThreadPinMode::OFF), "OFF" },
        { static_cast<uint32_t>(ThreadPinMode::ON), "ON" },
        { static_cast<uint32_t>(ThreadPinMode::AUTO), "AUTO" }
    };
    return values;
}

◆ GetTimestampCastResultValues()

const StringUtil::EnumStringLiteral * duckdb::GetTimestampCastResultValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TimestampCastResult::SUCCESS), "SUCCESS" },
        { static_cast<uint32_t>(TimestampCastResult::ERROR_INCORRECT_FORMAT), "ERROR_INCORRECT_FORMAT" },
        { static_cast<uint32_t>(TimestampCastResult::ERROR_NON_UTC_TIMEZONE), "ERROR_NON_UTC_TIMEZONE" },
        { static_cast<uint32_t>(TimestampCastResult::ERROR_RANGE), "ERROR_RANGE" },
        { static_cast<uint32_t>(TimestampCastResult::STRICT_UTC), "STRICT_UTC" }
    };
    return values;
}

◆ GetTransactionInvalidationPolicyValues()

const StringUtil::EnumStringLiteral * duckdb::GetTransactionInvalidationPolicyValues ( )

private

                                                                            {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TransactionInvalidationPolicy::STANDARD_POLICY), "STANDARD_POLICY" },
        { static_cast<uint32_t>(TransactionInvalidationPolicy::ALL_ERRORS_INVALIDATE_TRANSACTION), "ALL_ERRORS_INVALIDATE_TRANSACTION" }
    };
    return values;
}

◆ GetTransactionModifierTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetTransactionModifierTypeValues ( )

private

                                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER), "TRANSACTION_DEFAULT_MODIFIER" },
        { static_cast<uint32_t>(TransactionModifierType::TRANSACTION_READ_ONLY), "TRANSACTION_READ_ONLY" },
        { static_cast<uint32_t>(TransactionModifierType::TRANSACTION_READ_WRITE), "TRANSACTION_READ_WRITE" }
    };
    return values;
}

◆ GetTransactionTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetTransactionTypeValues ( )

private

                                                              {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TransactionType::INVALID), "INVALID" },
        { static_cast<uint32_t>(TransactionType::BEGIN_TRANSACTION), "BEGIN_TRANSACTION" },
        { static_cast<uint32_t>(TransactionType::COMMIT), "COMMIT" },
        { static_cast<uint32_t>(TransactionType::ROLLBACK), "ROLLBACK" }
    };
    return values;
}

◆ GetTupleDataNestednessTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetTupleDataNestednessTypeValues ( )

private

                                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TupleDataNestednessType::TOP_LEVEL_LAYOUT), "TOP_LEVEL_LAYOUT" },
        { static_cast<uint32_t>(TupleDataNestednessType::NESTED_STRUCT_LAYOUT), "NESTED_STRUCT_LAYOUT" }
    };
    return values;
}

◆ GetTupleDataPinPropertiesValues()

const StringUtil::EnumStringLiteral * duckdb::GetTupleDataPinPropertiesValues ( )

private

                                                                     {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TupleDataPinProperties::INVALID), "INVALID" },
        { static_cast<uint32_t>(TupleDataPinProperties::KEEP_EVERYTHING_PINNED), "KEEP_EVERYTHING_PINNED" },
        { static_cast<uint32_t>(TupleDataPinProperties::UNPIN_AFTER_DONE), "UNPIN_AFTER_DONE" },
        { static_cast<uint32_t>(TupleDataPinProperties::DESTROY_AFTER_DONE), "DESTROY_AFTER_DONE" },
        { static_cast<uint32_t>(TupleDataPinProperties::ALREADY_PINNED), "ALREADY_PINNED" }
    };
    return values;
}

◆ GetTupleDataValidityTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetTupleDataValidityTypeValues ( )

private

                                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(TupleDataValidityType::CAN_HAVE_NULL_VALUES), "CAN_HAVE_NULL_VALUES" },
        { static_cast<uint32_t>(TupleDataValidityType::CANNOT_HAVE_NULL_VALUES), "CANNOT_HAVE_NULL_VALUES" }
    };
    return values;
}

◆ GetUndoFlagsValues()

const StringUtil::EnumStringLiteral * duckdb::GetUndoFlagsValues ( )

private

                                                        {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(UndoFlags::EMPTY_ENTRY), "EMPTY_ENTRY" },
        { static_cast<uint32_t>(UndoFlags::CATALOG_ENTRY), "CATALOG_ENTRY" },
        { static_cast<uint32_t>(UndoFlags::INSERT_TUPLE), "INSERT_TUPLE" },
        { static_cast<uint32_t>(UndoFlags::DELETE_TUPLE), "DELETE_TUPLE" },
        { static_cast<uint32_t>(UndoFlags::UPDATE_TUPLE), "UPDATE_TUPLE" },
        { static_cast<uint32_t>(UndoFlags::SEQUENCE_VALUE), "SEQUENCE_VALUE" },
        { static_cast<uint32_t>(UndoFlags::ATTACHED_DATABASE), "ATTACHED_DATABASE" }
    };
    return values;
}

◆ GetUnionInvalidReasonValues()

const StringUtil::EnumStringLiteral * duckdb::GetUnionInvalidReasonValues ( )

private

                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(UnionInvalidReason::VALID), "VALID" },
        { static_cast<uint32_t>(UnionInvalidReason::TAG_OUT_OF_RANGE), "TAG_OUT_OF_RANGE" },
        { static_cast<uint32_t>(UnionInvalidReason::NO_MEMBERS), "NO_MEMBERS" },
        { static_cast<uint32_t>(UnionInvalidReason::VALIDITY_OVERLAP), "VALIDITY_OVERLAP" },
        { static_cast<uint32_t>(UnionInvalidReason::TAG_MISMATCH), "TAG_MISMATCH" },
        { static_cast<uint32_t>(UnionInvalidReason::NULL_TAG), "NULL_TAG" }
    };
    return values;
}

◆ GetVariantChildLookupModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetVariantChildLookupModeValues ( )

private

                                                                     {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(VariantChildLookupMode::INVALID), "INVALID" },
        { static_cast<uint32_t>(VariantChildLookupMode::BY_KEY), "BY_KEY" },
        { static_cast<uint32_t>(VariantChildLookupMode::BY_INDEX), "BY_INDEX" }
    };
    return values;
}

◆ GetVariantLogicalTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetVariantLogicalTypeValues ( )

private

                                                                 {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(VariantLogicalType::VARIANT_NULL), "VARIANT_NULL" },
        { static_cast<uint32_t>(VariantLogicalType::BOOL_TRUE), "BOOL_TRUE" },
        { static_cast<uint32_t>(VariantLogicalType::BOOL_FALSE), "BOOL_FALSE" },
        { static_cast<uint32_t>(VariantLogicalType::INT8), "INT8" },
        { static_cast<uint32_t>(VariantLogicalType::INT16), "INT16" },
        { static_cast<uint32_t>(VariantLogicalType::INT32), "INT32" },
        { static_cast<uint32_t>(VariantLogicalType::INT64), "INT64" },
        { static_cast<uint32_t>(VariantLogicalType::INT128), "INT128" },
        { static_cast<uint32_t>(VariantLogicalType::UINT8), "UINT8" },
        { static_cast<uint32_t>(VariantLogicalType::UINT16), "UINT16" },
        { static_cast<uint32_t>(VariantLogicalType::UINT32), "UINT32" },
        { static_cast<uint32_t>(VariantLogicalType::UINT64), "UINT64" },
        { static_cast<uint32_t>(VariantLogicalType::UINT128), "UINT128" },
        { static_cast<uint32_t>(VariantLogicalType::FLOAT), "FLOAT" },
        { static_cast<uint32_t>(VariantLogicalType::DOUBLE), "DOUBLE" },
        { static_cast<uint32_t>(VariantLogicalType::DECIMAL), "DECIMAL" },
        { static_cast<uint32_t>(VariantLogicalType::VARCHAR), "VARCHAR" },
        { static_cast<uint32_t>(VariantLogicalType::BLOB), "BLOB" },
        { static_cast<uint32_t>(VariantLogicalType::UUID), "UUID" },
        { static_cast<uint32_t>(VariantLogicalType::DATE), "DATE" },
        { static_cast<uint32_t>(VariantLogicalType::TIME_MICROS), "TIME_MICROS" },
        { static_cast<uint32_t>(VariantLogicalType::TIME_NANOS), "TIME_NANOS" },
        { static_cast<uint32_t>(VariantLogicalType::TIMESTAMP_SEC), "TIMESTAMP_SEC" },
        { static_cast<uint32_t>(VariantLogicalType::TIMESTAMP_MILIS), "TIMESTAMP_MILIS" },
        { static_cast<uint32_t>(VariantLogicalType::TIMESTAMP_MICROS), "TIMESTAMP_MICROS" },
        { static_cast<uint32_t>(VariantLogicalType::TIMESTAMP_NANOS), "TIMESTAMP_NANOS" },
        { static_cast<uint32_t>(VariantLogicalType::TIME_MICROS_TZ), "TIME_MICROS_TZ" },
        { static_cast<uint32_t>(VariantLogicalType::TIMESTAMP_MICROS_TZ), "TIMESTAMP_MICROS_TZ" },
        { static_cast<uint32_t>(VariantLogicalType::INTERVAL), "INTERVAL" },
        { static_cast<uint32_t>(VariantLogicalType::OBJECT), "OBJECT" },
        { static_cast<uint32_t>(VariantLogicalType::ARRAY), "ARRAY" },
        { static_cast<uint32_t>(VariantLogicalType::BIGNUM), "BIGNUM" },
        { static_cast<uint32_t>(VariantLogicalType::BITSTRING), "BITSTRING" },
        { static_cast<uint32_t>(VariantLogicalType::GEOMETRY), "GEOMETRY" },
        { static_cast<uint32_t>(VariantLogicalType::ENUM_SIZE), "ENUM_SIZE" }
    };
    return values;
}

◆ GetVariantStatsShreddingStateValues()

const StringUtil::EnumStringLiteral * duckdb::GetVariantStatsShreddingStateValues ( )

private

                                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(VariantStatsShreddingState::UNINITIALIZED), "UNINITIALIZED" },
        { static_cast<uint32_t>(VariantStatsShreddingState::NOT_SHREDDED), "NOT_SHREDDED" },
        { static_cast<uint32_t>(VariantStatsShreddingState::SHREDDED), "SHREDDED" },
        { static_cast<uint32_t>(VariantStatsShreddingState::INCONSISTENT), "INCONSISTENT" }
    };
    return values;
}

◆ GetVariantValueTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetVariantValueTypeValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(VariantValueType::PRIMITIVE), "PRIMITIVE" },
        { static_cast<uint32_t>(VariantValueType::OBJECT), "OBJECT" },
        { static_cast<uint32_t>(VariantValueType::ARRAY), "ARRAY" },
        { static_cast<uint32_t>(VariantValueType::MISSING), "MISSING" }
    };
    return values;
}

◆ GetVectorAuxiliaryDataTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetVectorAuxiliaryDataTypeValues ( )

private

                                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(VectorAuxiliaryDataType::ARROW_AUXILIARY), "ARROW_AUXILIARY" }
    };
    return values;
}

◆ GetVectorBufferTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetVectorBufferTypeValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(VectorBufferType::STANDARD_BUFFER), "STANDARD_BUFFER" },
        { static_cast<uint32_t>(VectorBufferType::DICTIONARY_BUFFER), "DICTIONARY_BUFFER" },
        { static_cast<uint32_t>(VectorBufferType::VECTOR_CHILD_BUFFER), "VECTOR_CHILD_BUFFER" },
        { static_cast<uint32_t>(VectorBufferType::STRING_BUFFER), "STRING_BUFFER" },
        { static_cast<uint32_t>(VectorBufferType::FSST_BUFFER), "FSST_BUFFER" },
        { static_cast<uint32_t>(VectorBufferType::STRUCT_BUFFER), "STRUCT_BUFFER" },
        { static_cast<uint32_t>(VectorBufferType::LIST_BUFFER), "LIST_BUFFER" },
        { static_cast<uint32_t>(VectorBufferType::MANAGED_BUFFER), "MANAGED_BUFFER" },
        { static_cast<uint32_t>(VectorBufferType::OPAQUE_BUFFER), "OPAQUE_BUFFER" },
        { static_cast<uint32_t>(VectorBufferType::ARRAY_BUFFER), "ARRAY_BUFFER" }
    };
    return values;
}

◆ GetVectorTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetVectorTypeValues ( )

private

                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(VectorType::FLAT_VECTOR), "FLAT_VECTOR" },
        { static_cast<uint32_t>(VectorType::FSST_VECTOR), "FSST_VECTOR" },
        { static_cast<uint32_t>(VectorType::CONSTANT_VECTOR), "CONSTANT_VECTOR" },
        { static_cast<uint32_t>(VectorType::DICTIONARY_VECTOR), "DICTIONARY_VECTOR" },
        { static_cast<uint32_t>(VectorType::SEQUENCE_VECTOR), "SEQUENCE_VECTOR" }
    };
    return values;
}

◆ GetVerificationTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetVerificationTypeValues ( )

private

                                                               {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(VerificationType::ORIGINAL), "ORIGINAL" },
        { static_cast<uint32_t>(VerificationType::COPIED), "COPIED" },
        { static_cast<uint32_t>(VerificationType::DESERIALIZED), "DESERIALIZED" },
        { static_cast<uint32_t>(VerificationType::PARSED), "PARSED" },
        { static_cast<uint32_t>(VerificationType::UNOPTIMIZED), "UNOPTIMIZED" },
        { static_cast<uint32_t>(VerificationType::NO_OPERATOR_CACHING), "NO_OPERATOR_CACHING" },
        { static_cast<uint32_t>(VerificationType::PREPARED), "PREPARED" },
        { static_cast<uint32_t>(VerificationType::EXTERNAL), "EXTERNAL" },
        { static_cast<uint32_t>(VerificationType::EXPLAIN), "EXPLAIN" },
        { static_cast<uint32_t>(VerificationType::FETCH_ROW_AS_SCAN), "FETCH_ROW_AS_SCAN" },
        { static_cast<uint32_t>(VerificationType::INVALID), "INVALID" }
    };
    return values;
}

◆ GetVerifyExistenceTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetVerifyExistenceTypeValues ( )

private

                                                                  {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(VerifyExistenceType::APPEND), "APPEND" },
        { static_cast<uint32_t>(VerifyExistenceType::APPEND_FK), "APPEND_FK" },
        { static_cast<uint32_t>(VerifyExistenceType::DELETE_FK), "DELETE_FK" }
    };
    return values;
}

◆ GetVertexTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetVertexTypeValues ( )

private

                                                         {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(VertexType::XY), "XY" },
        { static_cast<uint32_t>(VertexType::XYZ), "XYZ" },
        { static_cast<uint32_t>(VertexType::XYM), "XYM" },
        { static_cast<uint32_t>(VertexType::XYZM), "XYZM" }
    };
    return values;
}

◆ GetWALTypeValues()

const StringUtil::EnumStringLiteral * duckdb::GetWALTypeValues ( )

private

                                                      {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(WALType::INVALID), "INVALID" },
        { static_cast<uint32_t>(WALType::CREATE_TABLE), "CREATE_TABLE" },
        { static_cast<uint32_t>(WALType::DROP_TABLE), "DROP_TABLE" },
        { static_cast<uint32_t>(WALType::CREATE_SCHEMA), "CREATE_SCHEMA" },
        { static_cast<uint32_t>(WALType::DROP_SCHEMA), "DROP_SCHEMA" },
        { static_cast<uint32_t>(WALType::CREATE_VIEW), "CREATE_VIEW" },
        { static_cast<uint32_t>(WALType::DROP_VIEW), "DROP_VIEW" },
        { static_cast<uint32_t>(WALType::CREATE_SEQUENCE), "CREATE_SEQUENCE" },
        { static_cast<uint32_t>(WALType::DROP_SEQUENCE), "DROP_SEQUENCE" },
        { static_cast<uint32_t>(WALType::SEQUENCE_VALUE), "SEQUENCE_VALUE" },
        { static_cast<uint32_t>(WALType::CREATE_MACRO), "CREATE_MACRO" },
        { static_cast<uint32_t>(WALType::DROP_MACRO), "DROP_MACRO" },
        { static_cast<uint32_t>(WALType::CREATE_TYPE), "CREATE_TYPE" },
        { static_cast<uint32_t>(WALType::DROP_TYPE), "DROP_TYPE" },
        { static_cast<uint32_t>(WALType::ALTER_INFO), "ALTER_INFO" },
        { static_cast<uint32_t>(WALType::CREATE_TABLE_MACRO), "CREATE_TABLE_MACRO" },
        { static_cast<uint32_t>(WALType::DROP_TABLE_MACRO), "DROP_TABLE_MACRO" },
        { static_cast<uint32_t>(WALType::CREATE_INDEX), "CREATE_INDEX" },
        { static_cast<uint32_t>(WALType::DROP_INDEX), "DROP_INDEX" },
        { static_cast<uint32_t>(WALType::USE_TABLE), "USE_TABLE" },
        { static_cast<uint32_t>(WALType::INSERT_TUPLE), "INSERT_TUPLE" },
        { static_cast<uint32_t>(WALType::DELETE_TUPLE), "DELETE_TUPLE" },
        { static_cast<uint32_t>(WALType::UPDATE_TUPLE), "UPDATE_TUPLE" },
        { static_cast<uint32_t>(WALType::ROW_GROUP_DATA), "ROW_GROUP_DATA" },
        { static_cast<uint32_t>(WALType::WAL_VERSION), "WAL_VERSION" },
        { static_cast<uint32_t>(WALType::CHECKPOINT), "CHECKPOINT" },
        { static_cast<uint32_t>(WALType::WAL_FLUSH), "WAL_FLUSH" }
    };
    return values;
}

◆ GetWindowAggregationModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetWindowAggregationModeValues ( )

private

                                                                    {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(WindowAggregationMode::WINDOW), "WINDOW" },
        { static_cast<uint32_t>(WindowAggregationMode::COMBINE), "COMBINE" },
        { static_cast<uint32_t>(WindowAggregationMode::SEPARATE), "SEPARATE" }
    };
    return values;
}

◆ GetWindowBoundaryValues()

const StringUtil::EnumStringLiteral * duckdb::GetWindowBoundaryValues ( )

private

                                                             {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(WindowBoundary::INVALID), "INVALID" },
        { static_cast<uint32_t>(WindowBoundary::UNBOUNDED_PRECEDING), "UNBOUNDED_PRECEDING" },
        { static_cast<uint32_t>(WindowBoundary::UNBOUNDED_FOLLOWING), "UNBOUNDED_FOLLOWING" },
        { static_cast<uint32_t>(WindowBoundary::CURRENT_ROW_RANGE), "CURRENT_ROW_RANGE" },
        { static_cast<uint32_t>(WindowBoundary::CURRENT_ROW_ROWS), "CURRENT_ROW_ROWS" },
        { static_cast<uint32_t>(WindowBoundary::EXPR_PRECEDING_ROWS), "EXPR_PRECEDING_ROWS" },
        { static_cast<uint32_t>(WindowBoundary::EXPR_FOLLOWING_ROWS), "EXPR_FOLLOWING_ROWS" },
        { static_cast<uint32_t>(WindowBoundary::EXPR_PRECEDING_RANGE), "EXPR_PRECEDING_RANGE" },
        { static_cast<uint32_t>(WindowBoundary::EXPR_FOLLOWING_RANGE), "EXPR_FOLLOWING_RANGE" },
        { static_cast<uint32_t>(WindowBoundary::CURRENT_ROW_GROUPS), "CURRENT_ROW_GROUPS" },
        { static_cast<uint32_t>(WindowBoundary::EXPR_PRECEDING_GROUPS), "EXPR_PRECEDING_GROUPS" },
        { static_cast<uint32_t>(WindowBoundary::EXPR_FOLLOWING_GROUPS), "EXPR_FOLLOWING_GROUPS" }
    };
    return values;
}

◆ GetWindowExcludeModeValues()

const StringUtil::EnumStringLiteral * duckdb::GetWindowExcludeModeValues ( )

private

                                                                {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(WindowExcludeMode::NO_OTHER), "NO_OTHER" },
        { static_cast<uint32_t>(WindowExcludeMode::CURRENT_ROW), "CURRENT_ROW" },
        { static_cast<uint32_t>(WindowExcludeMode::GROUP), "GROUP" },
        { static_cast<uint32_t>(WindowExcludeMode::TIES), "TIES" }
    };
    return values;
}

◆ GetWindowMergeSortStageValues()

const StringUtil::EnumStringLiteral * duckdb::GetWindowMergeSortStageValues ( )

private

                                                                   {
    static constexpr StringUtil::EnumStringLiteral values[] {
        { static_cast<uint32_t>(WindowMergeSortStage::INIT), "INIT" },
        { static_cast<uint32_t>(WindowMergeSortStage::COMBINE), "COMBINE" },
        { static_cast<uint32_t>(WindowMergeSortStage::FINALIZE), "FINALIZE" },
        { static_cast<uint32_t>(WindowMergeSortStage::SORTED), "SORTED" },
        { static_cast<uint32_t>(WindowMergeSortStage::FINISHED), "FINISHED" }
    };
    return values;
}

◆ CatalogTypeToString()

DUCKDB_API string duckdb::CatalogTypeToString ( CatalogType type )

private

                                             {
    switch (type) {
    case CatalogType::COLLATION_ENTRY:
        return "Collation";
    case CatalogType::COORDINATE_SYSTEM_ENTRY:
        return "Coordinate System";
    case CatalogType::TYPE_ENTRY:
        return "Type";
    case CatalogType::TABLE_ENTRY:
        return "Table";
    case CatalogType::SCHEMA_ENTRY:
        return "Schema";
    case CatalogType::DATABASE_ENTRY:
        return "Database";
    case CatalogType::TABLE_FUNCTION_ENTRY:
        return "Table Function";
    case CatalogType::SCALAR_FUNCTION_ENTRY:
        return "Scalar Function";
    case CatalogType::AGGREGATE_FUNCTION_ENTRY:
        return "Aggregate Function";
    case CatalogType::COPY_FUNCTION_ENTRY:
        return "Copy Function";
    case CatalogType::PRAGMA_FUNCTION_ENTRY:
        return "Pragma Function";
    case CatalogType::MACRO_ENTRY:
        return "Macro Function";
    case CatalogType::TABLE_MACRO_ENTRY:
        return "Table Macro Function";
    case CatalogType::VIEW_ENTRY:
        return "View";
    case CatalogType::INDEX_ENTRY:
        return "Index";
    case CatalogType::PREPARED_STATEMENT:
        return "Prepared Statement";
    case CatalogType::SEQUENCE_ENTRY:
        return "Sequence";
    case CatalogType::SECRET_ENTRY:
        return "Secret";
    case CatalogType::SECRET_TYPE_ENTRY:
        return "Secret Type";
    case CatalogType::SECRET_FUNCTION_ENTRY:
        return "Secret Function";
    case CatalogType::INVALID:
    case CatalogType::DELETED_ENTRY:
    case CatalogType::RENAMED_ENTRY:
    case CatalogType::DEPENDENCY_ENTRY:
        break;
    }
    return "INVALID";
}

◆ CatalogTypeFromString()

CatalogType duckdb::CatalogTypeFromString ( const string & type )

private

                                                      {
    if (type == "Collation") {
        return CatalogType::COLLATION_ENTRY;
    }
    if (type == "Coordinate System") {
        return CatalogType::COORDINATE_SYSTEM_ENTRY;
    }
    if (type == "Type") {
        return CatalogType::TYPE_ENTRY;
    }
    if (type == "Table") {
        return CatalogType::TABLE_ENTRY;
    }
    if (type == "Schema") {
        return CatalogType::SCHEMA_ENTRY;
    }
    if (type == "Database") {
        return CatalogType::DATABASE_ENTRY;
    }
    if (type == "Table Function") {
        return CatalogType::TABLE_FUNCTION_ENTRY;
    }
    if (type == "Scalar Function") {
        return CatalogType::SCALAR_FUNCTION_ENTRY;
    }
    if (type == "Aggregate Function") {
        return CatalogType::AGGREGATE_FUNCTION_ENTRY;
    }
    if (type == "Copy Function") {
        return CatalogType::COPY_FUNCTION_ENTRY;
    }
    if (type == "Pragma Function") {
        return CatalogType::PRAGMA_FUNCTION_ENTRY;
    }
    if (type == "Macro Function") {
        return CatalogType::MACRO_ENTRY;
    }
    if (type == "Table Macro Function") {
        return CatalogType::TABLE_MACRO_ENTRY;
    }
    if (type == "View") {
        return CatalogType::VIEW_ENTRY;
    }
    if (type == "Index") {
        return CatalogType::INDEX_ENTRY;
    }
    if (type == "Prepared Statement") {
        return CatalogType::PREPARED_STATEMENT;
    }
    if (type == "Sequence") {
        return CatalogType::SEQUENCE_ENTRY;
    }
    if (type == "INVALID") {
        return CatalogType::INVALID;
    }
    throw InternalException("Unrecognized CatalogType '%s'", type);
}

◆ ListCompressionTypes()

vector< string > duckdb::ListCompressionTypes ( void )

private

                                          {
    vector<string> compression_types;
    uint8_t amount_of_compression_options = (uint8_t)CompressionType::COMPRESSION_COUNT;
    compression_types.reserve(amount_of_compression_options);
    for (uint8_t i = 0; i < amount_of_compression_options; i++) {
        compression_types.push_back(CompressionTypeToString((CompressionType)i));
    }
    return compression_types;
}

◆ CompressionTypeIsAvailable()

CompressionAvailabilityResult duckdb::CompressionTypeIsAvailable	(	CompressionType	compression_type,
		optional_ptr< StorageManager >	storage_manager
	)

private

Max storage compatibility

Used to signal: always deprecated

Can't determine in this call whether it's available or not, default to available

Minimum required storage version is higher than the current storage version, this method isn't available yet

Maximum supported storage version is lower than the current storage version, this method is no longer available

                                                                                                       {
    vector<CompressionMethodRequirements> candidates({{CompressionType::COMPRESSION_PATAS, optional_idx(), 0},
                                                      {CompressionType::COMPRESSION_CHIMP, optional_idx(), 0},
                                                      {CompressionType::COMPRESSION_DICTIONARY, 0, 4},
                                                      {CompressionType::COMPRESSION_FSST, 0, 4},
                                                      {CompressionType::COMPRESSION_DICT_FSST, 5, optional_idx()}});
 
    optional_idx current_storage_version;
    if (storage_manager && storage_manager->HasStorageVersion()) {
        current_storage_version = storage_manager->GetStorageVersion();
    }
    for (auto &candidate : candidates) {
        auto &type = candidate.type;
        if (type != compression_type) {
            continue;
        }
        auto &min = candidate.minimum_storage_version;
        auto &max = candidate.maximum_storage_version;
 
        if (!min.IsValid()) {
            return CompressionAvailabilityResult::Deprecated();
        }
 
        if (!current_storage_version.IsValid()) {
            return CompressionAvailabilityResult();
        }
 
        auto current_version = current_storage_version.GetIndex();
        D_ASSERT(min.IsValid());
        if (min.GetIndex() > current_version) {
            return CompressionAvailabilityResult::NotAvailableYet();
        }
        if (max.IsValid() && max.GetIndex() < current_version) {
            return CompressionAvailabilityResult::Deprecated();
        }
        return CompressionAvailabilityResult();
    }
    return CompressionAvailabilityResult();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CompressionTypeToString()

string duckdb::CompressionTypeToString ( CompressionType type )

private

                                                     {
    switch (type) {
    case CompressionType::COMPRESSION_AUTO:
        return "Auto";
    case CompressionType::COMPRESSION_UNCOMPRESSED:
        return "Uncompressed";
    case CompressionType::COMPRESSION_CONSTANT:
        return "Constant";
    case CompressionType::COMPRESSION_RLE:
        return "RLE";
    case CompressionType::COMPRESSION_DICTIONARY:
        return "Dictionary";
    case CompressionType::COMPRESSION_PFOR_DELTA:
        return "PFOR";
    case CompressionType::COMPRESSION_BITPACKING:
        return "BitPacking";
    case CompressionType::COMPRESSION_FSST:
        return "FSST";
    case CompressionType::COMPRESSION_CHIMP:
        return "Chimp";
    case CompressionType::COMPRESSION_PATAS:
        return "Patas";
    case CompressionType::COMPRESSION_ZSTD:
        return "ZSTD";
    case CompressionType::COMPRESSION_ALP:
        return "ALP";
    case CompressionType::COMPRESSION_ALPRD:
        return "ALPRD";
    case CompressionType::COMPRESSION_ROARING:
        return "Roaring";
    case CompressionType::COMPRESSION_DICT_FSST:
        return "DICT_FSST";
    case CompressionType::COMPRESSION_EMPTY:
        return "Empty Validity";
    default:
        throw InternalException("Unrecognized compression type!");
    }
}

◆ ExpressionTypeToString()

DUCKDB_API string duckdb::ExpressionTypeToString ( ExpressionType type )

                                                   {
    switch (type) {
    case ExpressionType::OPERATOR_CAST:
        return "CAST";
    case ExpressionType::OPERATOR_NOT:
        return "NOT";
    case ExpressionType::OPERATOR_IS_NULL:
        return "IS_NULL";
    case ExpressionType::OPERATOR_IS_NOT_NULL:
        return "IS_NOT_NULL";
    case ExpressionType::OPERATOR_UNPACK:
        return "UNPACK";
    case ExpressionType::COMPARE_EQUAL:
        return "EQUAL";
    case ExpressionType::COMPARE_NOTEQUAL:
        return "NOTEQUAL";
    case ExpressionType::COMPARE_LESSTHAN:
        return "LESSTHAN";
    case ExpressionType::COMPARE_GREATERTHAN:
        return "GREATERTHAN";
    case ExpressionType::COMPARE_LESSTHANOREQUALTO:
        return "LESSTHANOREQUALTO";
    case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
        return "GREATERTHANOREQUALTO";
    case ExpressionType::COMPARE_IN:
        return "IN";
    case ExpressionType::COMPARE_DISTINCT_FROM:
        return "DISTINCT_FROM";
    case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
        return "NOT_DISTINCT_FROM";
    case ExpressionType::CONJUNCTION_AND:
        return "AND";
    case ExpressionType::CONJUNCTION_OR:
        return "OR";
    case ExpressionType::VALUE_CONSTANT:
        return "CONSTANT";
    case ExpressionType::VALUE_PARAMETER:
        return "PARAMETER";
    case ExpressionType::VALUE_TUPLE:
        return "TUPLE";
    case ExpressionType::VALUE_TUPLE_ADDRESS:
        return "TUPLE_ADDRESS";
    case ExpressionType::VALUE_NULL:
        return "NULL";
    case ExpressionType::VALUE_VECTOR:
        return "VECTOR";
    case ExpressionType::VALUE_SCALAR:
        return "SCALAR";
    case ExpressionType::AGGREGATE:
        return "AGGREGATE";
    case ExpressionType::WINDOW_AGGREGATE:
        return "WINDOW_AGGREGATE";
    case ExpressionType::WINDOW_RANK:
        return "RANK";
    case ExpressionType::WINDOW_RANK_DENSE:
        return "RANK_DENSE";
    case ExpressionType::WINDOW_PERCENT_RANK:
        return "PERCENT_RANK";
    case ExpressionType::WINDOW_ROW_NUMBER:
        return "ROW_NUMBER";
    case ExpressionType::WINDOW_FIRST_VALUE:
        return "FIRST_VALUE";
    case ExpressionType::WINDOW_LAST_VALUE:
        return "LAST_VALUE";
    case ExpressionType::WINDOW_NTH_VALUE:
        return "NTH_VALUE";
    case ExpressionType::WINDOW_CUME_DIST:
        return "CUME_DIST";
    case ExpressionType::WINDOW_LEAD:
        return "LEAD";
    case ExpressionType::WINDOW_LAG:
        return "LAG";
    case ExpressionType::WINDOW_NTILE:
        return "NTILE";
    case ExpressionType::WINDOW_FILL:
        return "FILL";
    case ExpressionType::FUNCTION:
        return "FUNCTION";
    case ExpressionType::CASE_EXPR:
        return "CASE";
    case ExpressionType::OPERATOR_NULLIF:
        return "NULLIF";
    case ExpressionType::OPERATOR_COALESCE:
        return "COALESCE";
    case ExpressionType::OPERATOR_TRY:
        return "TRY";
    case ExpressionType::ARRAY_EXTRACT:
        return "ARRAY_EXTRACT";
    case ExpressionType::ARRAY_SLICE:
        return "ARRAY_SLICE";
    case ExpressionType::STRUCT_EXTRACT:
        return "STRUCT_EXTRACT";
    case ExpressionType::SUBQUERY:
        return "SUBQUERY";
    case ExpressionType::STAR:
        return "STAR";
    case ExpressionType::PLACEHOLDER:
        return "PLACEHOLDER";
    case ExpressionType::COLUMN_REF:
        return "COLUMN_REF";
    case ExpressionType::LAMBDA_REF:
        return "LAMBDA_REF";
    case ExpressionType::FUNCTION_REF:
        return "FUNCTION_REF";
    case ExpressionType::TABLE_REF:
        return "TABLE_REF";
    case ExpressionType::CAST:
        return "CAST";
    case ExpressionType::COMPARE_NOT_IN:
        return "COMPARE_NOT_IN";
    case ExpressionType::COMPARE_BETWEEN:
        return "COMPARE_BETWEEN";
    case ExpressionType::COMPARE_NOT_BETWEEN:
        return "COMPARE_NOT_BETWEEN";
    case ExpressionType::VALUE_DEFAULT:
        return "VALUE_DEFAULT";
    case ExpressionType::BOUND_REF:
        return "BOUND_REF";
    case ExpressionType::BOUND_COLUMN_REF:
        return "BOUND_COLUMN_REF";
    case ExpressionType::BOUND_FUNCTION:
        return "BOUND_FUNCTION";
    case ExpressionType::BOUND_AGGREGATE:
        return "BOUND_AGGREGATE";
    case ExpressionType::GROUPING_FUNCTION:
        return "GROUPING";
    case ExpressionType::ARRAY_CONSTRUCTOR:
        return "ARRAY_CONSTRUCTOR";
    case ExpressionType::TABLE_STAR:
        return "TABLE_STAR";
    case ExpressionType::BOUND_UNNEST:
        return "BOUND_UNNEST";
    case ExpressionType::COLLATE:
        return "COLLATE";
    case ExpressionType::POSITIONAL_REFERENCE:
        return "POSITIONAL_REFERENCE";
    case ExpressionType::BOUND_LAMBDA_REF:
        return "BOUND_LAMBDA_REF";
    case ExpressionType::LAMBDA:
        return "LAMBDA";
    case ExpressionType::ARROW:
        return "ARROW";
    case ExpressionType::TYPE:
        return "TYPE";
    case ExpressionType::BOUND_EXPANDED:
        return "BOUND_EXPANDED";
    case ExpressionType::INVALID:
        break;
    }
    return "INVALID";
}

◆ ExpressionClassToString()

DUCKDB_API string duckdb::ExpressionClassToString ( ExpressionClass type )

                                                     {
    switch (type) {
    case ExpressionClass::INVALID:
        return "INVALID";
    case ExpressionClass::AGGREGATE:
        return "AGGREGATE";
    case ExpressionClass::CASE:
        return "CASE";
    case ExpressionClass::CAST:
        return "CAST";
    case ExpressionClass::COLUMN_REF:
        return "COLUMN_REF";
    case ExpressionClass::LAMBDA_REF:
        return "LAMBDA_REF";
    case ExpressionClass::COMPARISON:
        return "COMPARISON";
    case ExpressionClass::CONJUNCTION:
        return "CONJUNCTION";
    case ExpressionClass::CONSTANT:
        return "CONSTANT";
    case ExpressionClass::DEFAULT:
        return "DEFAULT";
    case ExpressionClass::FUNCTION:
        return "FUNCTION";
    case ExpressionClass::OPERATOR:
        return "OPERATOR";
    case ExpressionClass::STAR:
        return "STAR";
    case ExpressionClass::SUBQUERY:
        return "SUBQUERY";
    case ExpressionClass::WINDOW:
        return "WINDOW";
    case ExpressionClass::PARAMETER:
        return "PARAMETER";
    case ExpressionClass::COLLATE:
        return "COLLATE";
    case ExpressionClass::LAMBDA:
        return "LAMBDA";
    case ExpressionClass::POSITIONAL_REFERENCE:
        return "POSITIONAL_REFERENCE";
    case ExpressionClass::BETWEEN:
        return "BETWEEN";
    case ExpressionClass::TYPE:
        return "TYPE";
    case ExpressionClass::BOUND_AGGREGATE:
        return "BOUND_AGGREGATE";
    case ExpressionClass::BOUND_CASE:
        return "BOUND_CASE";
    case ExpressionClass::BOUND_CAST:
        return "BOUND_CAST";
    case ExpressionClass::BOUND_COLUMN_REF:
        return "BOUND_COLUMN_REF";
    case ExpressionClass::BOUND_COMPARISON:
        return "BOUND_COMPARISON";
    case ExpressionClass::BOUND_CONJUNCTION:
        return "BOUND_CONJUNCTION";
    case ExpressionClass::BOUND_CONSTANT:
        return "BOUND_CONSTANT";
    case ExpressionClass::BOUND_DEFAULT:
        return "BOUND_DEFAULT";
    case ExpressionClass::BOUND_FUNCTION:
        return "BOUND_FUNCTION";
    case ExpressionClass::BOUND_OPERATOR:
        return "BOUND_OPERATOR";
    case ExpressionClass::BOUND_PARAMETER:
        return "BOUND_PARAMETER";
    case ExpressionClass::BOUND_REF:
        return "BOUND_REF";
    case ExpressionClass::BOUND_SUBQUERY:
        return "BOUND_SUBQUERY";
    case ExpressionClass::BOUND_WINDOW:
        return "BOUND_WINDOW";
    case ExpressionClass::BOUND_BETWEEN:
        return "BOUND_BETWEEN";
    case ExpressionClass::BOUND_UNNEST:
        return "BOUND_UNNEST";
    case ExpressionClass::BOUND_LAMBDA:
        return "BOUND_LAMBDA";
    case ExpressionClass::BOUND_EXPRESSION:
        return "BOUND_EXPRESSION";
    case ExpressionClass::BOUND_EXPANDED:
        return "BOUND_EXPANDED";
    default:
        return "ExpressionClass::!!UNIMPLEMENTED_CASE!!";
    }
}

◆ ExpressionTypeToOperator()

string duckdb::ExpressionTypeToOperator ( ExpressionType type )

                                                     {
    switch (type) {
    case ExpressionType::COMPARE_EQUAL:
        return "=";
    case ExpressionType::COMPARE_NOTEQUAL:
        return "!=";
    case ExpressionType::COMPARE_LESSTHAN:
        return "<";
    case ExpressionType::COMPARE_GREATERTHAN:
        return ">";
    case ExpressionType::COMPARE_LESSTHANOREQUALTO:
        return "<=";
    case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
        return ">=";
    case ExpressionType::COMPARE_DISTINCT_FROM:
        return "IS DISTINCT FROM";
    case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
        return "IS NOT DISTINCT FROM";
    case ExpressionType::CONJUNCTION_AND:
        return "AND";
    case ExpressionType::CONJUNCTION_OR:
        return "OR";
    default:
        return "";
    }
}

◆ NegateComparisonExpression()

ExpressionType duckdb::NegateComparisonExpression ( ExpressionType type )

Negate a comparison expression, turning e.g. = into !=, or < into >=.

                                                               {
    ExpressionType negated_type = ExpressionType::INVALID;
    switch (type) {
    case ExpressionType::COMPARE_EQUAL:
        negated_type = ExpressionType::COMPARE_NOTEQUAL;
        break;
    case ExpressionType::COMPARE_NOTEQUAL:
        negated_type = ExpressionType::COMPARE_EQUAL;
        break;
    case ExpressionType::COMPARE_LESSTHAN:
        negated_type = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
        break;
    case ExpressionType::COMPARE_GREATERTHAN:
        negated_type = ExpressionType::COMPARE_LESSTHANOREQUALTO;
        break;
    case ExpressionType::COMPARE_LESSTHANOREQUALTO:
        negated_type = ExpressionType::COMPARE_GREATERTHAN;
        break;
    case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
        negated_type = ExpressionType::COMPARE_LESSTHAN;
        break;
    case ExpressionType::COMPARE_DISTINCT_FROM:
        negated_type = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
        break;
    case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
        negated_type = ExpressionType::COMPARE_DISTINCT_FROM;
        break;
    default:
        throw InternalException("Unsupported comparison type in negation");
    }
    return negated_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FlipComparisonExpression()

ExpressionType duckdb::FlipComparisonExpression ( ExpressionType type )

Flip a comparison expression, turning e.g. < into >, or = into =.

                                                             {
    ExpressionType flipped_type = ExpressionType::INVALID;
    switch (type) {
    case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
    case ExpressionType::COMPARE_DISTINCT_FROM:
    case ExpressionType::COMPARE_NOTEQUAL:
    case ExpressionType::COMPARE_EQUAL:
        flipped_type = type;
        break;
    case ExpressionType::COMPARE_LESSTHAN:
        flipped_type = ExpressionType::COMPARE_GREATERTHAN;
        break;
    case ExpressionType::COMPARE_GREATERTHAN:
        flipped_type = ExpressionType::COMPARE_LESSTHAN;
        break;
    case ExpressionType::COMPARE_LESSTHANOREQUALTO:
        flipped_type = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
        break;
    case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
        flipped_type = ExpressionType::COMPARE_LESSTHANOREQUALTO;
        break;
    default:
        throw InternalException("Unsupported comparison type in flip");
    }
    return flipped_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OperatorToExpressionType()

ExpressionType duckdb::OperatorToExpressionType ( const string & op )

                                                          {
    if (op == "=" || op == "==") {
        return ExpressionType::COMPARE_EQUAL;
    } else if (op == "!=" || op == "<>") {
        return ExpressionType::COMPARE_NOTEQUAL;
    } else if (op == "<") {
        return ExpressionType::COMPARE_LESSTHAN;
    } else if (op == ">") {
        return ExpressionType::COMPARE_GREATERTHAN;
    } else if (op == "<=") {
        return ExpressionType::COMPARE_LESSTHANOREQUALTO;
    } else if (op == ">=") {
        return ExpressionType::COMPARE_GREATERTHANOREQUALTO;
    }
    return ExpressionType::INVALID;
}

◆ FileCompressionTypeFromString()

FileCompressionType duckdb::FileCompressionTypeFromString ( const string & input )

                                                                       {
    auto parameter = StringUtil::Lower(input);
    if (parameter == "infer" || parameter == "auto") {
        return FileCompressionType::AUTO_DETECT;
    } else if (parameter == "gzip") {
        return FileCompressionType::GZIP;
    } else if (parameter == "zstd") {
        return FileCompressionType::ZSTD;
    } else if (parameter == "uncompressed" || parameter == "none" || parameter.empty()) {
        return FileCompressionType::UNCOMPRESSED;
    } else {
        throw ParserException("Unrecognized file compression type \"%s\"", input);
    }
}

◆ CompressionExtensionFromType()

string duckdb::CompressionExtensionFromType ( const FileCompressionType type )

                                                                    {
    switch (type) {
    case FileCompressionType::GZIP:
        return ".gz";
    case FileCompressionType::ZSTD:
        return ".zst";
    default:
        throw NotImplementedException("Compression Extension of file compression type is not implemented");
    }
}

◆ IsFileCompressed()

bool duckdb::IsFileCompressed	(	string	path,
		FileCompressionType	type
	)

                                                             {
    auto extension = CompressionExtensionFromType(type);
    std::size_t question_mark_pos = std::string::npos;
    if (!StringUtil::StartsWith(path, "\\\\?\\")) {
        question_mark_pos = path.find('?');
    }
    path = path.substr(0, question_mark_pos);
    if (StringUtil::EndsWith(path, extension)) {
        return true;
    }
    return false;
}

◆ IsLeftOuterJoin()

bool duckdb::IsLeftOuterJoin ( JoinType type )

True if join is left or full outer join.

                                    {
    return type == JoinType::LEFT || type == JoinType::OUTER;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsRightOuterJoin()

bool duckdb::IsRightOuterJoin ( JoinType type )

True if join is rght or full outer join.

                                     {
    return type == JoinType::OUTER || type == JoinType::RIGHT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PropagatesBuildSide()

bool duckdb::PropagatesBuildSide ( JoinType type )

Whether the build side is propagated out of the join.

                                        {
    return type == JoinType::OUTER || type == JoinType::RIGHT || type == JoinType::RIGHT_ANTI ||
           type == JoinType::RIGHT_SEMI;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasInverseJoinType()

bool duckdb::HasInverseJoinType ( JoinType type )

Whether the JoinType has an inverse.

                                       {
    return type != JoinType::SINGLE && type != JoinType::MARK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InverseJoinType()

JoinType duckdb::InverseJoinType ( JoinType type )

Gets the inverse JoinType, e.g., LEFT -> RIGHT.

                                        {
    D_ASSERT(HasInverseJoinType(type));
    switch (type) {
    case JoinType::LEFT:
        return JoinType::RIGHT;
    case JoinType::RIGHT:
        return JoinType::LEFT;
    case JoinType::INNER:
        return JoinType::INNER;
    case JoinType::OUTER:
        return JoinType::OUTER;
    case JoinType::SEMI:
        return JoinType::RIGHT_SEMI;
    case JoinType::ANTI:
        return JoinType::RIGHT_ANTI;
    case JoinType::RIGHT_SEMI:
        return JoinType::SEMI;
    case JoinType::RIGHT_ANTI:
        return JoinType::ANTI;
    default:
        throw NotImplementedException("InverseJoinType for JoinType::%s", EnumUtil::ToString(type));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ JoinTypeToString()

string duckdb::JoinTypeToString ( JoinType type )

                                       {
    return EnumUtil::ToString(type);
}

◆ LogicalOperatorToString()

DUCKDB_API string duckdb::LogicalOperatorToString ( LogicalOperatorType type )

                                                         {
    switch (type) {
    case LogicalOperatorType::LOGICAL_GET:
        return "GET";
    case LogicalOperatorType::LOGICAL_CHUNK_GET:
        return "CHUNK_GET";
    case LogicalOperatorType::LOGICAL_DELIM_GET:
        return "DELIM_GET";
    case LogicalOperatorType::LOGICAL_EMPTY_RESULT:
        return "EMPTY_RESULT";
    case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
        return "EXPRESSION_GET";
    case LogicalOperatorType::LOGICAL_ANY_JOIN:
        return "ANY_JOIN";
    case LogicalOperatorType::LOGICAL_ASOF_JOIN:
        return "ASOF_JOIN";
    case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN:
        return "DEPENDENT_JOIN";
    case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
        return "COMPARISON_JOIN";
    case LogicalOperatorType::LOGICAL_DELIM_JOIN:
        return "DELIM_JOIN";
    case LogicalOperatorType::LOGICAL_PROJECTION:
        return "PROJECTION";
    case LogicalOperatorType::LOGICAL_FILTER:
        return "FILTER";
    case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
        return "AGGREGATE";
    case LogicalOperatorType::LOGICAL_WINDOW:
        return "WINDOW";
    case LogicalOperatorType::LOGICAL_UNNEST:
        return "UNNEST";
    case LogicalOperatorType::LOGICAL_LIMIT:
        return "LIMIT";
    case LogicalOperatorType::LOGICAL_ORDER_BY:
        return "ORDER_BY";
    case LogicalOperatorType::LOGICAL_TOP_N:
        return "TOP_N";
    case LogicalOperatorType::LOGICAL_SAMPLE:
        return "SAMPLE";
    case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
        return "COPY_TO_FILE";
    case LogicalOperatorType::LOGICAL_COPY_DATABASE:
        return "COPY_DATABASE";
    case LogicalOperatorType::LOGICAL_JOIN:
        return "JOIN";
    case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
        return "CROSS_PRODUCT";
    case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
        return "POSITIONAL_JOIN";
    case LogicalOperatorType::LOGICAL_UNION:
        return "UNION";
    case LogicalOperatorType::LOGICAL_EXCEPT:
        return "EXCEPT";
    case LogicalOperatorType::LOGICAL_INTERSECT:
        return "INTERSECT";
    case LogicalOperatorType::LOGICAL_INSERT:
        return "INSERT";
    case LogicalOperatorType::LOGICAL_DISTINCT:
        return "DISTINCT";
    case LogicalOperatorType::LOGICAL_DELETE:
        return "DELETE";
    case LogicalOperatorType::LOGICAL_UPDATE:
        return "UPDATE";
    case LogicalOperatorType::LOGICAL_MERGE_INTO:
        return "MERGE_INTO";
    case LogicalOperatorType::LOGICAL_PREPARE:
        return "PREPARE";
    case LogicalOperatorType::LOGICAL_DUMMY_SCAN:
        return "DUMMY_SCAN";
    case LogicalOperatorType::LOGICAL_CREATE_INDEX:
        return "CREATE_INDEX";
    case LogicalOperatorType::LOGICAL_CREATE_TABLE:
        return "CREATE_TABLE";
    case LogicalOperatorType::LOGICAL_CREATE_MACRO:
        return "CREATE_MACRO";
    case LogicalOperatorType::LOGICAL_EXPLAIN:
        return "EXPLAIN";
    case LogicalOperatorType::LOGICAL_EXECUTE:
        return "EXECUTE";
    case LogicalOperatorType::LOGICAL_VACUUM:
        return "VACUUM";
    case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
        return "REC_CTE";
    case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
        return "CTE";
    case LogicalOperatorType::LOGICAL_CTE_REF:
        return "CTE_SCAN";
    case LogicalOperatorType::LOGICAL_ALTER:
        return "ALTER";
    case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
        return "CREATE_SEQUENCE";
    case LogicalOperatorType::LOGICAL_CREATE_TYPE:
        return "CREATE_TYPE";
    case LogicalOperatorType::LOGICAL_CREATE_VIEW:
        return "CREATE_VIEW";
    case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
        return "CREATE_SCHEMA";
    case LogicalOperatorType::LOGICAL_CREATE_SECRET:
        return "CREATE_SECRET";
    case LogicalOperatorType::LOGICAL_ATTACH:
        return "ATTACH";
    case LogicalOperatorType::LOGICAL_DETACH:
        return "DETACH";
    case LogicalOperatorType::LOGICAL_DROP:
        return "DROP";
    case LogicalOperatorType::LOGICAL_PRAGMA:
        return "PRAGMA";
    case LogicalOperatorType::LOGICAL_TRANSACTION:
        return "TRANSACTION";
    case LogicalOperatorType::LOGICAL_EXPORT:
        return "EXPORT";
    case LogicalOperatorType::LOGICAL_SET:
        return "SET";
    case LogicalOperatorType::LOGICAL_RESET:
        return "RESET";
    case LogicalOperatorType::LOGICAL_LOAD:
        return "LOAD";
    case LogicalOperatorType::LOGICAL_INVALID:
        break;
    case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
        return "CUSTOM_OP";
    case LogicalOperatorType::LOGICAL_PIVOT:
        return "PIVOT";
    case LogicalOperatorType::LOGICAL_UPDATE_EXTENSIONS:
        return "UPDATE_EXTENSIONS";
    }
    return "INVALID";
}

◆ OptimizerTypeToString()

string duckdb::OptimizerTypeToString ( OptimizerType type )

private

                                                 {
    for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
        if (internal_optimizer_types[i].type == type) {
            return internal_optimizer_types[i].name;
        }
    }
    throw InternalException("Invalid optimizer type");
}

◆ ListAllOptimizers()

vector< string > duckdb::ListAllOptimizers ( )

private

                                   {
    vector<string> result;
    for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
        result.push_back(internal_optimizer_types[i].name);
    }
    return result;
}

◆ OptimizerTypeFromString()

OptimizerType duckdb::OptimizerTypeFromString ( const string & str )

private

                                                         {
    for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
        if (internal_optimizer_types[i].name == str) {
            return internal_optimizer_types[i].type;
        }
    }
    // optimizer not found, construct candidate list
    vector<string> optimizer_names;
    for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
        optimizer_names.emplace_back(internal_optimizer_types[i].name);
    }
    throw ParserException("Optimizer type \"%s\" not recognized\n%s", str,
                          StringUtil::CandidatesErrorMessage(optimizer_names, str, "Candidate optimizers"));
}

◆ PhysicalOperatorToString()

string duckdb::PhysicalOperatorToString ( PhysicalOperatorType type )

                                                           {
    switch (type) {
    case PhysicalOperatorType::TABLE_SCAN:
        return "TABLE_SCAN";
    case PhysicalOperatorType::DUMMY_SCAN:
        return "DUMMY_SCAN";
    case PhysicalOperatorType::CHUNK_SCAN:
        return "CHUNK_SCAN";
    case PhysicalOperatorType::COLUMN_DATA_SCAN:
        return "COLUMN_DATA_SCAN";
    case PhysicalOperatorType::DELIM_SCAN:
        return "DELIM_SCAN";
    case PhysicalOperatorType::ORDER_BY:
        return "ORDER_BY";
    case PhysicalOperatorType::LIMIT:
        return "LIMIT";
    case PhysicalOperatorType::LIMIT_PERCENT:
        return "LIMIT_PERCENT";
    case PhysicalOperatorType::STREAMING_LIMIT:
        return "STREAMING_LIMIT";
    case PhysicalOperatorType::RESERVOIR_SAMPLE:
        return "RESERVOIR_SAMPLE";
    case PhysicalOperatorType::STREAMING_SAMPLE:
        return "STREAMING_SAMPLE";
    case PhysicalOperatorType::TOP_N:
        return "TOP_N";
    case PhysicalOperatorType::WINDOW:
        return "WINDOW";
    case PhysicalOperatorType::STREAMING_WINDOW:
        return "STREAMING_WINDOW";
    case PhysicalOperatorType::UNNEST:
        return "UNNEST";
    case PhysicalOperatorType::UNGROUPED_AGGREGATE:
        return "UNGROUPED_AGGREGATE";
    case PhysicalOperatorType::HASH_GROUP_BY:
        return "HASH_GROUP_BY";
    case PhysicalOperatorType::PERFECT_HASH_GROUP_BY:
        return "PERFECT_HASH_GROUP_BY";
    case PhysicalOperatorType::PARTITIONED_AGGREGATE:
        return "PARTITIONED_AGGREGATE";
    case PhysicalOperatorType::FILTER:
        return "FILTER";
    case PhysicalOperatorType::PROJECTION:
        return "PROJECTION";
    case PhysicalOperatorType::COPY_TO_FILE:
        return "COPY_TO_FILE";
    case PhysicalOperatorType::BATCH_COPY_TO_FILE:
        return "BATCH_COPY_TO_FILE";
    case PhysicalOperatorType::LEFT_DELIM_JOIN:
        return "LEFT_DELIM_JOIN";
    case PhysicalOperatorType::RIGHT_DELIM_JOIN:
        return "RIGHT_DELIM_JOIN";
    case PhysicalOperatorType::BLOCKWISE_NL_JOIN:
        return "BLOCKWISE_NL_JOIN";
    case PhysicalOperatorType::NESTED_LOOP_JOIN:
        return "NESTED_LOOP_JOIN";
    case PhysicalOperatorType::HASH_JOIN:
        return "HASH_JOIN";
    case PhysicalOperatorType::PIECEWISE_MERGE_JOIN:
        return "PIECEWISE_MERGE_JOIN";
    case PhysicalOperatorType::IE_JOIN:
        return "IE_JOIN";
    case PhysicalOperatorType::ASOF_JOIN:
        return "ASOF_JOIN";
    case PhysicalOperatorType::CROSS_PRODUCT:
        return "CROSS_PRODUCT";
    case PhysicalOperatorType::POSITIONAL_JOIN:
        return "POSITIONAL_JOIN";
    case PhysicalOperatorType::POSITIONAL_SCAN:
        return "POSITIONAL_SCAN";
    case PhysicalOperatorType::UNION:
        return "UNION";
    case PhysicalOperatorType::INSERT:
        return "INSERT";
    case PhysicalOperatorType::BATCH_INSERT:
        return "BATCH_INSERT";
    case PhysicalOperatorType::DELETE_OPERATOR:
        return "DELETE";
    case PhysicalOperatorType::UPDATE:
        return "UPDATE";
    case PhysicalOperatorType::MERGE_INTO:
        return "MERGE_INTO";
    case PhysicalOperatorType::EMPTY_RESULT:
        return "EMPTY_RESULT";
    case PhysicalOperatorType::CREATE_TABLE:
        return "CREATE_TABLE";
    case PhysicalOperatorType::CREATE_TABLE_AS:
        return "CREATE_TABLE_AS";
    case PhysicalOperatorType::BATCH_CREATE_TABLE_AS:
        return "BATCH_CREATE_TABLE_AS";
    case PhysicalOperatorType::CREATE_INDEX:
        return "CREATE_INDEX";
    case PhysicalOperatorType::EXPLAIN:
        return "EXPLAIN";
    case PhysicalOperatorType::EXPLAIN_ANALYZE:
        return "EXPLAIN_ANALYZE";
    case PhysicalOperatorType::EXECUTE:
        return "EXECUTE";
    case PhysicalOperatorType::VACUUM:
        return "VACUUM";
    case PhysicalOperatorType::RECURSIVE_CTE:
        return "REC_CTE";
    case PhysicalOperatorType::RECURSIVE_KEY_CTE:
        return "REC_KEY_CTE";
    case PhysicalOperatorType::CTE:
        return "CTE";
    case PhysicalOperatorType::RECURSIVE_CTE_SCAN:
        return "REC_CTE_SCAN";
    case PhysicalOperatorType::RECURSIVE_RECURRING_CTE_SCAN:
        return "REC_REC_CTE_SCAN";
    case PhysicalOperatorType::CTE_SCAN:
        return "CTE_SCAN";
    case PhysicalOperatorType::EXPRESSION_SCAN:
        return "EXPRESSION_SCAN";
    case PhysicalOperatorType::ALTER:
        return "ALTER";
    case PhysicalOperatorType::CREATE_SEQUENCE:
        return "CREATE_SEQUENCE";
    case PhysicalOperatorType::CREATE_VIEW:
        return "CREATE_VIEW";
    case PhysicalOperatorType::CREATE_SCHEMA:
        return "CREATE_SCHEMA";
    case PhysicalOperatorType::CREATE_MACRO:
        return "CREATE_MACRO";
    case PhysicalOperatorType::CREATE_SECRET:
        return "CREATE_SECRET";
    case PhysicalOperatorType::DROP:
        return "DROP";
    case PhysicalOperatorType::PRAGMA:
        return "PRAGMA";
    case PhysicalOperatorType::TRANSACTION:
        return "TRANSACTION";
    case PhysicalOperatorType::PREPARE:
        return "PREPARE";
    case PhysicalOperatorType::EXPORT:
        return "EXPORT";
    case PhysicalOperatorType::SET:
        return "SET";
    case PhysicalOperatorType::SET_VARIABLE:
        return "SET_VARIABLE";
    case PhysicalOperatorType::RESET:
        return "RESET";
    case PhysicalOperatorType::LOAD:
        return "LOAD";
    case PhysicalOperatorType::INOUT_FUNCTION:
        return "INOUT_FUNCTION";
    case PhysicalOperatorType::CREATE_TYPE:
        return "CREATE_TYPE";
    case PhysicalOperatorType::ATTACH:
        return "ATTACH";
    case PhysicalOperatorType::DETACH:
        return "DETACH";
    case PhysicalOperatorType::RESULT_COLLECTOR:
        return "RESULT_COLLECTOR";
    case PhysicalOperatorType::EXTENSION:
        return "EXTENSION";
    case PhysicalOperatorType::PIVOT:
        return "PIVOT";
    case PhysicalOperatorType::COPY_DATABASE:
        return "COPY_DATABASE";
    case PhysicalOperatorType::VERIFY_VECTOR:
        return "VERIFY_VECTOR";
    case PhysicalOperatorType::UPDATE_EXTENSIONS:
        return "UPDATE_EXTENSIONS";
    case PhysicalOperatorType::INVALID:
        break;
    }
    return "INVALID";
}

◆ RelationTypeToString()

string duckdb::RelationTypeToString ( RelationType type )

                                               {
    switch (type) {
    case RelationType::TABLE_RELATION:
        return "TABLE_RELATION";
    case RelationType::DELIM_GET_RELATION:
        return "DELIM_GET_RELATION";
    case RelationType::DELIM_JOIN_RELATION:
        return "DELIM_JOIN_RELATION";
    case RelationType::PROJECTION_RELATION:
        return "PROJECTION_RELATION";
    case RelationType::FILTER_RELATION:
        return "FILTER_RELATION";
    case RelationType::EXPLAIN_RELATION:
        return "EXPLAIN_RELATION";
    case RelationType::CROSS_PRODUCT_RELATION:
        return "CROSS_PRODUCT_RELATION";
    case RelationType::JOIN_RELATION:
        return "JOIN_RELATION";
    case RelationType::AGGREGATE_RELATION:
        return "AGGREGATE_RELATION";
    case RelationType::SET_OPERATION_RELATION:
        return "SET_OPERATION_RELATION";
    case RelationType::DISTINCT_RELATION:
        return "DISTINCT_RELATION";
    case RelationType::LIMIT_RELATION:
        return "LIMIT_RELATION";
    case RelationType::ORDER_RELATION:
        return "ORDER_RELATION";
    case RelationType::CREATE_VIEW_RELATION:
        return "CREATE_VIEW_RELATION";
    case RelationType::CREATE_TABLE_RELATION:
        return "CREATE_TABLE_RELATION";
    case RelationType::INSERT_RELATION:
        return "INSERT_RELATION";
    case RelationType::VALUE_LIST_RELATION:
        return "VALUE_LIST_RELATION";
    case RelationType::MATERIALIZED_RELATION:
        return "MATERIALIZED_RELATION";
    case RelationType::DELETE_RELATION:
        return "DELETE_RELATION";
    case RelationType::UPDATE_RELATION:
        return "UPDATE_RELATION";
    case RelationType::WRITE_CSV_RELATION:
        return "WRITE_CSV_RELATION";
    case RelationType::WRITE_PARQUET_RELATION:
        return "WRITE_PARQUET_RELATION";
    case RelationType::READ_CSV_RELATION:
        return "READ_CSV_RELATION";
    case RelationType::SUBQUERY_RELATION:
        return "SUBQUERY_RELATION";
    case RelationType::TABLE_FUNCTION_RELATION:
        return "TABLE_FUNCTION_RELATION";
    case RelationType::VIEW_RELATION:
        return "VIEW_RELATION";
    case RelationType::QUERY_RELATION:
        return "QUERY_RELATION";
    case RelationType::EXTENSION_RELATION:
        return "EXTENSION_RELATION";
    case RelationType::INVALID_RELATION:
        break;
    }
    return "INVALID_RELATION";
}

◆ StatementTypeToString()

DUCKDB_API string duckdb::StatementTypeToString ( StatementType type )

                                                 {
    switch (type) {
    case StatementType::SELECT_STATEMENT:
        return "SELECT";
    case StatementType::INSERT_STATEMENT:
        return "INSERT";
    case StatementType::UPDATE_STATEMENT:
        return "UPDATE";
    case StatementType::DELETE_STATEMENT:
        return "DELETE";
    case StatementType::PREPARE_STATEMENT:
        return "PREPARE";
    case StatementType::EXECUTE_STATEMENT:
        return "EXECUTE";
    case StatementType::ALTER_STATEMENT:
        return "ALTER";
    case StatementType::TRANSACTION_STATEMENT:
        return "TRANSACTION";
    case StatementType::COPY_STATEMENT:
        return "COPY";
    case StatementType::COPY_DATABASE_STATEMENT:
        return "COPY_DATABASE";
    case StatementType::ANALYZE_STATEMENT:
        return "ANALYZE";
    case StatementType::VARIABLE_SET_STATEMENT:
        return "VARIABLE_SET";
    case StatementType::CREATE_FUNC_STATEMENT:
        return "CREATE_FUNC";
    case StatementType::EXPLAIN_STATEMENT:
        return "EXPLAIN";
    case StatementType::CREATE_STATEMENT:
        return "CREATE";
    case StatementType::DROP_STATEMENT:
        return "DROP";
    case StatementType::PRAGMA_STATEMENT:
        return "PRAGMA";
    case StatementType::VACUUM_STATEMENT:
        return "VACUUM";
    case StatementType::RELATION_STATEMENT:
        return "RELATION";
    case StatementType::EXPORT_STATEMENT:
        return "EXPORT";
    case StatementType::CALL_STATEMENT:
        return "CALL";
    case StatementType::SET_STATEMENT:
        return "SET";
    case StatementType::LOAD_STATEMENT:
        return "LOAD";
    case StatementType::EXTENSION_STATEMENT:
        return "EXTENSION";
    case StatementType::LOGICAL_PLAN_STATEMENT:
        return "LOGICAL_PLAN";
    case StatementType::ATTACH_STATEMENT:
        return "ATTACH";
    case StatementType::DETACH_STATEMENT:
        return "DETACH";
    case StatementType::MULTI_STATEMENT:
        return "MULTI";
    case StatementType::UPDATE_EXTENSIONS_STATEMENT:
        return "UPDATE_EXTENSIONS";
    case StatementType::MERGE_INTO_STATEMENT:
        return "MERGE_INTO";
    case StatementType::INVALID_STATEMENT:
        break;
    }
    return "INVALID";
}

◆ StatementReturnTypeToString()

string duckdb::StatementReturnTypeToString ( StatementReturnType type )

                                                             {
    switch (type) {
    case StatementReturnType::QUERY_RESULT:
        return "QUERY_RESULT";
    case StatementReturnType::CHANGED_ROWS:
        return "CHANGED_ROWS";
    case StatementReturnType::NOTHING:
        return "NOTHING";
    }
    return "INVALID";
}

◆ TemplatedGetPos()

template<class T >

int64_t duckdb::TemplatedGetPos	(	const string_map_t< T > &	map,
		const string_t &	key
	)

private

                                                                         {
    auto it = map.find(key);
    if (it == map.end()) {
        return -1;
    }
    return it->second;
}

◆ PathMatched()

bool duckdb::PathMatched	(	const string &	path,
		const string &	sub_path
	)

                                                             {
    return path.rfind(sub_path, 0) == 0;
}

◆ GetFileUrlOffset()

static idx_t duckdb::GetFileUrlOffset ( const string & path )

static

                                                  {
    if (!StringUtil::StartsWith(path, "file:/")) {
        return 0;
    }
 
    // Url without host: file:/some/path
    if (path[6] != '/') {
#ifdef _WIN32
        return 6;
#else
        return 5;
#endif
    }
 
    // Url with empty host: file:///some/path
    if (path[7] == '/') {
#ifdef _WIN32
        return 8;
#else
        return 7;
#endif
    }
 
    // Url with localhost: file://localhost/some/path
    if (path.compare(7, 10, "localhost/") == 0) {
#ifdef _WIN32
        return 17;
#else
        return 16;
#endif
    }
 
    // unkown file:/ url format
    return 0;
}

◆ SupportsLegacyFilenamePattern()

bool duckdb::SupportsLegacyFilenamePattern ( const vector< FileNameSegment > & segments )

                                                                            {
    idx_t non_literal_count = 0;
    for (auto &segment : segments) {
        if (segment.type == FileNameSegmentType::UUID_V7) {
            // UUID v7 is not supported in legacy mode
            return false;
        }
        if (segment.type != FileNameSegmentType::LITERAL) {
            non_literal_count++;
        }
    }
    if (non_literal_count != 1) {
        // legacy mode requires exactly one non-literal
        return false;
    }
    return true;
}

◆ GetLegacyFilenamePattern()

LegacyFilenamePattern duckdb::GetLegacyFilenamePattern ( const vector< FileNameSegment > & segments )

                                                                                        {
    LegacyFilenamePattern pattern;
    // construct the base + pos
    for (auto &segment : segments) {
        if (segment.type == FileNameSegmentType::LITERAL) {
            // add the literal to the base
            pattern.base += segment.data;
        } else {
            // non-literal: set the position to the current location
            pattern.pos = pattern.base.size();
        }
    }
    return pattern;
}

◆ GZipConsumeString()

static idx_t duckdb::GZipConsumeString	(	QueryContext	context,
		FileHandle &	input
	)

staticprivate

                                                                        {
    idx_t size = 1; // terminator
    char buffer[1];
    while (input.Read(context, buffer, 1) == 1) {
        if (buffer[0] == '\0') {
            break;
        }
        size++;
    }
    return size;
}

◆ GetKnownColumnValues()

static unordered_map< column_t, PartitioningColumnValue > duckdb::GetKnownColumnValues	(	const string &	filename,
		const HivePartitioningFilterInfo &	filter_info
	)

static

                                                                                            {
    unordered_map<column_t, PartitioningColumnValue> result;
 
    auto &column_map = filter_info.column_map;
    if (filter_info.filename_enabled) {
        auto lookup_column_id = column_map.find("filename");
        if (lookup_column_id != column_map.end()) {
            result.insert(make_pair(lookup_column_id->second, PartitioningColumnValue(filename)));
        }
    }
 
    if (filter_info.hive_enabled) {
        auto partitions = HivePartitioning::Parse(filename);
        for (auto &partition : partitions) {
            auto lookup_column_id = column_map.find(partition.first);
            if (lookup_column_id != column_map.end()) {
                result.insert(
                    make_pair(lookup_column_id->second, PartitioningColumnValue(partition.first, partition.second)));
            }
        }
    }
 
    return result;
}

◆ ConvertKnownColRefToConstants()

static void duckdb::ConvertKnownColRefToConstants	(	ClientContext &	context,
		unique_ptr< Expression > &	expr,
		const unordered_map< column_t, PartitioningColumnValue > &	known_column_values,
		idx_t	table_index
	)

static

                                                             {
    if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
        auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
 
        // This bound column ref is for another table
        if (table_index != bound_colref.binding.table_index) {
            return;
        }
 
        auto lookup = known_column_values.find(bound_colref.binding.column_index);
        if (lookup != known_column_values.end()) {
            auto &partition_val = lookup->second;
            Value result_val;
            if (partition_val.key.empty()) {
                // filename column - use directly
                result_val = Value(partition_val.value);
            } else {
                // hive partitioning column - cast the value to the target type
                result_val = HivePartitioning::GetValue(context, partition_val.key, partition_val.value,
                                                        bound_colref.return_type);
            }
            expr = make_uniq<BoundConstantExpression>(std::move(result_val));
        }
    } else {
        ExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<Expression> &child) {
            ConvertKnownColRefToConstants(context, child, known_column_values, table_index);
        });
    }
}

◆ GetHiveKeyValue() [1/2]

template<class T >

static Value duckdb::GetHiveKeyValue ( const T & val )

inlinestatic

                                                  {
    return Value::CreateValue<T>(val);
}

◆ GetHiveKeyValue() [2/2]

template<class T >

static Value duckdb::GetHiveKeyValue	(	const T &	val,
		const LogicalType &	type
	)

inlinestatic

                                                                           {
    auto result = GetHiveKeyValue(val);
    result.Reinterpret(type);
    return result;
}

◆ GetHiveKeyNullValue()

static Value duckdb::GetHiveKeyNullValue ( const LogicalType & type )

inlinestatic

                                                                 {
    Value result;
    result.Reinterpret(type);
    return result;
}

◆ TemplatedGetHivePartitionValues()

template<class T >

static void duckdb::TemplatedGetHivePartitionValues	(	Vector &	input,
		vector< HivePartitionKey > &	keys,
		const idx_t	col_idx,
		const idx_t	count
	)

static

                                                               {
    UnifiedVectorFormat format;
    input.ToUnifiedFormat(count, format);
 
    const auto &sel = *format.sel;
    const auto data = UnifiedVectorFormat::GetData<T>(format);
    const auto &validity = format.validity;
 
    const auto &type = input.GetType();
 
    for (idx_t i = 0; i < count; i++) {
        auto &key = keys[i];
        const auto idx = sel.get_index(i);
        if (validity.RowIsValid(idx)) {
            key.values[col_idx] = GetHiveKeyValue(data[idx], type);
        } else {
            key.values[col_idx] = GetHiveKeyNullValue(type);
        }
    }
}

◆ GetNestedHivePartitionValues()

static void duckdb::GetNestedHivePartitionValues	(	Vector &	input,
		vector< HivePartitionKey > &	keys,
		const idx_t	col_idx,
		const idx_t	count
	)

static

                                                            {
    for (idx_t i = 0; i < count; i++) {
        auto &key = keys[i];
        key.values[col_idx] = input.GetValue(i);
    }
}

◆ GetHivePartitionValuesTypeSwitch()

static void duckdb::GetHivePartitionValuesTypeSwitch	(	Vector &	input,
		vector< HivePartitionKey > &	keys,
		const idx_t	col_idx,
		const idx_t	count
	)

static

                                                                {
    const auto &type = input.GetType();
    switch (type.InternalType()) {
    case PhysicalType::BOOL:
        TemplatedGetHivePartitionValues<bool>(input, keys, col_idx, count);
        break;
    case PhysicalType::INT8:
        TemplatedGetHivePartitionValues<int8_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::INT16:
        TemplatedGetHivePartitionValues<int16_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::INT32:
        TemplatedGetHivePartitionValues<int32_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::INT64:
        TemplatedGetHivePartitionValues<int64_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::INT128:
        TemplatedGetHivePartitionValues<hugeint_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::UINT8:
        TemplatedGetHivePartitionValues<uint8_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::UINT16:
        TemplatedGetHivePartitionValues<uint16_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::UINT32:
        TemplatedGetHivePartitionValues<uint32_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::UINT64:
        TemplatedGetHivePartitionValues<uint64_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::UINT128:
        TemplatedGetHivePartitionValues<uhugeint_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::FLOAT:
        TemplatedGetHivePartitionValues<float>(input, keys, col_idx, count);
        break;
    case PhysicalType::DOUBLE:
        TemplatedGetHivePartitionValues<double>(input, keys, col_idx, count);
        break;
    case PhysicalType::INTERVAL:
        TemplatedGetHivePartitionValues<interval_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::VARCHAR:
        TemplatedGetHivePartitionValues<string_t>(input, keys, col_idx, count);
        break;
    case PhysicalType::STRUCT:
    case PhysicalType::LIST:
        GetNestedHivePartitionValues(input, keys, col_idx, count);
        break;
    default:
        throw InternalException("Unsupported type for HivePartitionedColumnData::ComputePartitionIndices");
    }
}

◆ IsCharacter()

static bool duckdb::IsCharacter ( char c )

inlinestaticprivate

                                       {
    return (c & 0xc0) != 0x80;
}

◆ Length()

template<class TA , class TR >

static TR duckdb::Length ( TA input )

inlinestaticprivate

                                  {
    auto input_data = input.GetData();
    auto input_length = input.GetSize();
    TR length = 0;
    for (idx_t i = 0; i < input_length; i++) {
        length += IsCharacter(input_data[i]);
    }
    return length;
}

◆ GraphemeCount()

template<class TA , class TR >

static TR duckdb::GraphemeCount ( TA input )

inlinestaticprivate

                                         {
    auto input_data = input.GetData();
    auto input_length = input.GetSize();
    for (idx_t i = 0; i < input_length; i++) {
        if (input_data[i] & 0x80) {
            // non-ascii character: use grapheme iterator on remainder of string
            return UnsafeNumericCast<TR>(Utf8Proc::GraphemeCount(input_data, input_length));
        }
    }
    return UnsafeNumericCast<TR>(input_length);
}

◆ StatsInternal()

static FileMetadata duckdb::StatsInternal	(	int	fd,
		const string &	path
	)

staticprivate

                                                              {
    struct stat s;
    if (fstat(fd, &s) == -1) {
        throw IOException({{"errno", std::to_string(errno)}}, "Failed to get stats for file \"%s\": %s", path,
                          strerror(errno));
    }
 
    FileMetadata file_metadata;
    file_metadata.file_size = s.st_size;
    file_metadata.last_modification_time = Timestamp::FromEpochSeconds(s.st_mtime);
 
    switch (s.st_mode & S_IFMT) {
    case S_IFBLK:
        file_metadata.file_type = FileType::FILE_TYPE_BLOCKDEV;
        break;
    case S_IFCHR:
        file_metadata.file_type = FileType::FILE_TYPE_CHARDEV;
        break;
    case S_IFIFO:
        file_metadata.file_type = FileType::FILE_TYPE_FIFO;
        break;
    case S_IFDIR:
        file_metadata.file_type = FileType::FILE_TYPE_DIR;
        break;
    case S_IFLNK:
        file_metadata.file_type = FileType::FILE_TYPE_LINK;
        break;
    case S_IFREG:
        file_metadata.file_type = FileType::FILE_TYPE_REGULAR;
        break;
    case S_IFSOCK:
        file_metadata.file_type = FileType::FILE_TYPE_SOCKET;
        break;
    default:
        file_metadata.file_type = FileType::FILE_TYPE_INVALID;
        break;
    }
 
    return file_metadata;
} // LCOV_EXCL_STOP

◆ AdditionalProcessInfo()

static string duckdb::AdditionalProcessInfo	(	FileSystem &	fs,
		pid_t	pid
	)

staticprivate

                                                               {
    return "";
}

◆ RemoveDirectoryRecursive()

int duckdb::RemoveDirectoryRecursive ( const char * path )

private

                                               {
    DIR *d = opendir(path);
    idx_t path_len = (idx_t)strlen(path);
    int r = -1;
 
    if (d) {
        struct dirent *p;
        r = 0;
        while (!r && (p = readdir(d))) {
            int r2 = -1;
            char *buf;
            idx_t len;
            /* Skip the names "." and ".." as we don't want to recurse on them. */
            if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, "..")) {
                continue;
            }
            len = path_len + (idx_t)strlen(p->d_name) + 2;
            buf = new (std::nothrow) char[len];
            if (buf) {
                struct stat statbuf;
                snprintf(buf, len, "%s/%s", path, p->d_name);
                if (!stat(buf, &statbuf)) {
                    if (S_ISDIR(statbuf.st_mode)) {
                        r2 = RemoveDirectoryRecursive(buf);
                    } else {
                        r2 = unlink(buf);
                    }
                }
                delete[] buf;
            }
            r = r2;
        }
        closedir(d);
    }
    if (!r) {
        r = rmdir(path);
    }
    return r;
}

◆ GetPosixVersionTag()

string duckdb::GetPosixVersionTag ( struct stat s )

private

                                         {
    // dev/ino should be enough, but to guard against in-place writes we also add file size and modification time
    uint64_t version_tag[4];
    Store(UnsafeNumericCast<uint64_t>(s.st_dev), data_ptr_cast(&version_tag[0]));
    Store(UnsafeNumericCast<uint64_t>(s.st_ino), data_ptr_cast(&version_tag[1]));
    Store(UnsafeNumericCast<uint64_t>(s.st_size), data_ptr_cast(&version_tag[2]));
    Store(Timestamp::FromEpochSeconds(s.st_mtime).value, data_ptr_cast(&version_tag[3]));
 
    return string(char_ptr_cast(version_tag), sizeof(uint64_t) * 4);
}

◆ IsCrawl()

static bool duckdb::IsCrawl ( const string & glob )

staticprivate

                                        {
    // glob must match exactly
    return glob == "**";
}

◆ IsSymbolicLink()

static bool duckdb::IsSymbolicLink ( const string & path )

staticprivate

                                               {
#ifndef _WIN32
    struct stat status;
    return (lstat(path.c_str(), &status) != -1 && S_ISLNK(status.st_mode));
#else
    auto unicode_path = ConvertPathToUnicode(path);
    auto attributes = WindowsGetFileAttributes(unicode_path);
    if (attributes == INVALID_FILE_ATTRIBUTES) {
        return false;
    }
    return attributes & FILE_ATTRIBUTE_REPARSE_POINT;
#endif
}

◆ HasMultipleCrawl()

static bool duckdb::HasMultipleCrawl ( const vector< PathSplit > & splits )

staticprivate

                                                              {
    idx_t crawl_count = 0;
    for (auto &split : splits) {
        if (split.path == "**") {
            crawl_count++;
        }
    }
    return crawl_count > 1;
}

◆ CrawlDirectoryLevel()

static void duckdb::CrawlDirectoryLevel	(	FileSystem &	fs,
		const string &	path,
		optional_ptr< vector< OpenFileInfo > >	files,
		std::priority_queue< ExpandDirectory > &	directories,
		idx_t	split_index
	)

staticprivate

                                                                                                    {
    fs.ListFiles(path, [&](OpenFileInfo &info) {
        info.path = fs.JoinPath(path, info.path);
        if (IsSymbolicLink(info.path)) {
            return;
        }
        bool is_directory = FileSystem::IsDirectory(info);
        if (is_directory) {
            directories.emplace(std::move(info.path), split_index);
        } else if (files) {
            files->push_back(std::move(info));
        }
    });
}

◆ GlobFilesInternal()

static void duckdb::GlobFilesInternal	(	FileSystem &	fs,
		const string &	path,
		const string &	glob,
		bool	match_directory,
		vector< OpenFileInfo > &	result
	)

staticprivate

                                                            {
    fs.ListFiles(path, [&](OpenFileInfo &info) {
        bool is_directory = FileSystem::IsDirectory(info);
        if (is_directory != match_directory) {
            return;
        }
        if (Glob(info.path.c_str(), info.path.size(), glob.c_str(), glob.size())) {
            info.path = fs.JoinPath(path, info.path);
            result.push_back(std::move(info));
        }
    });
}

◆ data_ptr_cast()

template<class SRC >

data_ptr_t duckdb::data_ptr_cast ( SRC * src )

                                   { // NOLINT: naming
    return reinterpret_cast<data_ptr_t>(src);
}

◆ const_data_ptr_cast()

template<class SRC >

const_data_ptr_t duckdb::const_data_ptr_cast ( const SRC * src )

                                                     { // NOLINT: naming
    return reinterpret_cast<const_data_ptr_t>(src);
}

◆ char_ptr_cast()

template<class SRC >

char * duckdb::char_ptr_cast ( SRC * src )

                              { // NOLINT: naming
    return reinterpret_cast<char *>(src);
}

◆ const_char_ptr_cast()

template<class SRC >

const char * duckdb::const_char_ptr_cast ( const SRC * src )

                                                { // NOLINT: naming
    return reinterpret_cast<const char *>(src);
}

◆ const_uchar_ptr_cast()

template<class SRC >

const unsigned char * duckdb::const_uchar_ptr_cast ( const SRC * src )

                                                          { // NOLINT: naming
    return reinterpret_cast<const unsigned char *>(src);
}

◆ CastPointerToValue()

template<class SRC >

uintptr_t duckdb::CastPointerToValue ( SRC * src )

                                       {
    return reinterpret_cast<uintptr_t>(src);
}

◆ cast_pointer_to_uint64()

template<class SRC >

uint64_t duckdb::cast_pointer_to_uint64 ( SRC * src )

                                          {
    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src));
}

◆ cast_uint64_to_pointer()

template<class SRC = data_t>

SRC * duckdb::cast_uint64_to_pointer ( uint64_t value )

                                            {
    return reinterpret_cast<SRC *>(static_cast<uintptr_t>(value));
}

◆ AssertRestrictFunction()

void duckdb::AssertRestrictFunction	(	const void *	left_start,
		const void *	left_end,
		const void *	right_start,
		const void *	right_end,
		const char *	fname,
		int	linenr
	)

inline

                                                                                         {
    // assert that the two pointers do not overlap
#ifdef DEBUG
    if (!(left_end <= right_start || right_end <= left_start)) {
        printf("ASSERT RESTRICT FAILED: %s:%d\n", fname, linenr);
        D_ASSERT(0);
    }
#endif
}

◆ BSwap() [1/12]

static int8_t duckdb::BSwap ( const int8_t & x )

inlinestatic

                                            {
    return x;
}

◆ BSwap() [2/12]

static uint8_t duckdb::BSwap ( const uint8_t & x )

inlinestatic

                                              {
    return x;
}

◆ BSwap() [3/12]

static uint16_t duckdb::BSwap ( const uint16_t & x )

inlinestatic

                                                {
    return BSWAP16(x);
}

◆ BSwap() [4/12]

static int16_t duckdb::BSwap ( const int16_t & x )

inlinestatic

                                              {
    return static_cast<int16_t>(BSWAP16(x));
}

◆ BSwap() [5/12]

static uint32_t duckdb::BSwap ( const uint32_t & x )

inlinestatic

                                                {
    return BSWAP32(x);
}

◆ BSwap() [6/12]

static int32_t duckdb::BSwap ( const int32_t & x )

inlinestatic

                                              {
    return static_cast<int32_t>(BSWAP32(x));
}

◆ BSwap() [7/12]

static uint64_t duckdb::BSwap ( const uint64_t & x )

inlinestatic

                                                {
    return BSWAP64(x);
}

◆ BSwap() [8/12]

static int64_t duckdb::BSwap ( const int64_t & x )

inlinestatic

                                              {
    return static_cast<int64_t>(BSWAP64(x));
}

◆ BSwap() [9/12]

static uhugeint_t duckdb::BSwap ( const uhugeint_t & x )

inlinestatic

                                                    {
    return uhugeint_t(BSWAP64(x.upper), BSWAP64(x.lower));
}

◆ BSwap() [10/12]

static hugeint_t duckdb::BSwap ( const hugeint_t & x )

inlinestatic

                                                  {
    return hugeint_t(static_cast<int64_t>(BSWAP64(x.upper)), BSWAP64(x.lower));
}

◆ BSwap() [11/12]

static float duckdb::BSwap ( const float & x )

inlinestatic

                                          {
    uint32_t temp;
    std::memcpy(&temp, &x, sizeof(temp));
    temp = BSWAP32(temp);
    float result;
    std::memcpy(&result, &temp, sizeof(result));
    return result;
}

◆ BSwap() [12/12]

static double duckdb::BSwap ( const double & x )

inlinestatic

                                            {
    uint64_t temp;
    std::memcpy(&temp, &x, sizeof(temp));
    temp = BSWAP64(temp);
    double result;
    std::memcpy(&result, &temp, sizeof(result));
    return result;
}

◆ BSwapIfLE()

template<class T >

static T duckdb::BSwapIfLE ( const T & x )

inlinestatic

                                      {
#if DUCKDB_IS_BIG_ENDIAN
    return x;
#else
    return BSwap(x);
#endif
}

◆ BSwapIfBE()

template<class T >

static T duckdb::BSwapIfBE ( const T & x )

inlinestatic

                                      {
#if DUCKDB_IS_BIG_ENDIAN
    return BSwap(x);
#else
    return x;
#endif
}

◆ make_uniq()

template<class DATA_TYPE , class... ARGS>

TemplatedUniqueIf< DATA_TYPE, true >::templated_unique_single_t duckdb::make_uniq ( ARGS &&... args )

inline

{
    return unique_ptr<DATA_TYPE, std::default_delete<DATA_TYPE>, true>(new DATA_TYPE(std::forward<ARGS>(args)...));
}

◆ make_shared_ptr()

template<class DATA_TYPE , class... ARGS>

shared_ptr< DATA_TYPE > duckdb::make_shared_ptr ( ARGS &&... args )

inline

{
    return shared_ptr<DATA_TYPE>(duckdb_base_std::make_shared<DATA_TYPE>(std::forward<ARGS>(args)...));
}

◆ make_unsafe_uniq()

template<class DATA_TYPE , class... ARGS>

TemplatedUniqueIf< DATA_TYPE, false >::templated_unique_single_t duckdb::make_unsafe_uniq ( ARGS &&... args )

inline

{
    return unique_ptr<DATA_TYPE, std::default_delete<DATA_TYPE>, false>(new DATA_TYPE(std::forward<ARGS>(args)...));
}

◆ make_uniq_array()

template<class DATA_TYPE >

unique_ptr< DATA_TYPE[], std::default_delete< DATA_TYPE[]>, true > duckdb::make_uniq_array ( size_t n )

inline

{
    return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, true>(new DATA_TYPE[n]());
}

◆ make_uniq_array_uninitialized()

template<class DATA_TYPE >

unique_ptr< DATA_TYPE[], std::default_delete< DATA_TYPE[]>, true > duckdb::make_uniq_array_uninitialized ( size_t n )

inline

{
    return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, true>(new DATA_TYPE[n]);
}

◆ make_unsafe_uniq_array()

template<class DATA_TYPE >

unique_ptr< DATA_TYPE[], std::default_delete< DATA_TYPE[]>, false > duckdb::make_unsafe_uniq_array ( size_t n )

inline

{
    return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, false>(new DATA_TYPE[n]());
}

◆ make_unsafe_uniq_array_uninitialized()

template<class DATA_TYPE >

unique_ptr< DATA_TYPE[], std::default_delete< DATA_TYPE[]>, false > duckdb::make_unsafe_uniq_array_uninitialized ( size_t n )

inline

{
    return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, false>(new DATA_TYPE[n]);
}

◆ make_uniq_base()

template<typename S , typename T , typename... ARGS>

unique_ptr< S > duckdb::make_uniq_base ( ARGS &&... args )

                                              { // NOLINT: mimic std style
    return unique_ptr<S>(new T(std::forward<ARGS>(args)...));
}

◆ unique_ptr_cast()

template<typename SRC , typename TGT >

unique_ptr< TGT > duckdb::unique_ptr_cast ( unique_ptr< SRC > src )

                                                     { // NOLINT: mimic std style
    return unique_ptr<TGT>(static_cast<TGT *>(src.release()));
}

◆ shared_ptr_cast()

template<typename SRC , typename TGT >

shared_ptr< TGT > duckdb::shared_ptr_cast ( shared_ptr< SRC > src )

                                                     { // NOLINT: mimic std style
    return shared_ptr<TGT>(std::static_pointer_cast<TGT, SRC>(src.internal));
}

◆ make_unique()

template<class T , class... ARGS>

static duckdb::unique_ptr< T > duckdb::make_unique ( ARGS &&... __args )

static

                                                         { // NOLINT: mimic std style
#ifndef DUCKDB_ENABLE_DEPRECATED_API
    static_assert(sizeof(T) == 0, "Use make_uniq instead of make_unique!");
#endif // DUCKDB_ENABLE_DEPRECATED_API
    return unique_ptr<T>(new T(std::forward<ARGS>(__args)...));
}

◆ make_shared()

template<class T , class... ARGS>

static duckdb::shared_ptr< T > duckdb::make_shared ( ARGS &&... __args )

static

                                                         { // NOLINT: mimic std style
#ifndef DUCKDB_ENABLE_DEPRECATED_API
    static_assert(sizeof(T) == 0, "Use make_shared_ptr instead of make_shared!");
#endif // DUCKDB_ENABLE_DEPRECATED_API
    return shared_ptr<T>(new T(std::forward<ARGS>(__args)...));
}

◆ MaxValue()

template<typename T >

constexpr T duckdb::MaxValue	(	T	a,
		T	b
	)

constexpr

                               {
    return a > b ? a : b;
}

◆ MinValue()

template<typename T >

constexpr T duckdb::MinValue	(	T	a,
		T	b
	)

constexpr

                               {
    return a < b ? a : b;
}

◆ ClampValue()

template<typename T >

constexpr T duckdb::ClampValue	(	T	v,
		T	min,
		T	max
	)

constexpr

Like std::clamp (C++17), returns v if within bounds, else nearest bound.

                                          {
    return MinValue(MaxValue(v, min), max);
}

Here is the call graph for this function:

◆ AbsValue()

template<typename T >

T duckdb::AbsValue ( T a )

                {
    return a < 0 ? -a : a;
}

◆ AlignValue() [1/2]

template<class T , T val = 8, typename = typename std::enable_if<!std::is_pointer<T>::value>::type>

static T duckdb::AlignValue ( T n )

inlinestatic

Align value (ceiling) (not for pointer types)

                                {
    return ((n + (val - 1)) / val) * val;
}

◆ AlignValue() [2/2]

template<class T >

static T duckdb::AlignValue	(	T	n,
		T	val
	)

static

                                {
    return ((n + (val - 1)) / val) * val;
}

◆ AlignPointer()

template<uintptr_t alignment, class T >

T * duckdb::AlignPointer ( T * addr )

inline

                                {
    static_assert((alignment & (alignment - 1)) == 0, "'alignment' has to be a power of 2");
    return reinterpret_cast<T *>((reinterpret_cast<uintptr_t>(addr) + alignment - 1) & ~(alignment - 1));
}

◆ AlignValueFloor()

template<class T , T val = 8>

constexpr T duckdb::AlignValueFloor ( T n )

inlineconstexpr

                                        {
    return (n / val) * val;
}

◆ ValueIsAligned()

template<class T , T val = 8>

static bool duckdb::ValueIsAligned ( T n )

inlinestatic

                                       {
    return (n % val) == 0;
}

◆ SignValue()

template<typename T >

T duckdb::SignValue ( T a )

                 {
    return a < 0 ? -1 : 1;
}

◆ Load()

template<typename T >

const T duckdb::Load ( const_data_ptr_t ptr )

                                   {
    T ret;
    memcpy(&ret, ptr, sizeof(ret)); // NOLINT
    return ret;
}

◆ LoadLE()

template<typename T >

const T duckdb::LoadLE ( const_data_ptr_t ptr )

                                     {
    return BSwapIfBE(Load<T>(ptr));
}

◆ Store()

template<typename T >

void duckdb::Store	(	const T &	val,
		data_ptr_t	ptr
	)

                                         {
    memcpy(ptr, (void *)&val, sizeof(val)); // NOLINT
}

◆ AssignSharedPointer()

template<class T >

void duckdb::AssignSharedPointer	(	shared_ptr< T > &	target,
		const shared_ptr< T > &	source
	)

This assigns a shared pointer, but ONLY assigns if "target" is not equal to "source" If this is often the case, this manner of assignment is significantly faster (~20X faster) Since it avoids the need of an atomic incref/decref at the cost of a single pointer comparison Benchmark: https://gist.github.com/Mytherin/4db3faa8e233c4a9b874b21f62bb4b96 If the shared pointers are not the same, the penalty is very low (on the order of 1%~ slower) This method should always be preferred if there is a (reasonable) chance that the pointers are the same

                                                                             {
    if (target.get() != source.get()) {
        target = source;
    }
}

◆ RefersToSameObject() [1/2]

template<class T >

bool duckdb::RefersToSameObject	(	const reference< T > &	a,
		const reference< T > &	b
	)

Returns whether or not two reference wrappers refer to the same object.

                                                                      {
    return &a.get() == &b.get();
}

◆ RefersToSameObject() [2/2]

template<class T >

bool duckdb::RefersToSameObject	(	const T &	a,
		const T &	b
	)

                                                {
    return &a == &b;
}

◆ DynamicCastCheck()

template<class T , class SRC >

void duckdb::DynamicCastCheck ( const SRC * source )

                                         {
#ifndef __APPLE__
    // Actual check is on the fact that dynamic_cast and reinterpret_cast are equivalent
    D_ASSERT(reinterpret_cast<const T *>(source) == dynamic_cast<const T *>(source));
#endif
}

◆ make_buffer()

template<class T , typename... ARGS>

buffer_ptr< T > duckdb::make_buffer ( ARGS &&... args )

                                          { // NOLINT: mimic std casing
    return make_shared_ptr<T>(std::forward<ARGS>(args)...);
}

◆ ThrowNumericCastError()

template<class TO , class FROM >

static void duckdb::ThrowNumericCastError	(	FROM	in,
		TO	minval,
		TO	maxval
	)

static

                                                                 {
    throw InternalException("Information loss on integer cast: value %d outside of target range [%d, %d]", in, minval,
                            maxval);
}

◆ NumericCast()

template<class TO , class FROM , class = typename std::enable_if<(NumericLimits<TO>::IsIntegral() && NumericLimits<FROM>::IsIntegral()) || std::is_same<TO, FROM>::value>::type>

TO duckdb::NumericCast ( FROM val )

                         {
    return NumericCastImpl<TO, FROM, std::is_same<TO, FROM>::value>::Convert(val);
}

◆ UnsafeNumericCast()

template<class TO , class FROM , class = typename std::enable_if<(NumericLimits<TO>::IsIntegral() && NumericLimits<FROM>::IsIntegral()) || std::is_same<TO, FROM>::value>::type>

TO duckdb::UnsafeNumericCast ( FROM in )

                              {
#if defined(DEBUG) || defined(UNSAFE_NUMERIC_CAST)
    return NumericCast<TO, FROM>(in);
#endif
    return static_cast<TO>(in);
}

◆ LossyNumericCast()

template<class TO , class FROM >

TO duckdb::LossyNumericCast ( FROM val )

                              {
    return static_cast<TO>(val);
}

◆ ExactNumericCast() [1/2]

template<class TO >

TO duckdb::ExactNumericCast ( double val )

                                {
    auto res = LossyNumericCast<TO>(val);
#if defined(DEBUG) || defined(UNSAFE_NUMERIC_CAST)
    if (val != double(res)) {
        throw InternalException("Information loss on double cast: value %lf outside of target range [%lf, %lf]", val,
                                double(res), double(res));
    }
#endif
    return res;
}

◆ ExactNumericCast() [2/2]

template<class TO >

TO duckdb::ExactNumericCast ( float val )

                               {
    auto res = LossyNumericCast<TO>(val);
#if defined(DEBUG) || defined(UNSAFE_NUMERIC_CAST)
    if (val != float(res)) {
        throw InternalException("Information loss on float cast: value %f outside of target range [%f, %f]", val,
                                float(res), float(res));
    }
#endif
    return res;
}

◆ CombineHash()

hash_t duckdb::CombineHash	(	hash_t	left,
		hash_t	right
	)

inline

Combine two hashes by XORing them.

                                                     {
    return left ^ right;
}

◆ MurmurHash64()

hash_t duckdb::MurmurHash64 ( uint64_t x )

inline

Efficient hash function that maximizes the avalanche effect and minimizes bias See: https://nullprogram.com/blog/2018/07/31/

                                       {
    x ^= x >> 32;
    x *= 0xd6e8feb86659fd93U;
    x ^= x >> 32;
    x *= 0xd6e8feb86659fd93U;
    x ^= x >> 32;
    return x;
}

◆ MurmurHash32()

hash_t duckdb::MurmurHash32 ( uint32_t x )

inline

                                       {
    return MurmurHash64(x);
}

◆ Hash() [1/3]

template<class T >

hash_t duckdb::Hash ( T value )

                     {
    return MurmurHash32(static_cast<uint32_t>(value));
}

◆ Hash() [2/3]

template<>

DUCKDB_API hash_t duckdb::Hash ( uint64_t val )

inline

                                            {
    return MurmurHash64(val);
}

◆ Hash() [3/3]

template<>

DUCKDB_API hash_t duckdb::Hash ( int64_t val )

inline

                                           {
    return MurmurHash64(static_cast<uint64_t>(val));
}

◆ operator==() [1/2]

bool duckdb::operator==	(	const std::string &	lhs,
		const String &	rhs
	)

inline

                                                                {
    return rhs == lhs;
}

◆ operator==() [2/2]

bool duckdb::operator==	(	const char *	lhs,
		const String &	rhs
	)

inline

                                                           {
    return rhs == lhs;
}

◆ AllocateArray()

template<class T >

T * duckdb::AllocateArray ( idx_t size )

                             {
    return (T *)Allocator::DefaultAllocator().AllocateData(size * sizeof(T));
}

◆ DeleteArray()

template<class T >

void duckdb::DeleteArray	(	T *	ptr,
		idx_t	size
	)

                                     {
    Allocator::DefaultAllocator().FreeData(data_ptr_cast(ptr), size * sizeof(T));
}

◆ AllocateObject()

template<typename T , typename... ARGS>

T * duckdb::AllocateObject ( ARGS &&... args )

                                   {
    auto data = Allocator::DefaultAllocator().AllocateData(sizeof(T));
    return new (data) T(std::forward<ARGS>(args)...);
}

◆ DestroyObject()

template<typename T >

void duckdb::DestroyObject ( T * ptr )

                           {
    ptr->~T();
    Allocator::DefaultAllocator().FreeData(data_ptr_cast(ptr), sizeof(T));
}

◆ GetTypeId()

template<class T >

PhysicalType duckdb::GetTypeId ( )

Returns the PhysicalType for the given type.

                         {
    using TYPE = typename std::remove_cv<T>::type;
 
    if (std::is_same<TYPE, bool>()) {
        return PhysicalType::BOOL;
    } else if (std::is_same<TYPE, int8_t>()) {
        return PhysicalType::INT8;
    } else if (std::is_same<TYPE, int16_t>()) {
        return PhysicalType::INT16;
    } else if (std::is_same<TYPE, int32_t>()) {
        return PhysicalType::INT32;
    } else if (std::is_same<TYPE, int64_t>()) {
        return PhysicalType::INT64;
    } else if (std::is_same<TYPE, uint8_t>()) {
        return PhysicalType::UINT8;
    } else if (std::is_same<TYPE, uint16_t>()) {
        return PhysicalType::UINT16;
    } else if (std::is_same<TYPE, uint32_t>()) {
        return PhysicalType::UINT32;
    } else if (std::is_same<TYPE, uint64_t>()) {
        return PhysicalType::UINT64;
    } else if (std::is_same<TYPE, idx_t>() || std::is_same<TYPE, const idx_t>()) {
        return PhysicalType::UINT64;
    } else if (std::is_same<TYPE, hugeint_t>()) {
        return PhysicalType::INT128;
    } else if (std::is_same<TYPE, uhugeint_t>()) {
        return PhysicalType::UINT128;
    } else if (std::is_same<TYPE, date_t>()) {
        return PhysicalType::INT32;
    } else if (std::is_same<TYPE, dtime_t>()) {
        return PhysicalType::INT64;
    } else if (std::is_same<TYPE, dtime_tz_t>()) {
        return PhysicalType::INT64;
    } else if (std::is_same<TYPE, dtime_ns_t>()) {
        return PhysicalType::INT64;
    } else if (std::is_same<TYPE, timestamp_t>()) {
        return PhysicalType::INT64;
    } else if (std::is_same<TYPE, timestamp_sec_t>()) {
        return PhysicalType::INT64;
    } else if (std::is_same<TYPE, timestamp_ms_t>()) {
        return PhysicalType::INT64;
    } else if (std::is_same<TYPE, timestamp_ns_t>()) {
        return PhysicalType::INT64;
    } else if (std::is_same<TYPE, timestamp_tz_t>()) {
        return PhysicalType::INT64;
    } else if (std::is_same<TYPE, float>() || std::is_same<TYPE, float_na_equal>()) {
        return PhysicalType::FLOAT;
    } else if (std::is_same<TYPE, double>() || std::is_same<TYPE, double_na_equal>()) {
        return PhysicalType::DOUBLE;
    } else if (std::is_same<TYPE, const char *>() || std::is_same<TYPE, char *>() || std::is_same<TYPE, string_t>() ||
               std::is_same<TYPE, bignum_t>()) {
        return PhysicalType::VARCHAR;
    } else if (std::is_same<TYPE, interval_t>()) {
        return PhysicalType::INTERVAL;
    } else if (std::is_same<TYPE, list_entry_t>()) {
        return PhysicalType::LIST;
    } else if (std::is_pointer<TYPE>() || std::is_same<TYPE, uintptr_t>()) {
        if (sizeof(uintptr_t) == sizeof(uint32_t)) {
            return PhysicalType::UINT32;
        } else if (sizeof(uintptr_t) == sizeof(uint64_t)) {
            return PhysicalType::UINT64;
        } else {
            throw InternalException("Unsupported pointer size in GetTypeId");
        }
    } else {
        throw InternalException("Unsupported type in GetTypeId");
    }
}

◆ StorageTypeCompatible()

template<class T >

bool duckdb::StorageTypeCompatible ( PhysicalType type )

                                              {
    using TYPE = typename std::remove_cv<T>::type;
 
    if (std::is_same<TYPE, int8_t>()) {
        return type == PhysicalType::INT8 || type == PhysicalType::BOOL;
    }
    if (std::is_same<TYPE, uint8_t>()) {
        return type == PhysicalType::UINT8 || type == PhysicalType::BOOL;
    }
    return type == GetTypeId<T>();
}

◆ TypeIsNumber()

template<class T >

bool duckdb::TypeIsNumber ( )

                    {
    using TYPE = typename std::remove_cv<T>::type;
 
    return std::is_integral<TYPE>() || std::is_floating_point<TYPE>() || std::is_same<TYPE, hugeint_t>() ||
           std::is_same<TYPE, uhugeint_t>();
}

◆ IsValidType()

template<class T >

bool duckdb::IsValidType ( )

                   {
    return GetTypeId<T>() != PhysicalType::INVALID;
}

◆ IsIntegerType()

template<class T >

bool duckdb::IsIntegerType ( )

                     {
    return TypeIsIntegral(GetTypeId<T>());
}

◆ CreateRelationAlias()

static string duckdb::CreateRelationAlias	(	RelationType	type,
		const string &	alias
	)

static

                                                                          {
    if (!alias.empty()) {
        return alias;
    }
    return StringUtil::Format("%s_%s", EnumUtil::ToString(type), StringUtil::GenerateRandomName());
}

Initial value:

= {
    {"aws", "httpfs"},         {"azure", "azure"},     {"ducklake", "ducklake"},   {"gcs", "httpfs"},
    {"huggingface", "httpfs"}, {"iceberg", "iceberg"}, {"mysql", "mysql_scanner"}, {"postgres", "postgres_scanner"},
    {"r2", "httpfs"},          {"s3", "httpfs"},
}

                                                           {
    {"aws", "httpfs"},         {"azure", "azure"},     {"ducklake", "ducklake"},   {"gcs", "httpfs"},
    {"huggingface", "httpfs"}, {"iceberg", "iceberg"}, {"mysql", "mysql_scanner"}, {"postgres", "postgres_scanner"},
    {"r2", "httpfs"},          {"s3", "httpfs"},
}; // END_OF_EXTENSION_SECRET_TYPES

◆ EXTENSION_COPY_FUNCTIONS

constexpr ExtensionEntry duckdb::EXTENSION_COPY_FUNCTIONS[]

staticconstexprprivate

Initial value:

= {

{"parquet", "parquet"}, {"json", "json"}, {"avro", "avro"}}

4438 {

4439 {"parquet", "parquet"}, {"json", "json"}, {"avro", "avro"}}; // END_OF_EXTENSION_COPY_FUNCTIONS

◆ EXTENSION_TYPES

constexpr ExtensionEntry duckdb::EXTENSION_TYPES[]

staticconstexprprivate

Initial value:

= {
    {"json", "json"},
    {"inet", "inet"},
}

                                                    {
    {"json", "json"},
    {"inet", "inet"},
}; // END_OF_EXTENSION_TYPES

◆ EXTENSION_COLLATIONS

constexpr ExtensionEntry duckdb::EXTENSION_COLLATIONS[]

staticconstexprprivate

Initial value:

= {
    {"af", "icu"},    {"am", "icu"},    {"ar", "icu"},     {"ar_sa", "icu"}, {"as", "icu"},    {"az", "icu"},
    {"be", "icu"},    {"bg", "icu"},    {"bn", "icu"},     {"bo", "icu"},    {"br", "icu"},    {"bs", "icu"},
    {"ca", "icu"},    {"ceb", "icu"},   {"chr", "icu"},    {"cs", "icu"},    {"cy", "icu"},    {"da", "icu"},
    {"de", "icu"},    {"de_at", "icu"}, {"dsb", "icu"},    {"dz", "icu"},    {"ee", "icu"},    {"el", "icu"},
    {"en", "icu"},    {"en_us", "icu"}, {"eo", "icu"},     {"es", "icu"},    {"et", "icu"},    {"fa", "icu"},
    {"fa_af", "icu"}, {"ff", "icu"},    {"fi", "icu"},     {"fil", "icu"},   {"fo", "icu"},    {"fr", "icu"},
    {"fr_ca", "icu"}, {"fy", "icu"},    {"ga", "icu"},     {"gl", "icu"},    {"gu", "icu"},    {"ha", "icu"},
    {"haw", "icu"},   {"he", "icu"},    {"he_il", "icu"},  {"hi", "icu"},    {"hr", "icu"},    {"hsb", "icu"},
    {"hu", "icu"},    {"hy", "icu"},    {"id", "icu"},     {"id_id", "icu"}, {"ig", "icu"},    {"is", "icu"},
    {"it", "icu"},    {"ja", "icu"},    {"ka", "icu"},     {"kk", "icu"},    {"kl", "icu"},    {"km", "icu"},
    {"kn", "icu"},    {"ko", "icu"},    {"kok", "icu"},    {"ku", "icu"},    {"ky", "icu"},    {"lb", "icu"},
    {"lkt", "icu"},   {"ln", "icu"},    {"lo", "icu"},     {"lt", "icu"},    {"lv", "icu"},    {"mk", "icu"},
    {"ml", "icu"},    {"mn", "icu"},    {"mr", "icu"},     {"ms", "icu"},    {"mt", "icu"},    {"my", "icu"},
    {"nb", "icu"},    {"nb_no", "icu"}, {"ne", "icu"},     {"nl", "icu"},    {"nn", "icu"},    {"om", "icu"},
    {"or", "icu"},    {"pa", "icu"},    {"pa_in", "icu"},  {"pl", "icu"},    {"ps", "icu"},    {"pt", "icu"},
    {"ro", "icu"},    {"ru", "icu"},    {"sa", "icu"},     {"se", "icu"},    {"si", "icu"},    {"sk", "icu"},
    {"sl", "icu"},    {"smn", "icu"},   {"sq", "icu"},     {"sr", "icu"},    {"sr_ba", "icu"}, {"sr_me", "icu"},
    {"sr_rs", "icu"}, {"sv", "icu"},    {"sw", "icu"},     {"ta", "icu"},    {"te", "icu"},    {"th", "icu"},
    {"tk", "icu"},    {"to", "icu"},    {"tr", "icu"},     {"ug", "icu"},    {"uk", "icu"},    {"ur", "icu"},
    {"uz", "icu"},    {"vi", "icu"},    {"wae", "icu"},    {"wo", "icu"},    {"xh", "icu"},    {"yi", "icu"},
    {"yo", "icu"},    {"yue", "icu"},   {"yue_cn", "icu"}, {"zh", "icu"},    {"zh_cn", "icu"}, {"zh_hk", "icu"},
    {"zh_mo", "icu"}, {"zh_sg", "icu"}, {"zh_tw", "icu"},  {"zu", "icu"}}

                                                         {
    {"af", "icu"},    {"am", "icu"},    {"ar", "icu"},     {"ar_sa", "icu"}, {"as", "icu"},    {"az", "icu"},
    {"be", "icu"},    {"bg", "icu"},    {"bn", "icu"},     {"bo", "icu"},    {"br", "icu"},    {"bs", "icu"},
    {"ca", "icu"},    {"ceb", "icu"},   {"chr", "icu"},    {"cs", "icu"},    {"cy", "icu"},    {"da", "icu"},
    {"de", "icu"},    {"de_at", "icu"}, {"dsb", "icu"},    {"dz", "icu"},    {"ee", "icu"},    {"el", "icu"},
    {"en", "icu"},    {"en_us", "icu"}, {"eo", "icu"},     {"es", "icu"},    {"et", "icu"},    {"fa", "icu"},
    {"fa_af", "icu"}, {"ff", "icu"},    {"fi", "icu"},     {"fil", "icu"},   {"fo", "icu"},    {"fr", "icu"},
    {"fr_ca", "icu"}, {"fy", "icu"},    {"ga", "icu"},     {"gl", "icu"},    {"gu", "icu"},    {"ha", "icu"},
    {"haw", "icu"},   {"he", "icu"},    {"he_il", "icu"},  {"hi", "icu"},    {"hr", "icu"},    {"hsb", "icu"},
    {"hu", "icu"},    {"hy", "icu"},    {"id", "icu"},     {"id_id", "icu"}, {"ig", "icu"},    {"is", "icu"},
    {"it", "icu"},    {"ja", "icu"},    {"ka", "icu"},     {"kk", "icu"},    {"kl", "icu"},    {"km", "icu"},
    {"kn", "icu"},    {"ko", "icu"},    {"kok", "icu"},    {"ku", "icu"},    {"ky", "icu"},    {"lb", "icu"},
    {"lkt", "icu"},   {"ln", "icu"},    {"lo", "icu"},     {"lt", "icu"},    {"lv", "icu"},    {"mk", "icu"},
    {"ml", "icu"},    {"mn", "icu"},    {"mr", "icu"},     {"ms", "icu"},    {"mt", "icu"},    {"my", "icu"},
    {"nb", "icu"},    {"nb_no", "icu"}, {"ne", "icu"},     {"nl", "icu"},    {"nn", "icu"},    {"om", "icu"},
    {"or", "icu"},    {"pa", "icu"},    {"pa_in", "icu"},  {"pl", "icu"},    {"ps", "icu"},    {"pt", "icu"},
    {"ro", "icu"},    {"ru", "icu"},    {"sa", "icu"},     {"se", "icu"},    {"si", "icu"},    {"sk", "icu"},
    {"sl", "icu"},    {"smn", "icu"},   {"sq", "icu"},     {"sr", "icu"},    {"sr_ba", "icu"}, {"sr_me", "icu"},
    {"sr_rs", "icu"}, {"sv", "icu"},    {"sw", "icu"},     {"ta", "icu"},    {"te", "icu"},    {"th", "icu"},
    {"tk", "icu"},    {"to", "icu"},    {"tr", "icu"},     {"ug", "icu"},    {"uk", "icu"},    {"ur", "icu"},
    {"uz", "icu"},    {"vi", "icu"},    {"wae", "icu"},    {"wo", "icu"},    {"xh", "icu"},    {"yi", "icu"},
    {"yo", "icu"},    {"yue", "icu"},   {"yue_cn", "icu"}, {"zh", "icu"},    {"zh_cn", "icu"}, {"zh_hk", "icu"},
    {"zh_mo", "icu"}, {"zh_sg", "icu"}, {"zh_tw", "icu"},  {"zu", "icu"}}; // END_OF_EXTENSION_COLLATIONS

◆ EXTENSION_FILE_PREFIXES

constexpr ExtensionEntry duckdb::EXTENSION_FILE_PREFIXES[]

staticconstexprprivate

Initial value:

= {
    {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"}, {"s3a://", "httpfs"},  {"s3n://", "httpfs"},
    {"gcs://", "httpfs"},  {"gs://", "httpfs"},    {"r2://", "httpfs"}, {"azure://", "azure"}, {"az://", "azure"},
    {"abfss://", "azure"}, {"hf://", "httpfs"}}

                                                            {
    {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"}, {"s3a://", "httpfs"},  {"s3n://", "httpfs"},
    {"gcs://", "httpfs"},  {"gs://", "httpfs"},    {"r2://", "httpfs"}, {"azure://", "azure"}, {"az://", "azure"},
    {"abfss://", "azure"}, {"hf://", "httpfs"}}; // END_OF_EXTENSION_FILE_PREFIXES

◆ EXTENSION_FILE_POSTFIXES

constexpr ExtensionEntry duckdb::EXTENSION_FILE_POSTFIXES[]

staticconstexprprivate

Initial value:

= {
    {".parquet", "parquet"}, {".json", "json"},   {".jsonl", "json"}, {".ndjson", "json"}, {".shp", "spatial"},
    {".gpkg", "spatial"},    {".fgb", "spatial"}, {".xlsx", "excel"}, {".avro", "avro"},
}

                                                             {
    {".parquet", "parquet"}, {".json", "json"},   {".jsonl", "json"}, {".ndjson", "json"}, {".shp", "spatial"},
    {".gpkg", "spatial"},    {".fgb", "spatial"}, {".xlsx", "excel"}, {".avro", "avro"},
}; // END_OF_EXTENSION_FILE_POSTFIXES

◆ EXTENSION_FILE_CONTAINS

constexpr ExtensionEntry duckdb::EXTENSION_FILE_CONTAINS[]

staticconstexprprivate

Initial value:

= {{".parquet?", "parquet"},
                                                             {".json?", "json"},
                                                             {".ndjson?", ".jsonl?"},
                                                             {".jsonl?", ".ndjson?"}}

                                                            {{".parquet?", "parquet"},
                                                             {".json?", "json"},
                                                             {".ndjson?", ".jsonl?"},
                                                             {".jsonl?", ".ndjson?"}}; // EXTENSION_FILE_CONTAINS

◆ EXTENSION_SECRET_PROVIDERS

constexpr ExtensionEntry duckdb::EXTENSION_SECRET_PROVIDERS[]

staticconstexprprivate

Initial value:

= {
    {"s3/config", "httpfs"},
    {"gcs/config", "httpfs"},
    {"r2/config", "httpfs"},
    {"s3/credential_chain", "aws"},
    {"gcs/credential_chain", "aws"},
    {"r2/credential_chain", "aws"},
    {"aws/credential_chain", "aws"},
    {"azure/access_token", "azure"},
    {"azure/config", "azure"},
    {"azure/credential_chain", "azure"},
    {"azure/service_principal", "azure"},
    {"huggingface/config", "httfps"},
    {"huggingface/credential_chain", "httpfs"},
    {"bearer/config", "httpfs"},
    {"mysql/config", "mysql_scanner"},
    {"postgres/config", "postgres_scanner"}}

                                                               {
    {"s3/config", "httpfs"},
    {"gcs/config", "httpfs"},
    {"r2/config", "httpfs"},
    {"s3/credential_chain", "aws"},
    {"gcs/credential_chain", "aws"},
    {"r2/credential_chain", "aws"},
    {"aws/credential_chain", "aws"},
    {"azure/access_token", "azure"},
    {"azure/config", "azure"},
    {"azure/credential_chain", "azure"},
    {"azure/service_principal", "azure"},
    {"huggingface/config", "httfps"},
    {"huggingface/credential_chain", "httpfs"},
    {"bearer/config", "httpfs"},
    {"mysql/config", "mysql_scanner"},
    {"postgres/config", "postgres_scanner"}}; // EXTENSION_SECRET_PROVIDERS

◆ AUTOLOADABLE_EXTENSIONS

constexpr const char* duckdb::AUTOLOADABLE_EXTENSIONS[]

staticconstexprprivate

Initial value:

= {"avro",
                                                          "aws",
                                                          "azure",
                                                          "autocomplete",
                                                          "core_functions",
                                                          "delta",
                                                          "ducklake",
                                                          "encodings",
                                                          "excel",
                                                          "fts",
                                                          "httpfs",
                                                          "iceberg",
                                                          "inet",
                                                          "icu",
                                                          "json",
                                                          "motherduck",
                                                          "mysql_scanner",
                                                          "parquet",
                                                          "sqlite_scanner",
                                                          "sqlsmith",
                                                          "postgres_scanner",
                                                          "tpcds",
                                                          "tpch",
                                                          "unity_catalog",
                                                          "ui"}

                                                         {"avro",
                                                          "aws",
                                                          "azure",
                                                          "autocomplete",
                                                          "core_functions",
                                                          "delta",
                                                          "ducklake",
                                                          "encodings",
                                                          "excel",
                                                          "fts",
                                                          "httpfs",
                                                          "iceberg",
                                                          "inet",
                                                          "icu",
                                                          "json",
                                                          "motherduck",
                                                          "mysql_scanner",
                                                          "parquet",
                                                          "sqlite_scanner",
                                                          "sqlsmith",
                                                          "postgres_scanner",
                                                          "tpcds",
                                                          "tpch",
                                                          "unity_catalog",
                                                          "ui"}; // END_OF_AUTOLOADABLE_EXTENSIONS

◆ internal_macros

const DefaultMacro duckdb::internal_macros[]

staticprivate

                                              {
    {DEFAULT_SCHEMA, "current_role", {nullptr}, {{nullptr, nullptr}}, "'duckdb'"},                       // user name of current execution context
    {DEFAULT_SCHEMA, "current_user", {nullptr}, {{nullptr, nullptr}}, "'duckdb'"},                       // user name of current execution context
    {DEFAULT_SCHEMA, "current_catalog", {nullptr}, {{nullptr, nullptr}}, "main.current_database()"},          // name of current database (called "catalog" in the SQL standard)
    {DEFAULT_SCHEMA, "user", {nullptr}, {{nullptr, nullptr}}, "current_user"},                           // equivalent to current_user
    {DEFAULT_SCHEMA, "session_user", {nullptr}, {{nullptr, nullptr}}, "'duckdb'"},                       // session user name
    {"pg_catalog", "inet_client_addr", {nullptr}, {{nullptr, nullptr}}, "NULL"},                       // address of the remote connection
    {"pg_catalog", "inet_client_port", {nullptr}, {{nullptr, nullptr}}, "NULL"},                       // port of the remote connection
    {"pg_catalog", "inet_server_addr", {nullptr}, {{nullptr, nullptr}}, "NULL"},                       // address of the local connection
    {"pg_catalog", "inet_server_port", {nullptr}, {{nullptr, nullptr}}, "NULL"},                       // port of the local connection
    {"pg_catalog", "pg_my_temp_schema", {nullptr}, {{nullptr, nullptr}}, "0"},                         // OID of session's temporary schema, or 0 if none
    {"pg_catalog", "pg_is_other_temp_schema", {"schema_id", nullptr}, {{nullptr, nullptr}}, "false"},  // is schema another session's temporary schema?
 
    {"pg_catalog", "pg_conf_load_time", {nullptr}, {{nullptr, nullptr}}, "current_timestamp"},         // configuration load time
    {"pg_catalog", "pg_postmaster_start_time", {nullptr}, {{nullptr, nullptr}}, "current_timestamp"},  // server start time
 
    {"pg_catalog", "pg_typeof", {"expression", nullptr}, {{nullptr, nullptr}}, "lower(typeof(expression))"},  // get the data type of any value
 
    {"pg_catalog", "current_database", {nullptr}, {{nullptr, nullptr}}, "system.main.current_database()"},          // name of current database (called "catalog" in the SQL standard)
    {"pg_catalog", "current_query", {nullptr}, {{nullptr, nullptr}}, "system.main.current_query()"},            // the currently executing query (NULL if not inside a plpgsql function)
    {"pg_catalog", "current_schema", {nullptr}, {{nullptr, nullptr}}, "system.main.current_schema()"},              // name of current schema
    {"pg_catalog", "current_schemas", {"include_implicit"}, {{nullptr, nullptr}}, "system.main.current_schemas(include_implicit)"},     // names of schemas in search path
 
    // privilege functions
    {"pg_catalog", "has_any_column_privilege", {"table", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for any column of table
    {"pg_catalog", "has_any_column_privilege", {"user", "table", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for any column of table
    {"pg_catalog", "has_column_privilege", {"table", "column", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for column
    {"pg_catalog", "has_column_privilege", {"user", "table", "column", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for column
    {"pg_catalog", "has_database_privilege", {"database", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for database
    {"pg_catalog", "has_database_privilege", {"user", "database", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for database
    {"pg_catalog", "has_foreign_data_wrapper_privilege", {"fdw", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for foreign-data wrapper
    {"pg_catalog", "has_foreign_data_wrapper_privilege", {"user", "fdw", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for foreign-data wrapper
    {"pg_catalog", "has_function_privilege", {"function", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for function
    {"pg_catalog", "has_function_privilege", {"user", "function", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for function
    {"pg_catalog", "has_language_privilege", {"language", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for language
    {"pg_catalog", "has_language_privilege", {"user", "language", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for language
    {"pg_catalog", "has_schema_privilege", {"schema", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for schema
    {"pg_catalog", "has_schema_privilege", {"user", "schema", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for schema
    {"pg_catalog", "has_sequence_privilege", {"sequence", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for sequence
    {"pg_catalog", "has_sequence_privilege", {"user", "sequence", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for sequence
    {"pg_catalog", "has_server_privilege", {"server", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for foreign server
    {"pg_catalog", "has_server_privilege", {"user", "server", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for foreign server
    {"pg_catalog", "has_table_privilege", {"table", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for table
    {"pg_catalog", "has_table_privilege", {"user", "table", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for table
    {"pg_catalog", "has_tablespace_privilege", {"tablespace", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for tablespace
    {"pg_catalog", "has_tablespace_privilege", {"user", "tablespace", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for tablespace
 
    // various postgres system functions
    {"pg_catalog", "pg_get_viewdef", {"oid", nullptr}, {{nullptr, nullptr}}, "(select sql from duckdb_views() v where v.view_oid=oid)"},
    {"pg_catalog", "pg_get_constraintdef", {"constraint_oid", nullptr}, {{nullptr, nullptr}}, "(select constraint_text from duckdb_constraints() d_constraint where d_constraint.table_oid=constraint_oid//1000000 and d_constraint.constraint_index=constraint_oid%1000000)"},
    {"pg_catalog", "pg_get_constraintdef", {"constraint_oid", "pretty_bool", nullptr}, {{nullptr, nullptr}}, "pg_get_constraintdef(constraint_oid)"},
    {"pg_catalog", "pg_get_expr", {"pg_node_tree", "relation_oid", nullptr}, {{nullptr, nullptr}}, "pg_node_tree"},
    {"pg_catalog", "format_pg_type", {"logical_type", "type_name", nullptr}, {{nullptr, nullptr}}, "case upper(logical_type) when 'FLOAT' then 'float4' when 'DOUBLE' then 'float8' when 'DECIMAL' then 'numeric' when 'ENUM' then lower(type_name) when 'VARCHAR' then 'varchar' when 'BLOB' then 'bytea' when 'TIMESTAMP' then 'timestamp' when 'TIME' then 'time' when 'TIMESTAMP WITH TIME ZONE' then 'timestamptz' when 'TIME WITH TIME ZONE' then 'timetz' when 'SMALLINT' then 'int2' when 'INTEGER' then 'int4' when 'BIGINT' then 'int8' when 'BOOLEAN' then 'bool' else lower(logical_type) end"},
    {"pg_catalog", "format_type", {"type_oid", "typemod", nullptr}, {{nullptr, nullptr}}, "(select format_pg_type(logical_type, type_name) from duckdb_types() t where t.type_oid=type_oid) || case when typemod>0 then concat('(', typemod//1000, ',', typemod%1000, ')') else '' end"},
    {"pg_catalog", "map_to_pg_oid", {"type_name", nullptr}, {{nullptr, nullptr}}, "case type_name when 'bool' then 16 when 'int16' then 21 when 'int' then 23 when 'bigint' then 20 when 'date' then 1082 when 'time' then 1083 when 'datetime' then 1114 when 'dec' then 1700 when 'float' then 700 when 'double' then 701 when 'bpchar' then 1043 when 'binary' then 17 when 'interval' then 1186 when 'timestamptz' then 1184 when 'timestamp with time zone' then 1184 when 'timetz' then 1266 when 'time with time zone' then 1266 when 'bit' then 1560 when 'guid' then 2950 else null end"}, // map duckdb_oid to pg_oid. If no corresponding type, return null
 
    {"pg_catalog", "pg_has_role", {"user", "role", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does user have privilege for role
    {"pg_catalog", "pg_has_role", {"role", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for role
 
    {"pg_catalog", "col_description", {"table_oid", "column_number", nullptr}, {{nullptr, nullptr}}, "NULL"},   // get comment for a table column
    {"pg_catalog", "obj_description", {"object_oid", "catalog_name", nullptr}, {{nullptr, nullptr}}, "NULL"},   // get comment for a database object
    {"pg_catalog", "shobj_description", {"object_oid", "catalog_name", nullptr}, {{nullptr, nullptr}}, "NULL"}, // get comment for a shared database object
 
    // visibility functions
    {"pg_catalog", "pg_collation_is_visible", {"collation_oid", nullptr}, {{nullptr, nullptr}}, "true"},
    {"pg_catalog", "pg_conversion_is_visible", {"conversion_oid", nullptr}, {{nullptr, nullptr}}, "true"},
    {"pg_catalog", "pg_function_is_visible", {"function_oid", nullptr}, {{nullptr, nullptr}}, "true"},
    {"pg_catalog", "pg_opclass_is_visible", {"opclass_oid", nullptr}, {{nullptr, nullptr}}, "true"},
    {"pg_catalog", "pg_operator_is_visible", {"operator_oid", nullptr}, {{nullptr, nullptr}}, "true"},
    {"pg_catalog", "pg_opfamily_is_visible", {"opclass_oid", nullptr}, {{nullptr, nullptr}}, "true"},
    {"pg_catalog", "pg_table_is_visible", {"table_oid", nullptr}, {{nullptr, nullptr}}, "true"},
    {"pg_catalog", "pg_ts_config_is_visible", {"config_oid", nullptr}, {{nullptr, nullptr}}, "true"},
    {"pg_catalog", "pg_ts_dict_is_visible", {"dict_oid", nullptr}, {{nullptr, nullptr}}, "true"},
    {"pg_catalog", "pg_ts_parser_is_visible", {"parser_oid", nullptr}, {{nullptr, nullptr}}, "true"},
    {"pg_catalog", "pg_ts_template_is_visible", {"template_oid", nullptr}, {{nullptr, nullptr}}, "true"},
    {"pg_catalog", "pg_type_is_visible", {"type_oid", nullptr}, {{nullptr, nullptr}}, "true"},
 
    {"pg_catalog", "pg_size_pretty", {"bytes", nullptr}, {{nullptr, nullptr}}, "format_bytes(bytes)"},
    {"pg_catalog", "pg_sleep", {"seconds", nullptr}, {{nullptr, nullptr}}, "sleep_ms(CAST(seconds * 1000 AS BIGINT))"},
 
    {DEFAULT_SCHEMA, "round_even", {"x", "n", nullptr}, {{nullptr, nullptr}}, "CASE ((abs(x) * power(10, n+1)) % 10) WHEN 5 THEN round(x/2, n) * 2 ELSE round(x, n) END"},
    {DEFAULT_SCHEMA, "roundbankers", {"x", "n", nullptr}, {{nullptr, nullptr}}, "round_even(x, n)"},
    {DEFAULT_SCHEMA, "nullif", {"a", "b", nullptr}, {{nullptr, nullptr}}, "CASE WHEN a=b THEN NULL ELSE a END"},
    {DEFAULT_SCHEMA, "list_append", {"l", "e", nullptr}, {{nullptr, nullptr}}, "list_concat(l, list_value(e))"},
    {DEFAULT_SCHEMA, "array_append", {"arr", "el", nullptr}, {{nullptr, nullptr}}, "list_append(arr, el)"},
    {DEFAULT_SCHEMA, "list_prepend", {"e", "l", nullptr}, {{nullptr, nullptr}}, "list_concat(list_value(e), l)"},
    {DEFAULT_SCHEMA, "array_prepend", {"el", "arr", nullptr}, {{nullptr, nullptr}}, "list_prepend(el, arr)"},
    {DEFAULT_SCHEMA, "array_pop_back", {"arr", nullptr}, {{nullptr, nullptr}}, "arr[:LEN(arr)-1]"},
    {DEFAULT_SCHEMA, "array_pop_front", {"arr", nullptr}, {{nullptr, nullptr}}, "arr[2:]"},
    {DEFAULT_SCHEMA, "array_push_back", {"arr", "e", nullptr}, {{nullptr, nullptr}}, "list_concat(arr, list_value(e))"},
    {DEFAULT_SCHEMA, "array_push_front", {"arr", "e", nullptr}, {{nullptr, nullptr}}, "list_concat(list_value(e), arr)"},
    {DEFAULT_SCHEMA, "array_to_string", {"arr", "sep", nullptr}, {{nullptr, nullptr}}, "case len(arr::varchar[]) when 0 then '' else list_aggr(arr::varchar[], 'string_agg', sep) end"},
    // Test default parameters
    {DEFAULT_SCHEMA, "array_to_string_comma_default", {"arr", nullptr}, {{"sep", "','"}, {nullptr, nullptr}}, "case len(arr::varchar[]) when 0 then '' else list_aggr(arr::varchar[], 'string_agg', sep) end"},
 
    {DEFAULT_SCHEMA, "generate_subscripts", {"arr", "dim", nullptr}, {{nullptr, nullptr}}, "unnest(generate_series(1, array_length(arr, dim)))"},
    {DEFAULT_SCHEMA, "fdiv", {"x", "y", nullptr}, {{nullptr, nullptr}}, "floor(x/y)"},
    {DEFAULT_SCHEMA, "fmod", {"x", "y", nullptr}, {{nullptr, nullptr}}, "(x-y*floor(x/y))"},
    {DEFAULT_SCHEMA, "split_part", {"string", "delimiter", "position", nullptr}, {{nullptr, nullptr}}, "if(string IS NOT NULL AND delimiter IS NOT NULL AND position IS NOT NULL, coalesce(string_split(string, delimiter)[position],''), NULL)"},
    {DEFAULT_SCHEMA, "geomean", {"x", nullptr}, {{nullptr, nullptr}}, "exp(avg(ln(x)))"},
    {DEFAULT_SCHEMA, "geometric_mean", {"x", nullptr}, {{nullptr, nullptr}}, "geomean(x)"},
 
    {DEFAULT_SCHEMA, "weighted_avg", {"value", "weight", nullptr}, {{nullptr, nullptr}}, "SUM(value * weight) / SUM(CASE WHEN value IS NOT NULL THEN weight ELSE 0 END)"},
    {DEFAULT_SCHEMA, "wavg", {"value", "weight", nullptr}, {{nullptr, nullptr}}, "weighted_avg(value, weight)"},
 
    {DEFAULT_SCHEMA, "list_reverse", {"l", nullptr}, {{nullptr, nullptr}}, "l[:-:-1]"},
    {DEFAULT_SCHEMA, "array_reverse", {"l", nullptr}, {{nullptr, nullptr}}, "list_reverse(l)"},
 
    // algebraic list aggregates
    {DEFAULT_SCHEMA, "list_avg", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'avg')"},
    {DEFAULT_SCHEMA, "list_var_samp", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'var_samp')"},
    {DEFAULT_SCHEMA, "list_var_pop", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'var_pop')"},
    {DEFAULT_SCHEMA, "list_stddev_pop", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'stddev_pop')"},
    {DEFAULT_SCHEMA, "list_stddev_samp", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'stddev_samp')"},
    {DEFAULT_SCHEMA, "list_sem", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'sem')"},
 
    // distributive list aggregates
    {DEFAULT_SCHEMA, "list_approx_count_distinct", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'approx_count_distinct')"},
    {DEFAULT_SCHEMA, "list_bit_xor", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'bit_xor')"},
    {DEFAULT_SCHEMA, "list_bit_or", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'bit_or')"},
    {DEFAULT_SCHEMA, "list_bit_and", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'bit_and')"},
    {DEFAULT_SCHEMA, "list_bool_and", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'bool_and')"},
    {DEFAULT_SCHEMA, "list_bool_or", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'bool_or')"},
    {DEFAULT_SCHEMA, "list_count", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'count')"},
    {DEFAULT_SCHEMA, "list_entropy", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'entropy')"},
    {DEFAULT_SCHEMA, "list_last", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'last')"},
    {DEFAULT_SCHEMA, "list_first", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'first')"},
    {DEFAULT_SCHEMA, "list_any_value", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'any_value')"},
    {DEFAULT_SCHEMA, "list_kurtosis", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'kurtosis')"},
    {DEFAULT_SCHEMA, "list_kurtosis_pop", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'kurtosis_pop')"},
    {DEFAULT_SCHEMA, "list_min", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'min')"},
    {DEFAULT_SCHEMA, "list_max", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'max')"},
    {DEFAULT_SCHEMA, "list_product", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'product')"},
    {DEFAULT_SCHEMA, "list_skewness", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'skewness')"},
    {DEFAULT_SCHEMA, "list_sum", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'sum')"},
    {DEFAULT_SCHEMA, "list_string_agg", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'string_agg')"},
 
    // holistic list aggregates
    {DEFAULT_SCHEMA, "list_mode", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'mode')"},
    {DEFAULT_SCHEMA, "list_median", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'median')"},
    {DEFAULT_SCHEMA, "list_mad", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'mad')"},
 
    // nested list aggregates
    {DEFAULT_SCHEMA, "list_histogram", {"l", nullptr}, {{nullptr, nullptr}}, "list_aggr(l, 'histogram')"},
 
    // map functions
    {DEFAULT_SCHEMA, "map_contains_entry", {"map", "key", "value"}, {{nullptr, nullptr}}, "contains(map_entries(map), {'key': key, 'value': value})"},
    {DEFAULT_SCHEMA, "map_contains_value", {"map", "value", nullptr}, {{nullptr, nullptr}}, "contains(map_values(map), value)"},
 
    // date functions
    {DEFAULT_SCHEMA, "date_add", {"date", "interval", nullptr}, {{nullptr, nullptr}}, "date + interval"},
 
    // date functions - convenience macro for getting days in month
    {DEFAULT_SCHEMA, "days_in_month", {"date", nullptr}, {{nullptr, nullptr}}, "day(last_day(date))"},
 
    // timestamptz functions
    {DEFAULT_SCHEMA, "ago", {"i", nullptr}, {{nullptr, nullptr}}, "current_timestamp - i::interval"},
 
    // regexp functions
    {DEFAULT_SCHEMA, "regexp_split_to_table", {"text", "pattern", nullptr}, {{nullptr, nullptr}}, "unnest(string_split_regex(text, pattern))"},
 
    // storage helper functions
    {DEFAULT_SCHEMA, "get_block_size", {"db_name"}, {{nullptr, nullptr}}, "(SELECT block_size FROM pragma_database_size() WHERE database_name = db_name)"},
 
    // string functions
    {DEFAULT_SCHEMA, "md5_number_upper", {"param"}, {{nullptr, nullptr}}, "((md5_number(param)::bit::varchar)[65:])::bit::uint64"},
    {DEFAULT_SCHEMA, "md5_number_lower", {"param"}, {{nullptr, nullptr}}, "((md5_number(param)::bit::varchar)[:64])::bit::uint64"},
 
    {nullptr, nullptr, {nullptr}, {{nullptr, nullptr}}, nullptr}
    };

◆ internal_schemas

const DefaultSchema duckdb::internal_schemas[] = {{"information_schema"}, {"pg_catalog"}, {nullptr}}

staticprivate

24303{{"information_schema"}, {"pg_catalog"}, {nullptr}};

◆ internal_table_macros

const DefaultTableMacro duckdb::internal_table_macros[]

static

                                                         {
    {DEFAULT_SCHEMA, "histogram_values", {"source", "col_name", nullptr}, {{"bin_count", "10"}, {"technique", "'auto'"}, {nullptr, nullptr}},  R"(
WITH bins AS (
   SELECT
      CASE
      WHEN (NOT (can_cast_implicitly(MIN(col_name), NULL::BIGINT) OR
            can_cast_implicitly(MIN(col_name), NULL::DOUBLE) OR
            can_cast_implicitly(MIN(col_name), NULL::TIMESTAMP)) AND technique='auto')
            OR technique='sample'
      THEN
         approx_top_k(col_name, bin_count)
      WHEN technique='equi-height'
      THEN
         quantile(col_name, [x / bin_count::DOUBLE for x in generate_series(1, bin_count)])
      WHEN technique='equi-width'
      THEN
         equi_width_bins(MIN(col_name), MAX(col_name), bin_count, false)
      WHEN technique='equi-width-nice' OR technique='auto'
      THEN
         equi_width_bins(MIN(col_name), MAX(col_name), bin_count, true)
      ELSE
         error(concat('Unrecognized technique ', technique))
      END AS bins
   FROM query_table(source::VARCHAR)
   )
SELECT UNNEST(map_keys(histogram)) AS bin, UNNEST(map_values(histogram)) AS count
FROM (
   SELECT CASE
      WHEN (NOT (can_cast_implicitly(MIN(col_name), NULL::BIGINT) OR
            can_cast_implicitly(MIN(col_name), NULL::DOUBLE) OR
            can_cast_implicitly(MIN(col_name), NULL::TIMESTAMP)) AND technique='auto')
            OR technique='sample'
      THEN
            histogram_exact(col_name, bins)
      ELSE
            histogram(col_name, bins)
      END AS histogram
   FROM query_table(source::VARCHAR), bins
);
)"},
    {DEFAULT_SCHEMA, "histogram", {"source", "col_name", nullptr}, {{"bin_count", "10"}, {"technique", "'auto'"}, {nullptr, nullptr}},  R"(
SELECT
   CASE
   WHEN is_histogram_other_bin(bin)
   THEN '(other values)'
   WHEN (NOT (can_cast_implicitly(bin, NULL::BIGINT) OR
              can_cast_implicitly(bin, NULL::DOUBLE) OR
              can_cast_implicitly(bin, NULL::TIMESTAMP)) AND technique='auto')
              OR technique='sample'
   THEN bin::VARCHAR
   WHEN row_number() over () = 1
   THEN concat('x <= ', bin::VARCHAR)
   ELSE concat(lag(bin::VARCHAR) over (), ' < x <= ', bin::VARCHAR)
   END AS bin,
   count,
   bar(count, 0, max(count) over ()) AS bar
FROM histogram_values(source, col_name, bin_count := bin_count, technique := technique);
)"},
    {DEFAULT_SCHEMA, "duckdb_logs_parsed", {"log_type"}, {}, R"(
SELECT * EXCLUDE (message), UNNEST(parse_duckdb_log_message(log_type, message))
FROM duckdb_logs(denormalized_table=1)
WHERE type ILIKE log_type
)"},
    {DEFAULT_SCHEMA, "duckdb_profiling_settings", {}, {}, R"(
SELECT * EXCLUDE(input_type, scope, aliases)
  FROM duckdb_settings()
  WHERE name IN (
      'enable_profiling',
      'profiling_coverage',
      'profiling_output',
      'profiling_mode',
      'custom_profiling_settings'
  );
)"},
    {nullptr, nullptr, {nullptr}, {{nullptr, nullptr}}, nullptr}
    };

◆ internal_views

const DefaultView duckdb::internal_views[]

static

                                            {
    {DEFAULT_SCHEMA, "pragma_database_list", "SELECT database_oid AS seq, database_name AS name, path AS file FROM duckdb_databases() WHERE NOT internal ORDER BY 1"},
    {DEFAULT_SCHEMA, "sqlite_master", "select 'table' \"type\", table_name \"name\", table_name \"tbl_name\", 0 rootpage, sql from duckdb_tables union all select 'view' \"type\", view_name \"name\", view_name \"tbl_name\", 0 rootpage, sql from duckdb_views union all select 'index' \"type\", index_name \"name\", table_name \"tbl_name\", 0 rootpage, sql from duckdb_indexes;"},
    {DEFAULT_SCHEMA, "sqlite_schema", "SELECT * FROM sqlite_master"},
    {DEFAULT_SCHEMA, "sqlite_temp_master", "SELECT * FROM sqlite_master"},
    {DEFAULT_SCHEMA, "sqlite_temp_schema", "SELECT * FROM sqlite_master"},
    {DEFAULT_SCHEMA, "duckdb_constraints", "SELECT * FROM duckdb_constraints()"},
    {DEFAULT_SCHEMA, "duckdb_columns", "SELECT * FROM duckdb_columns() WHERE NOT internal"},
    {DEFAULT_SCHEMA, "duckdb_databases", "SELECT * FROM duckdb_databases() WHERE NOT internal"},
    {DEFAULT_SCHEMA, "duckdb_indexes", "SELECT * FROM duckdb_indexes()"},
    {DEFAULT_SCHEMA, "duckdb_schemas", "SELECT * FROM duckdb_schemas() WHERE NOT internal"},
    {DEFAULT_SCHEMA, "duckdb_tables", "SELECT * FROM duckdb_tables() WHERE NOT internal"},
    {DEFAULT_SCHEMA, "duckdb_types", "SELECT * FROM duckdb_types()"},
    {DEFAULT_SCHEMA, "duckdb_views", "SELECT * FROM duckdb_views() WHERE NOT internal"},
    {DEFAULT_SCHEMA, "duckdb_logs", "SELECT * FROM duckdb_logs(denormalized_table=true)"},
    {"pg_catalog", "pg_am", "SELECT 0 oid, 'art' amname, NULL amhandler, 'i' amtype"},
    {"pg_catalog", "pg_prepared_statements", "SELECT name, statement, NULL prepare_time, parameter_types, result_types, NULL from_sql, NULL generic_plans, NULL custom_plans from duckdb_prepared_statements()"},
    {"pg_catalog", "pg_attribute", "SELECT table_oid attrelid, column_name attname, data_type_id atttypid, 0 attstattarget, NULL attlen, column_index attnum, 0 attndims, -1 attcacheoff, case when data_type ilike '%decimal%' then numeric_precision*1000+numeric_scale else -1 end atttypmod, false attbyval, NULL attstorage, NULL attalign, NOT is_nullable attnotnull, column_default IS NOT NULL atthasdef, false atthasmissing, '' attidentity, '' attgenerated, false attisdropped, true attislocal, 0 attinhcount, 0 attcollation, NULL attcompression, NULL attacl, NULL attoptions, NULL attfdwoptions, NULL attmissingval FROM duckdb_columns()"},
    {"pg_catalog", "pg_attrdef", "SELECT column_index oid, table_oid adrelid, column_index adnum, column_default adbin from duckdb_columns() where column_default is not null;"},
    {"pg_catalog", "pg_class", "SELECT table_oid oid, table_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, estimated_size::real reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, index_count > 0 relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'r' relkind, column_count relnatts, check_constraint_count relchecks, false relhasoids, has_primary_key relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_tables() UNION ALL SELECT view_oid oid, view_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'v' relkind, column_count relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_views() UNION ALL SELECT sequence_oid oid, sequence_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'S' relkind, 0 relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_sequences() UNION ALL SELECT index_oid oid, index_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, 't' relpersistence, 'i' relkind, NULL relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_indexes()"},
    {"pg_catalog", "pg_constraint", "SELECT table_oid*1000000+constraint_index oid, constraint_text conname, schema_oid connamespace, CASE constraint_type WHEN 'CHECK' then 'c' WHEN 'UNIQUE' then 'u' WHEN 'PRIMARY KEY' THEN 'p' WHEN 'FOREIGN KEY' THEN 'f' ELSE 'x' END contype, false condeferrable, false condeferred, true convalidated, table_oid conrelid, 0 contypid, 0 conindid, 0 conparentid, 0 confrelid, NULL confupdtype, NULL confdeltype, NULL confmatchtype, true conislocal, 0 coninhcount, false connoinherit, constraint_column_indexes conkey, NULL confkey, NULL conpfeqop, NULL conppeqop, NULL conffeqop, NULL conexclop, expression conbin FROM duckdb_constraints()"},
    {"pg_catalog", "pg_database", "SELECT database_oid oid, database_name datname FROM duckdb_databases()"},
    {"pg_catalog", "pg_depend", "SELECT * FROM duckdb_dependencies()"},
    {"pg_catalog", "pg_description", "SELECT table_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_tables() WHERE NOT internal UNION ALL SELECT table_oid AS objoid, database_oid AS classoid, column_index AS objsubid, comment AS description FROM duckdb_columns() WHERE NOT internal UNION ALL SELECT view_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_views() WHERE NOT internal UNION ALL SELECT index_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_indexes UNION ALL SELECT sequence_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_sequences() UNION ALL SELECT type_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_types() WHERE NOT internal UNION ALL SELECT function_oid AS objoid, database_oid AS classoid, 0 AS objsubid, comment AS description FROM duckdb_functions() WHERE NOT internal;"},
    {"pg_catalog", "pg_enum", "SELECT NULL oid, a.type_oid enumtypid, list_position(b.labels, a.elabel) enumsortorder, a.elabel enumlabel FROM (SELECT UNNEST(labels) elabel, type_oid FROM duckdb_types() WHERE logical_type='ENUM') a JOIN duckdb_types() b ON a.type_oid=b.type_oid;"},
    {"pg_catalog", "pg_index", "SELECT index_oid indexrelid, table_oid indrelid, 0 indnatts, 0 indnkeyatts, is_unique indisunique, is_primary indisprimary, false indisexclusion, true indimmediate, false indisclustered, true indisvalid, false indcheckxmin, true indisready, true indislive, false indisreplident, NULL::INT[] indkey, NULL::OID[] indcollation, NULL::OID[] indclass, NULL::INT[] indoption, expressions indexprs, NULL indpred FROM duckdb_indexes()"},
    {"pg_catalog", "pg_indexes", "SELECT schema_name schemaname, table_name tablename, index_name indexname, NULL \"tablespace\", sql indexdef FROM duckdb_indexes()"},
    {"pg_catalog", "pg_namespace", "SELECT oid, schema_name nspname, 0 nspowner, NULL nspacl FROM duckdb_schemas() where database_name=current_database()"},
    {"pg_catalog", "pg_proc", "SELECT f.function_oid oid, function_name proname, s.oid pronamespace,  NULL proowner, NULL prolang, 0 procost, 0 prorows, varargs provariadic,  0 prosupport, CASE function_type WHEN 'aggregate' THEN 'a' ELSE 'f' END prokind, false prosecdef, false proleakproof, false proisstrict, function_type = 'table' proretset,  case (stability) when 'CONSISTENT' then 'i' when 'CONSISTENT_WITHIN_QUERY' then 's' when 'VOLATILE' then 'v' end provolatile, 'u' proparallel, length(parameters)  pronargs, 0 pronargdefaults, return_type prorettype,  parameter_types proargtypes,  NULL proallargtypes, NULL proargmodes, parameters proargnames, NULL proargdefaults, NULL protrftypes, NULL prosrc, NULL probin, macro_definition prosqlbody, NULL proconfig, NULL proacl, function_type = 'aggregate' proisagg,  FROM duckdb_functions() f LEFT JOIN duckdb_schemas() s USING (database_name, schema_name)"},
    {"pg_catalog", "pg_sequence", "SELECT sequence_oid seqrelid, 0 seqtypid, start_value seqstart, increment_by seqincrement, max_value seqmax, min_value seqmin, 0 seqcache, cycle seqcycle FROM duckdb_sequences()"},
    {"pg_catalog", "pg_sequences", "SELECT schema_name schemaname, sequence_name sequencename, 'duckdb' sequenceowner, 0 data_type, start_value, min_value, max_value, increment_by, cycle, 0 cache_size, last_value FROM duckdb_sequences()"},
    {"pg_catalog", "pg_settings", "SELECT name, value setting, description short_desc, CASE WHEN input_type = 'VARCHAR' THEN 'string' WHEN input_type = 'BOOLEAN' THEN 'bool' WHEN input_type IN ('BIGINT', 'UBIGINT') THEN 'integer' ELSE input_type END vartype FROM duckdb_settings()"},
    {"pg_catalog", "pg_tables", "SELECT schema_name schemaname, table_name tablename, 'duckdb' tableowner, NULL \"tablespace\", index_count > 0 hasindexes, false hasrules, false hastriggers FROM duckdb_tables()"},
    {"pg_catalog", "pg_tablespace", "SELECT 0 oid, 'pg_default' spcname, 0 spcowner, NULL spcacl, NULL spcoptions"},
    {"pg_catalog", "pg_type", "SELECT CASE WHEN type_oid IS NULL THEN NULL WHEN logical_type = 'ENUM' AND type_name <> 'enum' THEN type_oid ELSE map_to_pg_oid(type_name) END oid, format_pg_type(logical_type, type_name) typname, schema_oid typnamespace, 0 typowner, type_size typlen, false typbyval, CASE WHEN logical_type='ENUM' THEN 'e' else 'b' end typtype, CASE WHEN type_category='NUMERIC' THEN 'N' WHEN type_category='STRING' THEN 'S' WHEN type_category='DATETIME' THEN 'D' WHEN type_category='BOOLEAN' THEN 'B' WHEN type_category='COMPOSITE' THEN 'C' WHEN type_category='USER' THEN 'U' ELSE 'X' END typcategory, false typispreferred, true typisdefined, NULL typdelim, NULL typrelid, NULL typsubscript, NULL typelem, NULL typarray, NULL typinput, NULL typoutput, NULL typreceive, NULL typsend, NULL typmodin, NULL typmodout, NULL typanalyze, 'd' typalign, 'p' typstorage, NULL typnotnull, NULL typbasetype, NULL typtypmod, NULL typndims, NULL typcollation, NULL typdefaultbin, NULL typdefault, NULL typacl FROM duckdb_types() WHERE type_oid IS NOT NULL;"},
    {"pg_catalog", "pg_views", "SELECT schema_name schemaname, view_name viewname, 'duckdb' viewowner, sql definition FROM duckdb_views()"},
    {"information_schema", "columns", "SELECT database_name table_catalog, schema_name table_schema, table_name, column_name, column_index ordinal_position, column_default, CASE WHEN is_nullable THEN 'YES' ELSE 'NO' END is_nullable, data_type, character_maximum_length, NULL::INT character_octet_length, numeric_precision, numeric_precision_radix, numeric_scale, NULL::INT datetime_precision, NULL::VARCHAR interval_type, NULL::INT interval_precision, NULL::VARCHAR character_set_catalog, NULL::VARCHAR character_set_schema, NULL::VARCHAR character_set_name, NULL::VARCHAR collation_catalog, NULL::VARCHAR collation_schema, NULL::VARCHAR collation_name, NULL::VARCHAR domain_catalog, NULL::VARCHAR domain_schema, NULL::VARCHAR domain_name, NULL::VARCHAR udt_catalog, NULL::VARCHAR udt_schema, NULL::VARCHAR udt_name, NULL::VARCHAR scope_catalog, NULL::VARCHAR scope_schema, NULL::VARCHAR scope_name, NULL::BIGINT maximum_cardinality, NULL::VARCHAR dtd_identifier, NULL::BOOL is_self_referencing, NULL::BOOL is_identity, NULL::VARCHAR identity_generation, NULL::VARCHAR identity_start, NULL::VARCHAR identity_increment, NULL::VARCHAR identity_maximum, NULL::VARCHAR identity_minimum, NULL::BOOL identity_cycle, NULL::VARCHAR is_generated, NULL::VARCHAR generation_expression, NULL::BOOL is_updatable, comment AS COLUMN_COMMENT FROM duckdb_columns;"},
    {"information_schema", "schemata", "SELECT database_name catalog_name, schema_name, 'duckdb' schema_owner, NULL::VARCHAR default_character_set_catalog, NULL::VARCHAR default_character_set_schema, NULL::VARCHAR default_character_set_name, sql sql_path FROM duckdb_schemas()"},
    {"information_schema", "tables", "SELECT database_name table_catalog, schema_name table_schema, table_name, CASE WHEN temporary THEN 'LOCAL TEMPORARY' ELSE 'BASE TABLE' END table_type, NULL::VARCHAR self_referencing_column_name, NULL::VARCHAR reference_generation, NULL::VARCHAR user_defined_type_catalog, NULL::VARCHAR user_defined_type_schema, NULL::VARCHAR user_defined_type_name, 'YES' is_insertable_into, 'NO' is_typed, CASE WHEN temporary THEN 'PRESERVE' ELSE NULL END commit_action, comment AS TABLE_COMMENT FROM duckdb_tables() UNION ALL SELECT database_name table_catalog, schema_name table_schema, view_name table_name, 'VIEW' table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'NO' is_insertable_into, 'NO' is_typed, NULL commit_action, comment AS TABLE_COMMENT FROM duckdb_views;"},
    {"information_schema", "character_sets", "SELECT NULL::VARCHAR character_set_catalog, NULL::VARCHAR character_set_schema, 'UTF8' character_set_name, 'UCS' character_repertoire, 'UTF8' form_of_use, current_database() default_collate_catalog, 'pg_catalog' default_collate_schema, 'ucs_basic' default_collate_name;"},
    {"information_schema", "referential_constraints", "SELECT f.database_name constraint_catalog, f.schema_name constraint_schema, f.constraint_name constraint_name, c.database_name unique_constraint_catalog, c.schema_name unique_constraint_schema, c.constraint_name unique_constraint_name, 'NONE' match_option, 'NO ACTION' update_rule, 'NO ACTION' delete_rule FROM duckdb_constraints() c, duckdb_constraints() f WHERE f.constraint_type = 'FOREIGN KEY' AND (c.constraint_type = 'UNIQUE' OR c.constraint_type = 'PRIMARY KEY') AND f.database_oid = c.database_oid AND f.schema_oid = c.schema_oid AND lower(f.referenced_table) = lower(c.table_name) AND [lower(x) for x in f.referenced_column_names] = [lower(x) for x in c.constraint_column_names]"},
    {"information_schema", "key_column_usage", "SELECT database_name constraint_catalog, schema_name constraint_schema, constraint_name, database_name table_catalog, schema_name table_schema, table_name, UNNEST(constraint_column_names) column_name, UNNEST(generate_series(1, len(constraint_column_names))) ordinal_position, CASE constraint_type WHEN 'FOREIGN KEY' THEN UNNEST (generate_series(1, len(constraint_column_names))) ELSE NULL END position_in_unique_constraint FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY' OR constraint_type = 'PRIMARY KEY' OR constraint_type = 'UNIQUE';"},
    {"information_schema", "table_constraints", "SELECT database_name constraint_catalog, schema_name constraint_schema, constraint_name, database_name table_catalog, schema_name table_schema, table_name, CASE constraint_type WHEN 'NOT NULL' THEN 'CHECK' ELSE constraint_type END constraint_type, 'NO' is_deferrable, 'NO' initially_deferred, 'YES' enforced, 'YES' nulls_distinct FROM duckdb_constraints() WHERE constraint_type = 'PRIMARY KEY' OR constraint_type = 'FOREIGN KEY' OR constraint_type = 'UNIQUE' OR constraint_type = 'CHECK' OR constraint_type = 'NOT NULL';"},
    {"information_schema", "constraint_column_usage", "SELECT database_name AS table_catalog, schema_name AS table_schema, table_name, column_name, database_name AS constraint_catalog, schema_name AS constraint_schema, constraint_name, constraint_type, constraint_text FROM (SELECT dc.*, UNNEST(dc.constraint_column_names) AS column_name FROM duckdb_constraints() AS dc WHERE constraint_type NOT IN ('NOT NULL') );"},
    {"information_schema", "constraint_table_usage", "SELECT database_name AS table_catalog, schema_name AS table_schema, table_name, database_name AS constraint_catalog, schema_name AS constraint_schema, constraint_name, constraint_type FROM duckdb_constraints() WHERE constraint_type NOT IN ('NOT NULL');"},
    {"information_schema", "check_constraints", "SELECT database_name AS constraint_catalog, schema_name AS constraint_schema, constraint_name, CASE constraint_type WHEN 'NOT NULL' THEN column_name || ' IS NOT NULL' ELSE constraint_text END AS check_clause FROM (SELECT dc.*, UNNEST(dc.constraint_column_names) AS column_name FROM duckdb_constraints() AS dc WHERE constraint_type IN ('CHECK', 'NOT NULL'));"},
    {"information_schema", "views", "SELECT database_name AS table_catalog, schema_name AS table_schema, view_name AS table_name, sql AS view_definition, 'NONE' AS check_option, 'NO' AS is_updatable, 'NO' AS is_insertable_into, 'NO' AS is_trigger_updatable, 'NO' AS is_trigger_deletable, 'NO' AS is_trigger_insertable_into FROM duckdb_views();"},
    {nullptr, nullptr, nullptr}};

◆ str_nil

constexpr const char duckdb::str_nil[4] = {'\200', '\0', '\0', '\0'}

constexpr

This could be two bytes but then GCC gives a warning when it's copied.

30958{'\200', '\0', '\0', '\0'};

◆ internal_optimizer_types

const DefaultOptimizerType duckdb::internal_optimizer_types[]

staticprivate

                                                               {
    {"expression_rewriter", OptimizerType::EXPRESSION_REWRITER},
    {"filter_pullup", OptimizerType::FILTER_PULLUP},
    {"filter_pushdown", OptimizerType::FILTER_PUSHDOWN},
    {"empty_result_pullup", OptimizerType::EMPTY_RESULT_PULLUP},
    {"cte_filter_pusher", OptimizerType::CTE_FILTER_PUSHER},
    {"regex_range", OptimizerType::REGEX_RANGE},
    {"in_clause", OptimizerType::IN_CLAUSE},
    {"join_order", OptimizerType::JOIN_ORDER},
    {"deliminator", OptimizerType::DELIMINATOR},
    {"unnest_rewriter", OptimizerType::UNNEST_REWRITER},
    {"unused_columns", OptimizerType::UNUSED_COLUMNS},
    {"statistics_propagation", OptimizerType::STATISTICS_PROPAGATION},
    {"common_subexpressions", OptimizerType::COMMON_SUBEXPRESSIONS},
    {"common_aggregate", OptimizerType::COMMON_AGGREGATE},
    {"column_lifetime", OptimizerType::COLUMN_LIFETIME},
    {"limit_pushdown", OptimizerType::LIMIT_PUSHDOWN},
    {"row_group_pruner", OptimizerType::ROW_GROUP_PRUNER},
    {"top_n", OptimizerType::TOP_N},
    {"top_n_window_elimination", OptimizerType::TOP_N_WINDOW_ELIMINATION},
    {"build_side_probe_side", OptimizerType::BUILD_SIDE_PROBE_SIDE},
    {"compressed_materialization", OptimizerType::COMPRESSED_MATERIALIZATION},
    {"duplicate_groups", OptimizerType::DUPLICATE_GROUPS},
    {"reorder_filter", OptimizerType::REORDER_FILTER},
    {"sampling_pushdown", OptimizerType::SAMPLING_PUSHDOWN},
    {"join_filter_pushdown", OptimizerType::JOIN_FILTER_PUSHDOWN},
    {"extension", OptimizerType::EXTENSION},
    {"materialized_cte", OptimizerType::MATERIALIZED_CTE},
    {"sum_rewriter", OptimizerType::SUM_REWRITER},
    {"late_materialization", OptimizerType::LATE_MATERIALIZATION},
    {"cte_inlining", OptimizerType::CTE_INLINING},
    {"common_subplan", OptimizerType::COMMON_SUBPLAN},
    {"join_elimination", OptimizerType::JOIN_ELIMINATION},
    {"window_self_join", OptimizerType::WINDOW_SELF_JOIN},
    {nullptr, OptimizerType::INVALID}};

◆ EXCEPTION_MAP

constexpr ExceptionEntry duckdb::EXCEPTION_MAP[]

staticconstexpr

                                                  {{ExceptionType::INVALID, "Invalid"},
                                                   {ExceptionType::OUT_OF_RANGE, "Out of Range"},
                                                   {ExceptionType::CONVERSION, "Conversion"},
                                                   {ExceptionType::UNKNOWN_TYPE, "Unknown Type"},
                                                   {ExceptionType::DECIMAL, "Decimal"},
                                                   {ExceptionType::MISMATCH_TYPE, "Mismatch Type"},
                                                   {ExceptionType::DIVIDE_BY_ZERO, "Divide by Zero"},
                                                   {ExceptionType::OBJECT_SIZE, "Object Size"},
                                                   {ExceptionType::INVALID_TYPE, "Invalid type"},
                                                   {ExceptionType::SERIALIZATION, "Serialization"},
                                                   {ExceptionType::TRANSACTION, "TransactionContext"},
                                                   {ExceptionType::NOT_IMPLEMENTED, "Not implemented"},
                                                   {ExceptionType::EXPRESSION, "Expression"},
                                                   {ExceptionType::CATALOG, "Catalog"},
                                                   {ExceptionType::PARSER, "Parser"},
                                                   {ExceptionType::BINDER, "Binder"},
                                                   {ExceptionType::PLANNER, "Planner"},
                                                   {ExceptionType::SCHEDULER, "Scheduler"},
                                                   {ExceptionType::EXECUTOR, "Executor"},
                                                   {ExceptionType::CONSTRAINT, "Constraint"},
                                                   {ExceptionType::INDEX, "Index"},
                                                   {ExceptionType::STAT, "Stat"},
                                                   {ExceptionType::CONNECTION, "Connection"},
                                                   {ExceptionType::SYNTAX, "Syntax"},
                                                   {ExceptionType::SETTINGS, "Settings"},
                                                   {ExceptionType::OPTIMIZER, "Optimizer"},
                                                   {ExceptionType::NULL_POINTER, "NullPointer"},
                                                   {ExceptionType::IO, "IO"},
                                                   {ExceptionType::INTERRUPT, "INTERRUPT"},
                                                   {ExceptionType::FATAL, "FATAL"},
                                                   {ExceptionType::INTERNAL, "INTERNAL"},
                                                   {ExceptionType::INVALID_INPUT, "Invalid Input"},
                                                   {ExceptionType::OUT_OF_MEMORY, "Out of Memory"},
                                                   {ExceptionType::PERMISSION, "Permission"},
                                                   {ExceptionType::PARAMETER_NOT_RESOLVED, "Parameter Not Resolved"},
                                                   {ExceptionType::PARAMETER_NOT_ALLOWED, "Parameter Not Allowed"},
                                                   {ExceptionType::DEPENDENCY, "Dependency"},
                                                   {ExceptionType::MISSING_EXTENSION, "Missing Extension"},
                                                   {ExceptionType::HTTP, "HTTP"},
                                                   {ExceptionType::AUTOLOAD, "Extension Autoloading"},
                                                   {ExceptionType::SEQUENCE, "Sequence"},
                                                   {ExceptionType::INVALID_CONFIGURATION, "Invalid Configuration"}};

◆ GZIP_FLAG_UNSUPPORTED

constexpr const unsigned char duckdb::GZIP_FLAG_UNSUPPORTED

staticconstexpr

Initial value:

=

GZIP_FLAG_ASCII | GZIP_FLAG_MULTIPART | GZIP_FLAG_COMMENT | GZIP_FLAG_ENCRYPT

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ compression_init_analyze_t

◆ compression_skip_t

Enumeration Type Documentation

◆ CatalogSetPathType

◆ CollationType

◆ BindingType

◆ CTEType

◆ ColumnBindType

◆ StarExpressionType

◆ BindingMode

◆ BinderType

◆ MacroType

◆ ViewBindState

◆ BindViewAction

◆ ExtensionLoadResult

◆ ExtensionUpdateResultTag

◆ ExtraDropInfoType

◆ DependencyEntryType

◆ UndoFlags

◆ ActiveTransactionState

◆ WALType

◆ WALInitState

◆ CompressInMemory

◆ PartialBlockType

◆ NType

◆ GateStatus

◆ VerifyExistenceType

◆ ARTConflictType

◆ ARTHandlingResult

◆ AlterScalarFunctionType

◆ CoordinateReferenceSystemType

◆ ExtraTypeInfoType

◆ EnumDictType

◆ AlterTableFunctionType

◆ AllowParserOverride

◆ ParserExtensionResultType

◆ ValueRenderAlignment

◆ RenderMode

◆ ResultRenderType

◆ LargeNumberRendering

◆ AbsoluteNumberComparison

◆ UnicodeType

◆ UnicodeInvalidReason

◆ RenderRowType

◆ JSONFormattingMode

◆ JSONComponentType

◆ JSONFormattingResult

◆ CSVNewLineMode

◆ AggregateHandling

◆ CheckpointAbort

◆ CopyOverwriteMode

◆ DatePartSpecifier

◆ DeprecatedUsingKeySyntax

◆ HTTPStatusCode

◆ MergeActionType

◆ MergeActionCondition

◆ OrdinalityType

◆ PreserveOrderType

◆ QuantileSerializationType

◆ SetType

◆ StorageBlockPrefetch

◆ SubqueryType

◆ TupleDataValidityType

◆ TupleDataNestednessType

◆ WindowAggregationMode

◆ FileNameSegmentType

◆ RequestType

◆ MultiFileFileState

◆ FileExpandResult

◆ MultiFileListScanType

◆ FileExpansionType

◆ ExponentType

◆ SortKeyType