#include "duckdb/common/enum_util.hpp"

#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"

#include "duckdb/catalog/catalog_entry/table_column_type.hpp"

#include "duckdb/common/box_renderer.hpp"

#include "duckdb/common/enums/access_mode.hpp"

#include "duckdb/common/enums/aggregate_handling.hpp"

#include "duckdb/common/enums/catalog_lookup_behavior.hpp"

#include "duckdb/common/enums/catalog_type.hpp"

#include "duckdb/common/enums/compression_type.hpp"

#include "duckdb/common/enums/copy_overwrite_mode.hpp"

#include "duckdb/common/enums/cte_materialize.hpp"

#include "duckdb/common/enums/date_part_specifier.hpp"

#include "duckdb/common/enums/debug_initialize.hpp"

#include "duckdb/common/enums/debug_vector_verification.hpp"

#include "duckdb/common/enums/destroy_buffer_upon.hpp"

#include "duckdb/common/enums/explain_format.hpp"

#include "duckdb/common/enums/expression_type.hpp"

#include "duckdb/common/enums/file_compression_type.hpp"

#include "duckdb/common/enums/file_glob_options.hpp"

#include "duckdb/common/enums/filter_propagate_result.hpp"

#include "duckdb/common/enums/function_errors.hpp"

#include "duckdb/common/enums/http_status_code.hpp"

#include "duckdb/common/enums/index_constraint_type.hpp"

#include "duckdb/common/enums/join_type.hpp"

#include "duckdb/common/enums/joinref_type.hpp"

#include "duckdb/common/enums/logical_operator_type.hpp"

#include "duckdb/common/enums/memory_tag.hpp"

#include "duckdb/common/enums/metric_type.hpp"

#include "duckdb/common/enums/on_create_conflict.hpp"

#include "duckdb/common/enums/on_entry_not_found.hpp"

#include "duckdb/common/enums/operator_result_type.hpp"

#include "duckdb/common/enums/optimizer_type.hpp"

#include "duckdb/common/enums/order_preservation_type.hpp"

#include "duckdb/common/enums/order_type.hpp"

#include "duckdb/common/enums/output_type.hpp"

#include "duckdb/common/enums/pending_execution_result.hpp"

#include "duckdb/common/enums/physical_operator_type.hpp"

#include "duckdb/common/enums/prepared_statement_mode.hpp"

#include "duckdb/common/enums/preserve_order.hpp"

#include "duckdb/common/enums/profiler_format.hpp"

#include "duckdb/common/enums/quantile_enum.hpp"

#include "duckdb/common/enums/relation_type.hpp"

#include "duckdb/common/enums/scan_options.hpp"

#include "duckdb/common/enums/set_operation_type.hpp"

#include "duckdb/common/enums/set_scope.hpp"

#include "duckdb/common/enums/set_type.hpp"

#include "duckdb/common/enums/statement_type.hpp"

#include "duckdb/common/enums/stream_execution_result.hpp"

#include "duckdb/common/enums/subquery_type.hpp"

#include "duckdb/common/enums/tableref_type.hpp"

#include "duckdb/common/enums/undo_flags.hpp"

#include "duckdb/common/enums/vector_type.hpp"

#include "duckdb/common/enums/wal_type.hpp"

#include "duckdb/common/enums/window_aggregation_mode.hpp"

#include "duckdb/common/exception.hpp"

#include "duckdb/common/exception_format_value.hpp"

#include "duckdb/common/extra_type_info.hpp"

#include "duckdb/common/file_buffer.hpp"

#include "duckdb/common/file_open_flags.hpp"

#include "duckdb/common/filename_pattern.hpp"

#include "duckdb/common/http_util.hpp"

#include "duckdb/common/multi_file/multi_file_data.hpp"

#include "duckdb/common/multi_file/multi_file_list.hpp"

#include "duckdb/common/multi_file/multi_file_options.hpp"

#include "duckdb/common/operator/decimal_cast_operators.hpp"

#include "duckdb/common/printer.hpp"

#include "duckdb/common/sort/partition_state.hpp"

#include "duckdb/common/types.hpp"

#include "duckdb/common/types/column/column_data_scan_states.hpp"

#include "duckdb/common/types/column/partitioned_column_data.hpp"

#include "duckdb/common/types/conflict_manager.hpp"

#include "duckdb/common/types/date.hpp"

#include "duckdb/common/types/hyperloglog.hpp"

#include "duckdb/common/types/row/partitioned_tuple_data.hpp"

#include "duckdb/common/types/row/tuple_data_states.hpp"

#include "duckdb/common/types/timestamp.hpp"

#include "duckdb/common/types/vector.hpp"

#include "duckdb/common/types/vector_buffer.hpp"

#include "duckdb/execution/index/art/art.hpp"

#include "duckdb/execution/index/art/art_scanner.hpp"

#include "duckdb/execution/index/art/node.hpp"

#include "duckdb/execution/index/bound_index.hpp"

#include "duckdb/execution/operator/csv_scanner/csv_option.hpp"

#include "duckdb/execution/operator/csv_scanner/csv_state.hpp"

#include "duckdb/execution/reservoir_sample.hpp"

#include "duckdb/function/aggregate_state.hpp"

#include "duckdb/function/compression_function.hpp"

#include "duckdb/function/copy_function.hpp"

#include "duckdb/function/function.hpp"

#include "duckdb/function/macro_function.hpp"

#include "duckdb/function/partition_stats.hpp"

#include "duckdb/function/scalar/compressed_materialization_utils.hpp"

#include "duckdb/function/scalar/strftime_format.hpp"

#include "duckdb/function/table/arrow/arrow_type_info.hpp"

#include "duckdb/function/table/arrow/enum/arrow_datetime_type.hpp"

#include "duckdb/function/table/arrow/enum/arrow_type_info_type.hpp"

#include "duckdb/function/table/arrow/enum/arrow_variable_size_type.hpp"

#include "duckdb/function/table_function.hpp"

#include "duckdb/logging/logging.hpp"

#include "duckdb/main/appender.hpp"

#include "duckdb/main/capi/capi_internal.hpp"

#include "duckdb/main/client_properties.hpp"

#include "duckdb/main/config.hpp"

#include "duckdb/main/error_manager.hpp"

#include "duckdb/main/extension.hpp"

#include "duckdb/main/extension_helper.hpp"

#include "duckdb/main/extension_install_info.hpp"

#include "duckdb/main/query_result.hpp"

#include "duckdb/main/secret/secret.hpp"

#include "duckdb/main/settings.hpp"

#include "duckdb/parallel/interrupt.hpp"

#include "duckdb/parallel/meta_pipeline.hpp"

#include "duckdb/parallel/task.hpp"

#include "duckdb/parser/constraint.hpp"

#include "duckdb/parser/expression/lambda_expression.hpp"

#include "duckdb/parser/expression/parameter_expression.hpp"

#include "duckdb/parser/expression/star_expression.hpp"

#include "duckdb/parser/expression/window_expression.hpp"

#include "duckdb/parser/parsed_data/alter_info.hpp"

#include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"

#include "duckdb/parser/parsed_data/alter_table_function_info.hpp"

#include "duckdb/parser/parsed_data/alter_table_info.hpp"

#include "duckdb/parser/parsed_data/create_sequence_info.hpp"

#include "duckdb/parser/parsed_data/extra_drop_info.hpp"

#include "duckdb/parser/parsed_data/load_info.hpp"

#include "duckdb/parser/parsed_data/parse_info.hpp"

#include "duckdb/parser/parsed_data/pragma_info.hpp"

#include "duckdb/parser/parsed_data/sample_options.hpp"

#include "duckdb/parser/parsed_data/transaction_info.hpp"

#include "duckdb/parser/parser_extension.hpp"

#include "duckdb/parser/query_node.hpp"

#include "duckdb/parser/result_modifier.hpp"

#include "duckdb/parser/simplified_token.hpp"

#include "duckdb/parser/statement/copy_statement.hpp"

#include "duckdb/parser/statement/explain_statement.hpp"

#include "duckdb/parser/statement/insert_statement.hpp"

#include "duckdb/parser/tableref/showref.hpp"

#include "duckdb/planner/binder.hpp"

#include "duckdb/planner/bound_result_modifier.hpp"

#include "duckdb/planner/table_filter.hpp"

#include "duckdb/storage/buffer/block_handle.hpp"

#include "duckdb/storage/compression/bitpacking.hpp"

#include "duckdb/storage/magic_bytes.hpp"

#include "duckdb/storage/statistics/base_statistics.hpp"

#include "duckdb/storage/table/chunk_info.hpp"

#include "duckdb/storage/table/column_segment.hpp"

#include "duckdb/storage/temporary_file_manager.hpp"

#include "duckdb/verification/statement_verifier.hpp"

namespace duckdb {

const StringUtil::EnumStringLiteral *GetARTConflictTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<ARTConflictType>(ARTConflictType value) {

return StringUtil::EnumToString(GetARTConflictTypeValues(), 3, "ARTConflictType", static_cast<uint32_t>(value));

}

template<>

ARTConflictType EnumUtil::FromString<ARTConflictType>(const char *value) {

return static_cast<ARTConflictType>(StringUtil::StringToEnum(GetARTConflictTypeValues(), 3, "ARTConflictType", value));

}

const StringUtil::EnumStringLiteral *GetARTHandlingResultValues() {

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" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<ARTHandlingResult>(ARTHandlingResult value) {

return StringUtil::EnumToString(GetARTHandlingResultValues(), 3, "ARTHandlingResult", static_cast<uint32_t>(value));

}

template<>

ARTHandlingResult EnumUtil::FromString<ARTHandlingResult>(const char *value) {

return static_cast<ARTHandlingResult>(StringUtil::StringToEnum(GetARTHandlingResultValues(), 3, "ARTHandlingResult", value));

}

const StringUtil::EnumStringLiteral *GetARTScanHandlingValues() {

static constexpr StringUtil::EnumStringLiteral values[] {

{ static_cast<uint32_t>(ARTScanHandling::EMPLACE), "EMPLACE" },

{ static_cast<uint32_t>(ARTScanHandling::POP), "POP" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<ARTScanHandling>(ARTScanHandling value) {

return StringUtil::EnumToString(GetARTScanHandlingValues(), 2, "ARTScanHandling", static_cast<uint32_t>(value));

}

template<>

ARTScanHandling EnumUtil::FromString<ARTScanHandling>(const char *value) {

return static_cast<ARTScanHandling>(StringUtil::StringToEnum(GetARTScanHandlingValues(), 2, "ARTScanHandling", value));

}

const StringUtil::EnumStringLiteral *GetAccessModeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<AccessMode>(AccessMode value) {

return StringUtil::EnumToString(GetAccessModeValues(), 4, "AccessMode", static_cast<uint32_t>(value));

}

template<>

AccessMode EnumUtil::FromString<AccessMode>(const char *value) {

return static_cast<AccessMode>(StringUtil::StringToEnum(GetAccessModeValues(), 4, "AccessMode", value));

}

const StringUtil::EnumStringLiteral *GetAggregateCombineTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<AggregateCombineType>(AggregateCombineType value) {

return StringUtil::EnumToString(GetAggregateCombineTypeValues(), 2, "AggregateCombineType", static_cast<uint32_t>(value));

}

template<>

AggregateCombineType EnumUtil::FromString<AggregateCombineType>(const char *value) {

return static_cast<AggregateCombineType>(StringUtil::StringToEnum(GetAggregateCombineTypeValues(), 2, "AggregateCombineType", value));

}

const StringUtil::EnumStringLiteral *GetAggregateDistinctDependentValues() {

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;

}

template<>

const char* EnumUtil::ToChars<AggregateDistinctDependent>(AggregateDistinctDependent value) {

return StringUtil::EnumToString(GetAggregateDistinctDependentValues(), 2, "AggregateDistinctDependent", static_cast<uint32_t>(value));

}

template<>

AggregateDistinctDependent EnumUtil::FromString<AggregateDistinctDependent>(const char *value) {

return static_cast<AggregateDistinctDependent>(StringUtil::StringToEnum(GetAggregateDistinctDependentValues(), 2, "AggregateDistinctDependent", value));

}

const StringUtil::EnumStringLiteral *GetAggregateHandlingValues() {

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;

}

template<>

const char* EnumUtil::ToChars<AggregateHandling>(AggregateHandling value) {

return StringUtil::EnumToString(GetAggregateHandlingValues(), 3, "AggregateHandling", static_cast<uint32_t>(value));

}

template<>

AggregateHandling EnumUtil::FromString<AggregateHandling>(const char *value) {

return static_cast<AggregateHandling>(StringUtil::StringToEnum(GetAggregateHandlingValues(), 3, "AggregateHandling", value));

}

const StringUtil::EnumStringLiteral *GetAggregateOrderDependentValues() {

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;

}

template<>

const char* EnumUtil::ToChars<AggregateOrderDependent>(AggregateOrderDependent value) {

return StringUtil::EnumToString(GetAggregateOrderDependentValues(), 2, "AggregateOrderDependent", static_cast<uint32_t>(value));

}

template<>

AggregateOrderDependent EnumUtil::FromString<AggregateOrderDependent>(const char *value) {

return static_cast<AggregateOrderDependent>(StringUtil::StringToEnum(GetAggregateOrderDependentValues(), 2, "AggregateOrderDependent", value));

}

const StringUtil::EnumStringLiteral *GetAggregateTypeValues() {

static constexpr StringUtil::EnumStringLiteral values[] {

{ static_cast<uint32_t>(AggregateType::NON_DISTINCT), "NON_DISTINCT" },

{ static_cast<uint32_t>(AggregateType::DISTINCT), "DISTINCT" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<AggregateType>(AggregateType value) {

return StringUtil::EnumToString(GetAggregateTypeValues(), 2, "AggregateType", static_cast<uint32_t>(value));

}

template<>

AggregateType EnumUtil::FromString<AggregateType>(const char *value) {

return static_cast<AggregateType>(StringUtil::StringToEnum(GetAggregateTypeValues(), 2, "AggregateType", value));

}

const StringUtil::EnumStringLiteral *GetAlterForeignKeyTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<AlterForeignKeyType>(AlterForeignKeyType value) {

return StringUtil::EnumToString(GetAlterForeignKeyTypeValues(), 2, "AlterForeignKeyType", static_cast<uint32_t>(value));

}

template<>

AlterForeignKeyType EnumUtil::FromString<AlterForeignKeyType>(const char *value) {

return static_cast<AlterForeignKeyType>(StringUtil::StringToEnum(GetAlterForeignKeyTypeValues(), 2, "AlterForeignKeyType", value));

}

const StringUtil::EnumStringLiteral *GetAlterScalarFunctionTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<AlterScalarFunctionType>(AlterScalarFunctionType value) {

return StringUtil::EnumToString(GetAlterScalarFunctionTypeValues(), 2, "AlterScalarFunctionType", static_cast<uint32_t>(value));

}

template<>

AlterScalarFunctionType EnumUtil::FromString<AlterScalarFunctionType>(const char *value) {

return static_cast<AlterScalarFunctionType>(StringUtil::StringToEnum(GetAlterScalarFunctionTypeValues(), 2, "AlterScalarFunctionType", value));

}

const StringUtil::EnumStringLiteral *GetAlterTableFunctionTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<AlterTableFunctionType>(AlterTableFunctionType value) {

return StringUtil::EnumToString(GetAlterTableFunctionTypeValues(), 2, "AlterTableFunctionType", static_cast<uint32_t>(value));

}

template<>

AlterTableFunctionType EnumUtil::FromString<AlterTableFunctionType>(const char *value) {

return static_cast<AlterTableFunctionType>(StringUtil::StringToEnum(GetAlterTableFunctionTypeValues(), 2, "AlterTableFunctionType", value));

}

const StringUtil::EnumStringLiteral *GetAlterTableTypeValues() {

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" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<AlterTableType>(AlterTableType value) {

return StringUtil::EnumToString(GetAlterTableTypeValues(), 17, "AlterTableType", static_cast<uint32_t>(value));

}

template<>

AlterTableType EnumUtil::FromString<AlterTableType>(const char *value) {

return static_cast<AlterTableType>(StringUtil::StringToEnum(GetAlterTableTypeValues(), 17, "AlterTableType", value));

}

const StringUtil::EnumStringLiteral *GetAlterTypeValues() {

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" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<AlterType>(AlterType value) {

return StringUtil::EnumToString(GetAlterTypeValues(), 9, "AlterType", static_cast<uint32_t>(value));

}

template<>

AlterType EnumUtil::FromString<AlterType>(const char *value) {

return static_cast<AlterType>(StringUtil::StringToEnum(GetAlterTypeValues(), 9, "AlterType", value));

}

const StringUtil::EnumStringLiteral *GetAlterViewTypeValues() {

static constexpr StringUtil::EnumStringLiteral values[] {

{ static_cast<uint32_t>(AlterViewType::INVALID), "INVALID" },

{ static_cast<uint32_t>(AlterViewType::RENAME_VIEW), "RENAME_VIEW" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<AlterViewType>(AlterViewType value) {

return StringUtil::EnumToString(GetAlterViewTypeValues(), 2, "AlterViewType", static_cast<uint32_t>(value));

}

template<>

AlterViewType EnumUtil::FromString<AlterViewType>(const char *value) {

return static_cast<AlterViewType>(StringUtil::StringToEnum(GetAlterViewTypeValues(), 2, "AlterViewType", value));

}

const StringUtil::EnumStringLiteral *GetAppenderTypeValues() {

static constexpr StringUtil::EnumStringLiteral values[] {

{ static_cast<uint32_t>(AppenderType::LOGICAL), "LOGICAL" },

{ static_cast<uint32_t>(AppenderType::PHYSICAL), "PHYSICAL" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<AppenderType>(AppenderType value) {

return StringUtil::EnumToString(GetAppenderTypeValues(), 2, "AppenderType", static_cast<uint32_t>(value));

}

template<>

AppenderType EnumUtil::FromString<AppenderType>(const char *value) {

return static_cast<AppenderType>(StringUtil::StringToEnum(GetAppenderTypeValues(), 2, "AppenderType", value));

}

const StringUtil::EnumStringLiteral *GetArrowDateTimeTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<ArrowDateTimeType>(ArrowDateTimeType value) {

return StringUtil::EnumToString(GetArrowDateTimeTypeValues(), 7, "ArrowDateTimeType", static_cast<uint32_t>(value));

}

template<>

ArrowDateTimeType EnumUtil::FromString<ArrowDateTimeType>(const char *value) {

return static_cast<ArrowDateTimeType>(StringUtil::StringToEnum(GetArrowDateTimeTypeValues(), 7, "ArrowDateTimeType", value));

}

const StringUtil::EnumStringLiteral *GetArrowOffsetSizeValues() {

static constexpr StringUtil::EnumStringLiteral values[] {

{ static_cast<uint32_t>(ArrowOffsetSize::REGULAR), "REGULAR" },

{ static_cast<uint32_t>(ArrowOffsetSize::LARGE), "LARGE" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<ArrowOffsetSize>(ArrowOffsetSize value) {

return StringUtil::EnumToString(GetArrowOffsetSizeValues(), 2, "ArrowOffsetSize", static_cast<uint32_t>(value));

}

template<>

ArrowOffsetSize EnumUtil::FromString<ArrowOffsetSize>(const char *value) {

return static_cast<ArrowOffsetSize>(StringUtil::StringToEnum(GetArrowOffsetSizeValues(), 2, "ArrowOffsetSize", value));

}

const StringUtil::EnumStringLiteral *GetArrowTypeInfoTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<ArrowTypeInfoType>(ArrowTypeInfoType value) {

return StringUtil::EnumToString(GetArrowTypeInfoTypeValues(), 6, "ArrowTypeInfoType", static_cast<uint32_t>(value));

}

template<>

ArrowTypeInfoType EnumUtil::FromString<ArrowTypeInfoType>(const char *value) {

return static_cast<ArrowTypeInfoType>(StringUtil::StringToEnum(GetArrowTypeInfoTypeValues(), 6, "ArrowTypeInfoType", value));

}

const StringUtil::EnumStringLiteral *GetArrowVariableSizeTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<ArrowVariableSizeType>(ArrowVariableSizeType value) {

return StringUtil::EnumToString(GetArrowVariableSizeTypeValues(), 4, "ArrowVariableSizeType", static_cast<uint32_t>(value));

}

template<>

ArrowVariableSizeType EnumUtil::FromString<ArrowVariableSizeType>(const char *value) {

return static_cast<ArrowVariableSizeType>(StringUtil::StringToEnum(GetArrowVariableSizeTypeValues(), 4, "ArrowVariableSizeType", value));

}

const StringUtil::EnumStringLiteral *GetBinderTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<BinderType>(BinderType value) {

return StringUtil::EnumToString(GetBinderTypeValues(), 2, "BinderType", static_cast<uint32_t>(value));

}

template<>

BinderType EnumUtil::FromString<BinderType>(const char *value) {

return static_cast<BinderType>(StringUtil::StringToEnum(GetBinderTypeValues(), 2, "BinderType", value));

}

const StringUtil::EnumStringLiteral *GetBindingModeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<BindingMode>(BindingMode value) {

return StringUtil::EnumToString(GetBindingModeValues(), 4, "BindingMode", static_cast<uint32_t>(value));

}

template<>

BindingMode EnumUtil::FromString<BindingMode>(const char *value) {

return static_cast<BindingMode>(StringUtil::StringToEnum(GetBindingModeValues(), 4, "BindingMode", value));

}

const StringUtil::EnumStringLiteral *GetBitpackingModeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<BitpackingMode>(BitpackingMode value) {

return StringUtil::EnumToString(GetBitpackingModeValues(), 6, "BitpackingMode", static_cast<uint32_t>(value));

}

template<>

BitpackingMode EnumUtil::FromString<BitpackingMode>(const char *value) {

return static_cast<BitpackingMode>(StringUtil::StringToEnum(GetBitpackingModeValues(), 6, "BitpackingMode", value));

}

const StringUtil::EnumStringLiteral *GetBlockStateValues() {

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;

}

template<>

const char* EnumUtil::ToChars<BlockState>(BlockState value) {

return StringUtil::EnumToString(GetBlockStateValues(), 2, "BlockState", static_cast<uint32_t>(value));

}

template<>

BlockState EnumUtil::FromString<BlockState>(const char *value) {

return static_cast<BlockState>(StringUtil::StringToEnum(GetBlockStateValues(), 2, "BlockState", value));

}

const StringUtil::EnumStringLiteral *GetCAPIResultSetTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<CAPIResultSetType>(CAPIResultSetType value) {

return StringUtil::EnumToString(GetCAPIResultSetTypeValues(), 4, "CAPIResultSetType", static_cast<uint32_t>(value));

}

template<>

CAPIResultSetType EnumUtil::FromString<CAPIResultSetType>(const char *value) {

return static_cast<CAPIResultSetType>(StringUtil::StringToEnum(GetCAPIResultSetTypeValues(), 4, "CAPIResultSetType", value));

}

const StringUtil::EnumStringLiteral *GetCSVStateValues() {

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;

}

template<>

const char* EnumUtil::ToChars<CSVState>(CSVState value) {

return StringUtil::EnumToString(GetCSVStateValues(), 19, "CSVState", static_cast<uint32_t>(value));

}

template<>

CSVState EnumUtil::FromString<CSVState>(const char *value) {

return static_cast<CSVState>(StringUtil::StringToEnum(GetCSVStateValues(), 19, "CSVState", value));

}

const StringUtil::EnumStringLiteral *GetCTEMaterializeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<CTEMaterialize>(CTEMaterialize value) {

return StringUtil::EnumToString(GetCTEMaterializeValues(), 3, "CTEMaterialize", static_cast<uint32_t>(value));

}

template<>

CTEMaterialize EnumUtil::FromString<CTEMaterialize>(const char *value) {

return static_cast<CTEMaterialize>(StringUtil::StringToEnum(GetCTEMaterializeValues(), 3, "CTEMaterialize", value));

}

const StringUtil::EnumStringLiteral *GetCatalogLookupBehaviorValues() {

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;

}

template<>

const char* EnumUtil::ToChars<CatalogLookupBehavior>(CatalogLookupBehavior value) {

return StringUtil::EnumToString(GetCatalogLookupBehaviorValues(), 3, "CatalogLookupBehavior", static_cast<uint32_t>(value));

}

template<>

CatalogLookupBehavior EnumUtil::FromString<CatalogLookupBehavior>(const char *value) {

return static_cast<CatalogLookupBehavior>(StringUtil::StringToEnum(GetCatalogLookupBehaviorValues(), 3, "CatalogLookupBehavior", value));

}

const StringUtil::EnumStringLiteral *GetCatalogTypeValues() {

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::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;

}

template<>

const char* EnumUtil::ToChars<CatalogType>(CatalogType value) {

return StringUtil::EnumToString(GetCatalogTypeValues(), 23, "CatalogType", static_cast<uint32_t>(value));

}

template<>

CatalogType EnumUtil::FromString<CatalogType>(const char *value) {

return static_cast<CatalogType>(StringUtil::StringToEnum(GetCatalogTypeValues(), 23, "CatalogType", value));

}

const StringUtil::EnumStringLiteral *GetCheckpointAbortValues() {

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" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<CheckpointAbort>(CheckpointAbort value) {

return StringUtil::EnumToString(GetCheckpointAbortValues(), 4, "CheckpointAbort", static_cast<uint32_t>(value));

}

template<>

CheckpointAbort EnumUtil::FromString<CheckpointAbort>(const char *value) {

return static_cast<CheckpointAbort>(StringUtil::StringToEnum(GetCheckpointAbortValues(), 4, "CheckpointAbort", value));

}

const StringUtil::EnumStringLiteral *GetChunkInfoTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<ChunkInfoType>(ChunkInfoType value) {

return StringUtil::EnumToString(GetChunkInfoTypeValues(), 3, "ChunkInfoType", static_cast<uint32_t>(value));

}

template<>

ChunkInfoType EnumUtil::FromString<ChunkInfoType>(const char *value) {

return static_cast<ChunkInfoType>(StringUtil::StringToEnum(GetChunkInfoTypeValues(), 3, "ChunkInfoType", value));

}

const StringUtil::EnumStringLiteral *GetColumnDataAllocatorTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<ColumnDataAllocatorType>(ColumnDataAllocatorType value) {

return StringUtil::EnumToString(GetColumnDataAllocatorTypeValues(), 3, "ColumnDataAllocatorType", static_cast<uint32_t>(value));

}

template<>

ColumnDataAllocatorType EnumUtil::FromString<ColumnDataAllocatorType>(const char *value) {

return static_cast<ColumnDataAllocatorType>(StringUtil::StringToEnum(GetColumnDataAllocatorTypeValues(), 3, "ColumnDataAllocatorType", value));

}

const StringUtil::EnumStringLiteral *GetColumnDataScanPropertiesValues() {

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;

}

template<>

const char* EnumUtil::ToChars<ColumnDataScanProperties>(ColumnDataScanProperties value) {

return StringUtil::EnumToString(GetColumnDataScanPropertiesValues(), 3, "ColumnDataScanProperties", static_cast<uint32_t>(value));

}

template<>

ColumnDataScanProperties EnumUtil::FromString<ColumnDataScanProperties>(const char *value) {

return static_cast<ColumnDataScanProperties>(StringUtil::StringToEnum(GetColumnDataScanPropertiesValues(), 3, "ColumnDataScanProperties", value));

}

const StringUtil::EnumStringLiteral *GetColumnSegmentTypeValues() {

static constexpr StringUtil::EnumStringLiteral values[] {

{ static_cast<uint32_t>(ColumnSegmentType::TRANSIENT), "TRANSIENT" },

{ static_cast<uint32_t>(ColumnSegmentType::PERSISTENT), "PERSISTENT" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<ColumnSegmentType>(ColumnSegmentType value) {

return StringUtil::EnumToString(GetColumnSegmentTypeValues(), 2, "ColumnSegmentType", static_cast<uint32_t>(value));

}

template<>

ColumnSegmentType EnumUtil::FromString<ColumnSegmentType>(const char *value) {

return static_cast<ColumnSegmentType>(StringUtil::StringToEnum(GetColumnSegmentTypeValues(), 2, "ColumnSegmentType", value));

}

const StringUtil::EnumStringLiteral *GetCompressedMaterializationDirectionValues() {

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;

}

template<>

const char* EnumUtil::ToChars<CompressedMaterializationDirection>(CompressedMaterializationDirection value) {

return StringUtil::EnumToString(GetCompressedMaterializationDirectionValues(), 3, "CompressedMaterializationDirection", static_cast<uint32_t>(value));

}

template<>

CompressedMaterializationDirection EnumUtil::FromString<CompressedMaterializationDirection>(const char *value) {

return static_cast<CompressedMaterializationDirection>(StringUtil::StringToEnum(GetCompressedMaterializationDirectionValues(), 3, "CompressedMaterializationDirection", value));

}

const StringUtil::EnumStringLiteral *GetCompressionTypeValues() {

static constexpr StringUtil::EnumStringLiteral values[] {

{ static_cast<uint32_t>(CompressionType::COMPRESSION_AUTO), "COMPRESSION_AUTO" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_UNCOMPRESSED), "COMPRESSION_UNCOMPRESSED" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_CONSTANT), "COMPRESSION_CONSTANT" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_RLE), "COMPRESSION_RLE" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_DICTIONARY), "COMPRESSION_DICTIONARY" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_PFOR_DELTA), "COMPRESSION_PFOR_DELTA" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_BITPACKING), "COMPRESSION_BITPACKING" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_FSST), "COMPRESSION_FSST" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_CHIMP), "COMPRESSION_CHIMP" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_PATAS), "COMPRESSION_PATAS" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_ALP), "COMPRESSION_ALP" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_ALPRD), "COMPRESSION_ALPRD" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_ZSTD), "COMPRESSION_ZSTD" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_ROARING), "COMPRESSION_ROARING" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_EMPTY), "COMPRESSION_EMPTY" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_DICT_FSST), "COMPRESSION_DICT_FSST" },

{ static_cast<uint32_t>(CompressionType::COMPRESSION_COUNT), "COMPRESSION_COUNT" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<CompressionType>(CompressionType value) {

return StringUtil::EnumToString(GetCompressionTypeValues(), 17, "CompressionType", static_cast<uint32_t>(value));

}

template<>

CompressionType EnumUtil::FromString<CompressionType>(const char *value) {

return static_cast<CompressionType>(StringUtil::StringToEnum(GetCompressionTypeValues(), 17, "CompressionType", value));

}

const StringUtil::EnumStringLiteral *GetCompressionValidityValues() {

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;

}

template<>

const char* EnumUtil::ToChars<CompressionValidity>(CompressionValidity value) {

return StringUtil::EnumToString(GetCompressionValidityValues(), 2, "CompressionValidity", static_cast<uint32_t>(value));

}

template<>

CompressionValidity EnumUtil::FromString<CompressionValidity>(const char *value) {

return static_cast<CompressionValidity>(StringUtil::StringToEnum(GetCompressionValidityValues(), 2, "CompressionValidity", value));

}

const StringUtil::EnumStringLiteral *GetConflictManagerModeValues() {

static constexpr StringUtil::EnumStringLiteral values[] {

{ static_cast<uint32_t>(ConflictManagerMode::SCAN), "SCAN" },

{ static_cast<uint32_t>(ConflictManagerMode::THROW), "THROW" }

};

return values;

}

template<>

const char* EnumUtil::ToChars<ConflictManagerMode>(ConflictManagerMode value) {

return StringUtil::EnumToString(GetConflictManagerModeValues(), 2, "ConflictManagerMode", static_cast<uint32_t>(value));

}

template<>

ConflictManagerMode EnumUtil::FromString<ConflictManagerMode>(const char *value) {

return static_cast<ConflictManagerMode>(StringUtil::StringToEnum(GetConflictManagerModeValues(), 2, "ConflictManagerMode", value));

}

const StringUtil::EnumStringLiteral *GetConstraintTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<ConstraintType>(ConstraintType value) {

return StringUtil::EnumToString(GetConstraintTypeValues(), 5, "ConstraintType", static_cast<uint32_t>(value));

}

template<>

ConstraintType EnumUtil::FromString<ConstraintType>(const char *value) {

return static_cast<ConstraintType>(StringUtil::StringToEnum(GetConstraintTypeValues(), 5, "ConstraintType", value));

}

const StringUtil::EnumStringLiteral *GetCopyFunctionReturnTypeValues() {

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;

}

template<>

const char* EnumUtil::ToChars<CopyFunctionReturnType>(CopyFunctionReturnType value) {

return StringUtil::EnumToString(GetCopyFunctionReturnTypeValues(), 3, "CopyFunctionReturnType", static_cast<uint32_t>(value));

}

template<>

CopyFunctionReturnType EnumUtil::FromString<CopyFunctionReturnType>(const char *value) {

return static_cast<CopyFunctionReturnType>(StringUtil::StringToEnum(GetCopyFunctionReturnTypeValues(), 3, "CopyFunctionReturnType", value));

}

const StringUtil::EnumStringLiteral *GetCopyOverwriteModeValues() {

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" }

};