#![allow(clippy::all, dead_code, unused_imports)]
use crate::ast::*;
use std::mem::size_of;
pub(crate) const ACCESS_CONTROL_STATEMENT_SIZE_BUDGET: usize = 104;
pub(crate) const AFTER_MATCH_SKIP_SIZE_BUDGET: usize = 36;
pub(crate) const AGGREGATE_ARGS_SIZE_BUDGET: usize = 32;
pub(crate) const ALTER_COLUMN_ACTION_SIZE_BUDGET: usize = 56;
pub(crate) const ALTER_COLUMN_TARGET_SIZE_BUDGET: usize = 24;
pub(crate) const ALTER_DATABASE_SIZE_BUDGET: usize = 68;
pub(crate) const ALTER_DATABASE_ACTION_SIZE_BUDGET: usize = 32;
pub(crate) const ALTER_DATABASE_OPTION_SIZE_BUDGET: usize = 40;
pub(crate) const ALTER_DATABASE_OPTIONS_SIZE_BUDGET: usize = 48;
pub(crate) const ALTER_EVENT_SIZE_BUDGET: usize = 112;
pub(crate) const ALTER_EXTENSION_SIZE_BUDGET: usize = 152;
pub(crate) const ALTER_EXTENSION_ACTION_SIZE_BUDGET: usize = 120;
pub(crate) const ALTER_INSTANCE_SIZE_BUDGET: usize = 48;
pub(crate) const ALTER_INSTANCE_ACTION_SIZE_BUDGET: usize = 36;
pub(crate) const ALTER_LOGFILE_GROUP_SIZE_BUDGET: usize = 64;
pub(crate) const ALTER_OBJECT_DEPENDS_SIZE_BUDGET: usize = 144;
pub(crate) const ALTER_OBJECT_SCHEMA_SIZE_BUDGET: usize = 48;
pub(crate) const ALTER_RESOURCE_GROUP_SIZE_BUDGET: usize = 104;
pub(crate) const ALTER_ROUTINE_SIZE_BUDGET: usize = 32;
pub(crate) const ALTER_SEQUENCE_SIZE_BUDGET: usize = 32;
pub(crate) const ALTER_SEQUENCE_OPTION_SIZE_BUDGET: usize = 72;
pub(crate) const ALTER_SERVER_SIZE_BUDGET: usize = 40;
pub(crate) const ALTER_SYSTEM_SIZE_BUDGET: usize = 64;
pub(crate) const ALTER_SYSTEM_ACTION_SIZE_BUDGET: usize = 48;
pub(crate) const ALTER_TABLE_SIZE_BUDGET: usize = 32;
pub(crate) const ALTER_TABLE_ACTION_SIZE_BUDGET: usize = 128;
pub(crate) const ALTER_TABLESPACE_SIZE_BUDGET: usize = 80;
pub(crate) const ALTER_TABLESPACE_ACTION_SIZE_BUDGET: usize = 48;
pub(crate) const ALTER_USER_SIZE_BUDGET: usize = 104;
pub(crate) const ALTER_USER_SPEC_SIZE_BUDGET: usize = 152;
pub(crate) const ALTER_VIEW_SIZE_BUDGET: usize = 56;
pub(crate) const ANALYZE_HISTOGRAM_SIZE_BUDGET: usize = 48;
pub(crate) const ANALYZE_STATEMENT_SIZE_BUDGET: usize = 32;
pub(crate) const ARRAY_EXPR_SIZE_BUDGET: usize = 24;
pub(crate) const AT_TIME_ZONE_EXPR_SIZE_BUDGET: usize = 96;
pub(crate) const ATTACH_STATEMENT_SIZE_BUDGET: usize = 80;
pub(crate) const AUTH_OPTION_SIZE_BUDGET: usize = 60;
pub(crate) const CACHE_INDEX_KEY_LIST_SIZE_BUDGET: usize = 24;
pub(crate) const CACHE_INDEX_STATEMENT_SIZE_BUDGET: usize = 120;
pub(crate) const CACHE_INDEX_TABLE_SIZE_BUDGET: usize = 48;
pub(crate) const CACHE_INDEX_TARGETS_SIZE_BUDGET: usize = 72;
pub(crate) const CALL_STATEMENT_SIZE_BUDGET: usize = 32;
pub(crate) const CASE_EXPR_SIZE_BUDGET: usize = 40;
pub(crate) const CASE_STATEMENT_SIZE_BUDGET: usize = 40;
pub(crate) const CHANGE_REPLICATION_SOURCE_OPTION_SIZE_BUDGET: usize = 80;
pub(crate) const CHANGE_REPLICATION_SOURCE_OPTION_VALUE_SIZE_BUDGET: usize = 64;
pub(crate) const CHARSET_ANNOTATION_SIZE_BUDGET: usize = 36;
pub(crate) const CHECKPOINT_STATEMENT_SIZE_BUDGET: usize = 36;
pub(crate) const CLOSE_CURSOR_STATEMENT_SIZE_BUDGET: usize = 32;
pub(crate) const COLLATE_EXPR_SIZE_BUDGET: usize = 64;
pub(crate) const COLUMN_CONSTRAINT_SIZE_BUDGET: usize = 72;
pub(crate) const COLUMN_DEF_SIZE_BUDGET: usize = 88;
pub(crate) const COLUMN_OPTION_SIZE_BUDGET: usize = 24;
pub(crate) const COMMENT_ON_STATEMENT_SIZE_BUDGET: usize = 72;
pub(crate) const COMPOUND_STATEMENT_SIZE_BUDGET: usize = 72;
pub(crate) const COMPREHENSION_SOURCE_SIZE_BUDGET: usize = 24;
pub(crate) const CONDITIONAL_BRANCH_SIZE_BUDGET: usize = 64;
pub(crate) const CONDITION_INFO_ITEM_SIZE_BUDGET: usize = 56;
pub(crate) const CONDITION_VALUE_SIZE_BUDGET: usize = 40;
pub(crate) const CONFIG_PARAMETER_SIZE_BUDGET: usize = 24;
pub(crate) const CONFLICT_ACTION_SIZE_BUDGET: usize = 64;
pub(crate) const CONFLICT_TARGET_SIZE_BUDGET: usize = 64;
pub(crate) const CONSTRAINT_CHARACTERISTICS_SIZE_BUDGET: usize = 16;
pub(crate) const CONSTRAINTS_TARGET_SIZE_BUDGET: usize = 24;
pub(crate) const COPY_INTO_SOURCE_SIZE_BUDGET: usize = 40;
pub(crate) const COPY_INTO_STATEMENT_SIZE_BUDGET: usize = 104;
pub(crate) const COPY_INTO_TARGET_SIZE_BUDGET: usize = 40;
pub(crate) const COPY_OPTION_SIZE_BUDGET: usize = 72;
pub(crate) const COPY_OPTION_VALUE_SIZE_BUDGET: usize = 40;
pub(crate) const COPY_SOURCE_SIZE_BUDGET: usize = 32;
pub(crate) const COPY_STATEMENT_SIZE_BUDGET: usize = 160;
pub(crate) const COPY_TARGET_SIZE_BUDGET: usize = 40;
pub(crate) const CREATE_DATABASE_SIZE_BUDGET: usize = 24;
pub(crate) const CREATE_COLOCATION_GROUP_SIZE_BUDGET: usize = 72;
pub(crate) const CREATE_EVENT_SIZE_BUDGET: usize = 104;
pub(crate) const CREATE_EXTENSION_SIZE_BUDGET: usize = 48;
pub(crate) const CREATE_EXTENSION_OPTION_SIZE_BUDGET: usize = 48;
pub(crate) const CREATE_FUNCTION_SIZE_BUDGET: usize = 88;
pub(crate) const CREATE_INDEX_SIZE_BUDGET: usize = 88;
pub(crate) const CREATE_LOGFILE_GROUP_SIZE_BUDGET: usize = 64;
pub(crate) const CREATE_MACRO_SIZE_BUDGET: usize = 56;
pub(crate) const CREATE_PROCEDURE_SIZE_BUDGET: usize = 56;
pub(crate) const CREATE_RESOURCE_GROUP_SIZE_BUDGET: usize = 104;
pub(crate) const CREATE_SCHEMA_SIZE_BUDGET: usize = 56;
pub(crate) const CREATE_SECRET_SIZE_BUDGET: usize = 32;
pub(crate) const CREATE_SERVER_SIZE_BUDGET: usize = 64;
pub(crate) const CREATE_SEQUENCE_SIZE_BUDGET: usize = 32;
pub(crate) const CREATE_SPATIAL_REFERENCE_SYSTEM_SIZE_BUDGET: usize = 48;
pub(crate) const CREATE_STORED_TRIGGER_SIZE_BUDGET: usize = 112;
pub(crate) const CREATE_TABLE_SIZE_BUDGET: usize = 96;
pub(crate) const CREATE_TABLE_BODY_SIZE_BUDGET: usize = 40;
pub(crate) const CREATE_TABLE_OPTION_SIZE_BUDGET: usize = 56;
pub(crate) const CREATE_TABLE_OPTION_KIND_SIZE_BUDGET: usize = 40;
pub(crate) const CREATE_TABLESPACE_SIZE_BUDGET: usize = 88;
pub(crate) const CREATE_TRIGGER_SIZE_BUDGET: usize = 104;
pub(crate) const CREATE_TYPE_SIZE_BUDGET: usize = 72;
pub(crate) const CREATE_TYPE_DEFINITION_SIZE_BUDGET: usize = 48;
pub(crate) const CREATE_USER_SIZE_BUDGET: usize = 112;
pub(crate) const CREATE_VIEW_SIZE_BUDGET: usize = 72;
pub(crate) const CREATE_VIRTUAL_TABLE_SIZE_BUDGET: usize = 56;
pub(crate) const CTE_SIZE_BUDGET: usize = 96;
pub(crate) const CTE_BODY_SIZE_BUDGET: usize = 24;
pub(crate) const CTE_CYCLE_CLAUSE_SIZE_BUDGET: usize = 96;
pub(crate) const CTE_CYCLE_MARK_SIZE_BUDGET: usize = 32;
pub(crate) const CTE_SEARCH_CLAUSE_SIZE_BUDGET: usize = 48;
pub(crate) const DATA_TYPE_SIZE_BUDGET: usize = 32;
pub(crate) const DEALLOCATE_STATEMENT_SIZE_BUDGET: usize = 36;
pub(crate) const DECLARATION_SIZE_BUDGET: usize = 96;
pub(crate) const DEFAULT_ROLE_TARGET_SIZE_BUDGET: usize = 24;
pub(crate) const DEFAULT_VALUE_SIZE_BUDGET: usize = 12;
pub(crate) const DEFINER_SIZE_BUDGET: usize = 52;
pub(crate) const DELETE_SIZE_BUDGET: usize = 296;
pub(crate) const DESCRIBE_COLUMN_SIZE_BUDGET: usize = 36;
pub(crate) const DESCRIBE_STATEMENT_SIZE_BUDGET: usize = 64;
pub(crate) const DETACH_STATEMENT_SIZE_BUDGET: usize = 36;
pub(crate) const DIAGNOSTICS_INFO_SIZE_BUDGET: usize = 32;
pub(crate) const DML_SELECTION_SIZE_BUDGET: usize = 56;
pub(crate) const DML_TARGET_SIZE_BUDGET: usize = 48;
pub(crate) const DO_ARG_SIZE_BUDGET: usize = 48;
pub(crate) const DO_EXPRESSIONS_STATEMENT_SIZE_BUDGET: usize = 24;
pub(crate) const DO_STATEMENT_SIZE_BUDGET: usize = 24;
pub(crate) const DROP_DATABASE_SIZE_BUDGET: usize = 36;
pub(crate) const DROP_COLOCATION_GROUP_SIZE_BUDGET: usize = 36;
pub(crate) const DROP_EVENT_SIZE_BUDGET: usize = 24;
pub(crate) const DROP_INDEX_ON_TABLE_SIZE_BUDGET: usize = 48;
pub(crate) const DROP_LOGFILE_GROUP_SIZE_BUDGET: usize = 40;
pub(crate) const DROP_RESOURCE_GROUP_SIZE_BUDGET: usize = 36;
pub(crate) const DROP_SECRET_STMT_SIZE_BUDGET: usize = 56;
pub(crate) const DROP_SERVER_SIZE_BUDGET: usize = 36;
pub(crate) const DROP_SPATIAL_REFERENCE_SYSTEM_SIZE_BUDGET: usize = 40;
pub(crate) const DROP_STATEMENT_SIZE_BUDGET: usize = 24;
pub(crate) const DROP_TABLESPACE_SIZE_BUDGET: usize = 48;
pub(crate) const DROP_TRANSFORM_SIZE_BUDGET: usize = 120;
pub(crate) const EVENT_SCHEDULE_SIZE_BUDGET: usize = 40;
pub(crate) const EXCLUDE_CONSTRAINT_SIZE_BUDGET: usize = 88;
pub(crate) const EXCLUDE_ELEMENT_SIZE_BUDGET: usize = 96;
pub(crate) const EXECUTE_STATEMENT_SIZE_BUDGET: usize = 40;
pub(crate) const EXECUTE_USING_STATEMENT_SIZE_BUDGET: usize = 40;
pub(crate) const EXPLAIN_OPTION_SIZE_BUDGET: usize = 52;
pub(crate) const EXPLAIN_STATEMENT_SIZE_BUDGET: usize = 32;
pub(crate) const EXPORT_STATEMENT_SIZE_BUDGET: usize = 72;
pub(crate) const EXPR_SIZE_BUDGET: usize = 40;
pub(crate) const EXTENSION_VERSION_SIZE_BUDGET: usize = 36;
pub(crate) const EXTRACT_EXPR_SIZE_BUDGET: usize = 40;
pub(crate) const FETCH_CURSOR_STATEMENT_SIZE_BUDGET: usize = 48;
pub(crate) const FIELD_SELECTION_EXPR_SIZE_BUDGET: usize = 88;
pub(crate) const FIELD_SELECTOR_SIZE_BUDGET: usize = 32;
pub(crate) const FLUSH_OPTION_SIZE_BUDGET: usize = 36;
pub(crate) const FLUSH_STATEMENT_SIZE_BUDGET: usize = 40;
pub(crate) const FLUSH_TARGET_SIZE_BUDGET: usize = 24;
pub(crate) const FORCE_SEEK_TARGET_SIZE_BUDGET: usize = 40;
pub(crate) const FOREIGN_KEY_REF_SIZE_BUDGET: usize = 48;
pub(crate) const FOR_CLAUSE_SIZE_BUDGET: usize = 92;
pub(crate) const FOR_ROOT_SIZE_BUDGET: usize = 36;
pub(crate) const FOR_XML_MODE_SIZE_BUDGET: usize = 40;
pub(crate) const FORMAT_CLAUSE_SIZE_BUDGET: usize = 32;
pub(crate) const FUNCTION_ARG_SIZE_BUDGET: usize = 64;
pub(crate) const FUNCTION_BODY_SIZE_BUDGET: usize = 40;
pub(crate) const FUNCTION_CALL_SIZE_BUDGET: usize = 120;
pub(crate) const FUNCTION_OPTION_SIZE_BUDGET: usize = 56;
pub(crate) const FUNCTION_PARAM_SIZE_BUDGET: usize = 80;
pub(crate) const FUNCTION_PARAM_DEFAULT_SIZE_BUDGET: usize = 56;
pub(crate) const GENERATED_COLUMN_SIZE_BUDGET: usize = 56;
pub(crate) const GET_DIAGNOSTICS_STATEMENT_SIZE_BUDGET: usize = 48;
pub(crate) const GRANT_AS_SIZE_BUDGET: usize = 88;
pub(crate) const GRANT_OBJECT_SIZE_BUDGET: usize = 24;
pub(crate) const GRANTEE_SIZE_BUDGET: usize = 48;
pub(crate) const PRIVILEGE_LEVEL_OBJECT_SIZE_BUDGET: usize = 48;
pub(crate) const PRIVILEGE_LEVEL_SIZE_BUDGET: usize = 32;
pub(crate) const WITH_ROLE_SPEC_SIZE_BUDGET: usize = 24;
pub(crate) const GROUP_BY_ITEM_SIZE_BUDGET: usize = 56;
pub(crate) const GROUP_REPLICATION_OPTION_SIZE_BUDGET: usize = 40;
pub(crate) const HANDLER_CONDITION_SIZE_BUDGET: usize = 40;
pub(crate) const HANDLER_STATEMENT_SIZE_BUDGET: usize = 224;
pub(crate) const HANDLER_OPERATION_SIZE_BUDGET: usize = 200;
pub(crate) const HANDLER_READ_SELECTOR_SIZE_BUDGET: usize = 48;
pub(crate) const CLONE_STATEMENT_SIZE_BUDGET: usize = 156;
pub(crate) const CLONE_DATA_DIRECTORY_SIZE_BUDGET: usize = 40;
pub(crate) const IMPORT_TABLE_STATEMENT_SIZE_BUDGET: usize = 24;
pub(crate) const HELP_STATEMENT_SIZE_BUDGET: usize = 32;
pub(crate) const BINLOG_STATEMENT_SIZE_BUDGET: usize = 36;
pub(crate) const HIERARCHICAL_CLAUSE_SIZE_BUDGET: usize = 96;
pub(crate) const IDENT_SIZE_BUDGET: usize = 20;
pub(crate) const IDENTITY_COLUMN_SIZE_BUDGET: usize = 24;
pub(crate) const IDENTITY_OPTION_SIZE_BUDGET: usize = 56;
pub(crate) const IF_STATEMENT_SIZE_BUDGET: usize = 32;
pub(crate) const IMPORT_STATEMENT_SIZE_BUDGET: usize = 36;
pub(crate) const INDEX_COLUMN_SIZE_BUDGET: usize = 56;
pub(crate) const INDEX_HINT_SIZE_BUDGET: usize = 24;
pub(crate) const INDEXED_BY_SIZE_BUDGET: usize = 32;
pub(crate) const INSERT_SIZE_BUDGET: usize = 216;
pub(crate) const INSERT_SOURCE_SIZE_BUDGET: usize = 32;
pub(crate) const INSERT_TARGET_SIZE_BUDGET: usize = 56;
pub(crate) const INSERT_VALUE_SIZE_BUDGET: usize = 56;
pub(crate) const INSERT_VALUES_SIZE_BUDGET: usize = 24;
pub(crate) const INSTANCE_LOCK_STATEMENT_SIZE_BUDGET: usize = 16;
pub(crate) const INTO_TARGET_SIZE_BUDGET: usize = 24;
pub(crate) const IS_JSON_EXPR_SIZE_BUDGET: usize = 24;
pub(crate) const ITERATE_STATEMENT_SIZE_BUDGET: usize = 32;
pub(crate) const JOIN_SIZE_BUDGET: usize = 208;
pub(crate) const JOIN_CONSTRAINT_SIZE_BUDGET: usize = 56;
pub(crate) const JOIN_OPERATOR_SIZE_BUDGET: usize = 72;
pub(crate) const JSON_AGGREGATE_BODY_SIZE_BUDGET: usize = 64;
pub(crate) const JSON_AGGREGATE_EXPR_SIZE_BUDGET: usize = 120;
pub(crate) const JSON_ARRAY_BODY_SIZE_BUDGET: usize = 24;
pub(crate) const JSON_ARRAY_EXPR_SIZE_BUDGET: usize = 64;
pub(crate) const JSON_BEHAVIOR_SIZE_BUDGET: usize = 24;
pub(crate) const JSON_CONSTRUCTOR_EXPR_SIZE_BUDGET: usize = 64;
pub(crate) const JSON_FUNC_EXPR_SIZE_BUDGET: usize = 128;
pub(crate) const JSON_KEY_VALUE_SIZE_BUDGET: usize = 48;
pub(crate) const JSON_OBJECT_EXPR_SIZE_BUDGET: usize = 48;
pub(crate) const JSON_PASSING_ARG_SIZE_BUDGET: usize = 56;
pub(crate) const JSON_RETURNING_SIZE_BUDGET: usize = 24;
pub(crate) const JSON_TABLE_SIZE_BUDGET: usize = 112;
pub(crate) const JSON_TABLE_COLUMN_SIZE_BUDGET: usize = 104;
pub(crate) const JSON_VALUE_EXPR_SIZE_BUDGET: usize = 24;
pub(crate) const KEY_CACHE_NAME_SIZE_BUDGET: usize = 32;
pub(crate) const LAMBDA_EXPR_SIZE_BUDGET: usize = 64;
pub(crate) const LANGUAGE_NAME_SIZE_BUDGET: usize = 36;
pub(crate) const LATERAL_VIEW_SIZE_BUDGET: usize = 168;
pub(crate) const LEAVE_STATEMENT_SIZE_BUDGET: usize = 32;
pub(crate) const KILL_STATEMENT_SIZE_BUDGET: usize = 56;
pub(crate) const INSTALL_STATEMENT_SIZE_BUDGET: usize = 56;
pub(crate) const UNINSTALL_STATEMENT_SIZE_BUDGET: usize = 32;
pub(crate) const INSTALL_COMPONENT_SET_ELEMENT_SIZE_BUDGET: usize = 80;
pub(crate) const INSTALL_COMPONENT_SET_VALUE_SIZE_BUDGET: usize = 56;
pub(crate) const LIMIT_SIZE_BUDGET: usize = 96;
pub(crate) const LIMIT_BY_SIZE_BUDGET: usize = 104;
pub(crate) const LIST_COMPREHENSION_SIZE_BUDGET: usize = 64;
pub(crate) const LITERAL_SIZE_BUDGET: usize = 24;
pub(crate) const LOAD_DATA_ENCLOSED_SIZE_BUDGET: usize = 40;
pub(crate) const LOAD_DATA_FIELD_OR_VAR_SIZE_BUDGET: usize = 36;
pub(crate) const LOAD_DATA_FIELDS_SIZE_BUDGET: usize = 104;
pub(crate) const LOAD_DATA_IGNORE_ROWS_SIZE_BUDGET: usize = 40;
pub(crate) const LOAD_DATA_LINES_SIZE_BUDGET: usize = 60;
pub(crate) const LOAD_DATA_STATEMENT_SIZE_BUDGET: usize = 320;
pub(crate) const LOAD_INDEX_STATEMENT_SIZE_BUDGET: usize = 88;
pub(crate) const LOAD_INDEX_TABLE_SIZE_BUDGET: usize = 48;
pub(crate) const LOAD_INDEX_TARGETS_SIZE_BUDGET: usize = 72;
pub(crate) const LOAD_STATEMENT_SIZE_BUDGET: usize = 48;
pub(crate) const LOAD_TARGET_SIZE_BUDGET: usize = 36;
pub(crate) const LOCK_TABLES_STATEMENT_SIZE_BUDGET: usize = 24;
pub(crate) const LOCKING_CLAUSE_SIZE_BUDGET: usize = 24;
pub(crate) const LOOP_STATEMENT_SIZE_BUDGET: usize = 64;
pub(crate) const MACRO_BODY_SIZE_BUDGET: usize = 24;
pub(crate) const MACRO_PARAM_SIZE_BUDGET: usize = 72;
pub(crate) const MAP_ENTRY_SIZE_BUDGET: usize = 96;
pub(crate) const MAP_EXPR_SIZE_BUDGET: usize = 24;
pub(crate) const MATCH_RECOGNIZE_SIZE_BUDGET: usize = 144;
pub(crate) const MATCH_RECOGNIZE_PATTERN_SIZE_BUDGET: usize = 40;
pub(crate) const MEASURE_SIZE_BUDGET: usize = 72;
pub(crate) const MERGE_SIZE_BUDGET: usize = 304;
pub(crate) const MERGE_ACTION_SIZE_BUDGET: usize = 40;
pub(crate) const MERGE_WHEN_CLAUSE_SIZE_BUDGET: usize = 96;
pub(crate) const MODULE_ARG_SIZE_BUDGET: usize = 16;
pub(crate) const ACCOUNT_NAME_SIZE_BUDGET: usize = 52;
pub(crate) const NAMED_OPERATOR_EXPR_SIZE_BUDGET: usize = 112;
pub(crate) const NAMED_WINDOW_SIZE_BUDGET: usize = 144;
pub(crate) const OBJECT_NAME_SIZE_BUDGET: usize = 8;
pub(crate) const OBJECT_REFERENCE_SIZE_BUDGET: usize = 104;
pub(crate) const ON_CONFLICT_SIZE_BUDGET: usize = 144;
pub(crate) const OPEN_CURSOR_STATEMENT_SIZE_BUDGET: usize = 32;
pub(crate) const OPEN_JSON_SIZE_BUDGET: usize = 40;
pub(crate) const OPEN_JSON_COLUMN_SIZE_BUDGET: usize = 56;
pub(crate) const OPERATOR_ARGS_SIZE_BUDGET: usize = 80;
pub(crate) const ORDER_BY_ALL_SIZE_BUDGET: usize = 16;
pub(crate) const ORDER_BY_EXPR_SIZE_BUDGET: usize = 64;
pub(crate) const ORDER_BY_USING_SIZE_BUDGET: usize = 24;
pub(crate) const PARTITION_BOUND_SIZE_BUDGET: usize = 64;
pub(crate) const PARTITION_ELEM_SIZE_BUDGET: usize = 72;
pub(crate) const PARTITION_SELECTION_SIZE_BUDGET: usize = 24;
pub(crate) const PARTITION_SPEC_SIZE_BUDGET: usize = 24;
pub(crate) const PASSWORD_LOCK_OPTION_SIZE_BUDGET: usize = 40;
pub(crate) const PIPE_AGGREGATE_EXPR_SIZE_BUDGET: usize = 80;
pub(crate) const PIPE_OPERATOR_SIZE_BUDGET: usize = 64;
pub(crate) const PIPE_RENAME_ITEM_SIZE_BUDGET: usize = 52;
pub(crate) const PIVOT_SIZE_BUDGET: usize = 104;
pub(crate) const PIVOT_COLUMN_SIZE_BUDGET: usize = 88;
pub(crate) const PIVOT_EXPR_SIZE_BUDGET: usize = 80;
pub(crate) const PIVOT_VALUE_SOURCE_SIZE_BUDGET: usize = 24;
pub(crate) const POSTFIX_OPERATOR_EXPR_SIZE_BUDGET: usize = 56;
pub(crate) const PRAGMA_STATEMENT_SIZE_BUDGET: usize = 64;
pub(crate) const PREFIX_OPERATOR_EXPR_SIZE_BUDGET: usize = 56;
pub(crate) const PREPARE_FROM_STATEMENT_SIZE_BUDGET: usize = 68;
pub(crate) const PREPARE_SOURCE_SIZE_BUDGET: usize = 36;
pub(crate) const PREPARE_STATEMENT_SIZE_BUDGET: usize = 48;
pub(crate) const PRIVILEGE_SIZE_BUDGET: usize = 40;
pub(crate) const PRIVILEGES_SIZE_BUDGET: usize = 24;
pub(crate) const PURGE_STATEMENT_SIZE_BUDGET: usize = 72;
pub(crate) const PURGE_TARGET_SIZE_BUDGET: usize = 56;
pub(crate) const QUERY_SIZE_BUDGET: usize = 232;
pub(crate) const REFERENTIAL_ACTION_SIZE_BUDGET: usize = 24;
pub(crate) const REFRESH_MATERIALIZED_VIEW_SIZE_BUDGET: usize = 24;
pub(crate) const REINDEX_STATEMENT_SIZE_BUDGET: usize = 24;
pub(crate) const RENAME_STATEMENT_SIZE_BUDGET: usize = 24;
pub(crate) const RESOURCE_LIMIT_SIZE_BUDGET: usize = 40;
pub(crate) const RETURNING_SIZE_BUDGET: usize = 24;
pub(crate) const REPEAT_STATEMENT_SIZE_BUDGET: usize = 72;
pub(crate) const REPLICA_THREAD_OPTION_SIZE_BUDGET: usize = 16;
pub(crate) const REPLICA_UNTIL_CONDITION_SIZE_BUDGET: usize = 40;
pub(crate) const REPLICATION_FILTER_RULE_SIZE_BUDGET: usize = 24;
pub(crate) const REPLICATION_STATEMENT_SIZE_BUDGET: usize = 152;
pub(crate) const RESOURCE_GROUP_THREAD_PRIORITY_SIZE_BUDGET: usize = 40;
pub(crate) const RESOURCE_GROUP_VCPU_SIZE_BUDGET: usize = 24;
pub(crate) const RETURN_STATEMENT_SIZE_BUDGET: usize = 56;
pub(crate) const REWRITE_DB_PAIR_SIZE_BUDGET: usize = 52;
pub(crate) const ROLE_SPEC_SIZE_BUDGET: usize = 32;
pub(crate) const ROUTINE_SIGNATURE_SIZE_BUDGET: usize = 32;
pub(crate) const ROW_EXPR_SIZE_BUDGET: usize = 24;
pub(crate) const ROWS_FROM_ITEM_SIZE_BUDGET: usize = 144;
pub(crate) const SAMPLE_CLAUSE_SIZE_BUDGET: usize = 72;
pub(crate) const SECRET_OPTION_SIZE_BUDGET: usize = 72;
pub(crate) const SELECT_SIZE_BUDGET: usize = 192;
pub(crate) const SELECT_DISTINCT_SIZE_BUDGET: usize = 24;
pub(crate) const SELECT_ITEM_SIZE_BUDGET: usize = 80;
pub(crate) const SEMI_STRUCTURED_ACCESS_EXPR_SIZE_BUDGET: usize = 64;
pub(crate) const SEMI_STRUCTURED_PATH_SEGMENT_SIZE_BUDGET: usize = 32;
pub(crate) const SERVER_OPTION_SIZE_BUDGET: usize = 40;
pub(crate) const SESSION_STATEMENT_SIZE_BUDGET: usize = 48;
pub(crate) const SET_CHARACTER_SET_VALUE_SIZE_BUDGET: usize = 56;
pub(crate) const SET_EXPR_SIZE_BUDGET: usize = 32;
pub(crate) const SET_NAMES_VALUE_SIZE_BUDGET: usize = 72;
pub(crate) const SET_PARAMETER_VALUE_SIZE_BUDGET: usize = 40;
pub(crate) const SET_VALUE_SIZE_BUDGET: usize = 24;
pub(crate) const SET_VARIABLE_ASSIGNMENT_SIZE_BUDGET: usize = 48;
pub(crate) const SET_VARIABLE_VALUE_SIZE_BUDGET: usize = 24;
pub(crate) const SETTING_SIZE_BUDGET: usize = 72;
pub(crate) const SHOW_FILTER_SIZE_BUDGET: usize = 56;
pub(crate) const SHOW_FROM_SIZE_BUDGET: usize = 24;
pub(crate) const SHOW_FUNCTIONS_FILTER_SIZE_BUDGET: usize = 40;
pub(crate) const SHOW_LIMIT_SIZE_BUDGET: usize = 64;
pub(crate) const SHOW_REF_SIZE_BUDGET: usize = 40;
pub(crate) const SHOW_REF_TARGET_SIZE_BUDGET: usize = 24;
pub(crate) const SHOW_STATEMENT_SIZE_BUDGET: usize = 168;
pub(crate) const SHOW_TARGET_SIZE_BUDGET: usize = 152;
pub(crate) const SIGNAL_ITEM_SIZE_BUDGET: usize = 56;
pub(crate) const SIGNAL_STATEMENT_SIZE_BUDGET: usize = 64;
pub(crate) const SIZE_LITERAL_SIZE_BUDGET: usize = 16;
pub(crate) const SPECIAL_SET_VALUE_SIZE_BUDGET: usize = 56;
pub(crate) const SRS_ATTRIBUTE_SIZE_BUDGET: usize = 60;
pub(crate) const STATEMENT_SIZE_BUDGET: usize = 24;
pub(crate) const STATEMENT_INFO_ITEM_SIZE_BUDGET: usize = 56;
pub(crate) const STRUCT_CONSTRUCTOR_ARG_SIZE_BUDGET: usize = 72;
pub(crate) const STRUCT_CONSTRUCTOR_EXPR_SIZE_BUDGET: usize = 32;
pub(crate) const STRUCT_CONSTRUCTOR_FIELD_SIZE_BUDGET: usize = 64;
pub(crate) const STRUCT_EXPR_SIZE_BUDGET: usize = 24;
pub(crate) const STRUCT_FIELD_SIZE_BUDGET: usize = 64;
pub(crate) const STRUCT_TYPE_FIELD_SIZE_BUDGET: usize = 64;
pub(crate) const SUBSCRIPT_EXPR_SIZE_BUDGET: usize = 176;
pub(crate) const SUBSET_DEFINITION_SIZE_BUDGET: usize = 40;
pub(crate) const SYMBOL_DEFINITION_SIZE_BUDGET: usize = 72;
pub(crate) const TABLE_ALIAS_SIZE_BUDGET: usize = 48;
pub(crate) const STRING_FUNC_SIZE_BUDGET: usize = 48;
pub(crate) const TABLE_CONSTRAINT_SIZE_BUDGET: usize = 32;
pub(crate) const TABLE_CONSTRAINT_DEF_SIZE_BUDGET: usize = 80;
pub(crate) const TABLE_ELEMENT_SIZE_BUDGET: usize = 104;
pub(crate) const TABLE_FACTOR_SIZE_BUDGET: usize = 120;
pub(crate) const TABLE_FUNCTION_COLUMN_SIZE_BUDGET: usize = 64;
pub(crate) const TABLE_HINT_SIZE_BUDGET: usize = 56;
pub(crate) const TABLE_LIKE_OPTION_SIZE_BUDGET: usize = 16;
pub(crate) const TABLE_LOCK_SIZE_BUDGET: usize = 48;
pub(crate) const TABLE_MAINTENANCE_KIND_SIZE_BUDGET: usize = 64;
pub(crate) const TABLE_MAINTENANCE_STATEMENT_SIZE_BUDGET: usize = 88;
pub(crate) const TABLE_OPTION_SIZE_BUDGET: usize = 72;
pub(crate) const TABLE_OPTION_VALUE_SIZE_BUDGET: usize = 40;
pub(crate) const TABLE_RENAME_SIZE_BUDGET: usize = 32;
pub(crate) const TABLE_SAMPLE_SIZE_BUDGET: usize = 40;
pub(crate) const TABLE_STORAGE_PARAMETER_SIZE_BUDGET: usize = 64;
pub(crate) const TABLE_VERSION_SIZE_BUDGET: usize = 32;
pub(crate) const TABLE_WITH_JOINS_SIZE_BUDGET: usize = 144;
pub(crate) const TABLESPACE_OPTION_SIZE_BUDGET: usize = 40;
pub(crate) const TLS_OPTION_SIZE_BUDGET: usize = 40;
pub(crate) const TLS_REQUIREMENT_SIZE_BUDGET: usize = 24;
pub(crate) const TRANSACTION_MODE_SIZE_BUDGET: usize = 16;
pub(crate) const TRANSACTION_STATEMENT_SIZE_BUDGET: usize = 48;
pub(crate) const TRIGGER_EVENT_SIZE_BUDGET: usize = 24;
pub(crate) const TRIGGER_ORDER_SIZE_BUDGET: usize = 36;
pub(crate) const UNLOCK_TABLES_STATEMENT_SIZE_BUDGET: usize = 16;
pub(crate) const UNPIVOT_SIZE_BUDGET: usize = 96;
pub(crate) const UNPIVOT_COLUMN_SIZE_BUDGET: usize = 48;
pub(crate) const UPDATE_SIZE_BUDGET: usize = 296;
pub(crate) const UPDATE_ASSIGNMENT_SIZE_BUDGET: usize = 80;
pub(crate) const UPDATE_EXTENSIONS_STATEMENT_SIZE_BUDGET: usize = 24;
pub(crate) const UPDATE_TUPLE_SOURCE_SIZE_BUDGET: usize = 32;
pub(crate) const UPDATE_VALUE_SIZE_BUDGET: usize = 56;
pub(crate) const UPSERT_SIZE_BUDGET: usize = 160;
pub(crate) const USE_STATEMENT_SIZE_BUDGET: usize = 24;
pub(crate) const USER_ATTRIBUTE_SIZE_BUDGET: usize = 40;
pub(crate) const USER_RENAME_SIZE_BUDGET: usize = 116;
pub(crate) const USER_ROLE_LIST_SIZE_BUDGET: usize = 24;
pub(crate) const USER_SPEC_SIZE_BUDGET: usize = 124;
pub(crate) const VACUUM_STATEMENT_SIZE_BUDGET: usize = 96;
pub(crate) const VALUES_SIZE_BUDGET: usize = 24;
pub(crate) const VALUES_ITEM_SIZE_BUDGET: usize = 56;
pub(crate) const VCPU_RANGE_SIZE_BUDGET: usize = 60;
pub(crate) const WHEN_CLAUSE_SIZE_BUDGET: usize = 96;
pub(crate) const WHILE_STATEMENT_SIZE_BUDGET: usize = 72;
pub(crate) const WILDCARD_OPTIONS_SIZE_BUDGET: usize = 40;
pub(crate) const WILDCARD_RENAME_SIZE_BUDGET: usize = 40;
pub(crate) const WILDCARD_REPLACE_SIZE_BUDGET: usize = 72;
pub(crate) const WINDOW_DEFINITION_SIZE_BUDGET: usize = 112;
pub(crate) const WINDOW_FRAME_SIZE_BUDGET: usize = 64;
pub(crate) const WINDOW_FRAME_BOUND_SIZE_BUDGET: usize = 24;
pub(crate) const WINDOW_SPEC_SIZE_BUDGET: usize = 32;
pub(crate) const WITH_SIZE_BUDGET: usize = 24;
pub(crate) const XA_STATEMENT_SIZE_BUDGET: usize = 100;
pub(crate) const XID_SIZE_BUDGET: usize = 84;
pub(crate) const XML_ATTRIBUTE_SIZE_BUDGET: usize = 40;
pub(crate) const XML_FUNC_SIZE_BUDGET: usize = 48;
pub(crate) const XML_NAMESPACE_SIZE_BUDGET: usize = 40;
pub(crate) const XML_TABLE_SIZE_BUDGET: usize = 48;
pub(crate) const XML_TABLE_COLUMN_SIZE_BUDGET: usize = 64;
#[cfg(target_pointer_width = "64")]
const _: () = {
assert!(size_of::<AccessControlStatement<NoExt>>() == ACCESS_CONTROL_STATEMENT_SIZE_BUDGET);
assert!(size_of::<AfterMatchSkip>() == AFTER_MATCH_SKIP_SIZE_BUDGET);
assert!(size_of::<AggregateArgs<NoExt>>() == AGGREGATE_ARGS_SIZE_BUDGET);
assert!(size_of::<AlterColumnAction<NoExt>>() == ALTER_COLUMN_ACTION_SIZE_BUDGET);
assert!(size_of::<AlterColumnTarget>() == ALTER_COLUMN_TARGET_SIZE_BUDGET);
assert!(size_of::<AlterDatabase>() == ALTER_DATABASE_SIZE_BUDGET);
assert!(size_of::<AlterDatabaseAction>() == ALTER_DATABASE_ACTION_SIZE_BUDGET);
assert!(size_of::<AlterDatabaseOption>() == ALTER_DATABASE_OPTION_SIZE_BUDGET);
assert!(size_of::<AlterDatabaseOptions>() == ALTER_DATABASE_OPTIONS_SIZE_BUDGET);
assert!(size_of::<AlterEvent<NoExt>>() == ALTER_EVENT_SIZE_BUDGET);
assert!(size_of::<AlterExtension<NoExt>>() == ALTER_EXTENSION_SIZE_BUDGET);
assert!(size_of::<AlterExtensionAction<NoExt>>() == ALTER_EXTENSION_ACTION_SIZE_BUDGET);
assert!(size_of::<AlterInstance>() == ALTER_INSTANCE_SIZE_BUDGET);
assert!(size_of::<AlterInstanceAction>() == ALTER_INSTANCE_ACTION_SIZE_BUDGET);
assert!(size_of::<AlterLogfileGroup>() == ALTER_LOGFILE_GROUP_SIZE_BUDGET);
assert!(size_of::<AlterObjectDepends<NoExt>>() == ALTER_OBJECT_DEPENDS_SIZE_BUDGET);
assert!(size_of::<AlterObjectSchema>() == ALTER_OBJECT_SCHEMA_SIZE_BUDGET);
assert!(size_of::<AlterResourceGroup>() == ALTER_RESOURCE_GROUP_SIZE_BUDGET);
assert!(size_of::<AlterRoutine<NoExt>>() == ALTER_ROUTINE_SIZE_BUDGET);
assert!(size_of::<AlterSequence<NoExt>>() == ALTER_SEQUENCE_SIZE_BUDGET);
assert!(size_of::<AlterSequenceOption<NoExt>>() == ALTER_SEQUENCE_OPTION_SIZE_BUDGET);
assert!(size_of::<AlterServer>() == ALTER_SERVER_SIZE_BUDGET);
assert!(size_of::<AlterSystem>() == ALTER_SYSTEM_SIZE_BUDGET);
assert!(size_of::<AlterSystemAction>() == ALTER_SYSTEM_ACTION_SIZE_BUDGET);
assert!(size_of::<AlterTable<NoExt>>() == ALTER_TABLE_SIZE_BUDGET);
assert!(size_of::<AlterTableAction<NoExt>>() == ALTER_TABLE_ACTION_SIZE_BUDGET);
assert!(size_of::<AlterTablespace>() == ALTER_TABLESPACE_SIZE_BUDGET);
assert!(size_of::<AlterTablespaceAction>() == ALTER_TABLESPACE_ACTION_SIZE_BUDGET);
assert!(size_of::<AlterUser>() == ALTER_USER_SIZE_BUDGET);
assert!(size_of::<AlterUserSpec>() == ALTER_USER_SPEC_SIZE_BUDGET);
assert!(size_of::<AlterView<NoExt>>() == ALTER_VIEW_SIZE_BUDGET);
assert!(size_of::<AnalyzeHistogram>() == ANALYZE_HISTOGRAM_SIZE_BUDGET);
assert!(size_of::<AnalyzeStatement>() == ANALYZE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<ArrayExpr<NoExt>>() == ARRAY_EXPR_SIZE_BUDGET);
assert!(size_of::<AtTimeZoneExpr<NoExt>>() == AT_TIME_ZONE_EXPR_SIZE_BUDGET);
assert!(size_of::<AttachStatement<NoExt>>() == ATTACH_STATEMENT_SIZE_BUDGET);
assert!(size_of::<AuthOption>() == AUTH_OPTION_SIZE_BUDGET);
assert!(size_of::<CacheIndexKeyList>() == CACHE_INDEX_KEY_LIST_SIZE_BUDGET);
assert!(size_of::<CacheIndexStatement>() == CACHE_INDEX_STATEMENT_SIZE_BUDGET);
assert!(size_of::<CacheIndexTable>() == CACHE_INDEX_TABLE_SIZE_BUDGET);
assert!(size_of::<CacheIndexTargets>() == CACHE_INDEX_TARGETS_SIZE_BUDGET);
assert!(size_of::<CallStatement<NoExt>>() == CALL_STATEMENT_SIZE_BUDGET);
assert!(size_of::<CaseExpr<NoExt>>() == CASE_EXPR_SIZE_BUDGET);
assert!(size_of::<CaseStatement<NoExt>>() == CASE_STATEMENT_SIZE_BUDGET);
assert!(
size_of::<ChangeReplicationSourceOption>() == CHANGE_REPLICATION_SOURCE_OPTION_SIZE_BUDGET
);
assert!(
size_of::<ChangeReplicationSourceOptionValue>()
== CHANGE_REPLICATION_SOURCE_OPTION_VALUE_SIZE_BUDGET
);
assert!(size_of::<CharsetAnnotation>() == CHARSET_ANNOTATION_SIZE_BUDGET);
assert!(size_of::<CheckpointStatement>() == CHECKPOINT_STATEMENT_SIZE_BUDGET);
assert!(size_of::<CloseCursorStatement>() == CLOSE_CURSOR_STATEMENT_SIZE_BUDGET);
assert!(size_of::<CollateExpr<NoExt>>() == COLLATE_EXPR_SIZE_BUDGET);
assert!(size_of::<ColumnConstraint<NoExt>>() == COLUMN_CONSTRAINT_SIZE_BUDGET);
assert!(size_of::<ColumnDef<NoExt>>() == COLUMN_DEF_SIZE_BUDGET);
assert!(size_of::<ColumnOption<NoExt>>() == COLUMN_OPTION_SIZE_BUDGET);
assert!(size_of::<CommentOnStatement<NoExt>>() == COMMENT_ON_STATEMENT_SIZE_BUDGET);
assert!(size_of::<CompoundStatement<NoExt>>() == COMPOUND_STATEMENT_SIZE_BUDGET);
assert!(size_of::<ComprehensionSource<NoExt>>() == COMPREHENSION_SOURCE_SIZE_BUDGET);
assert!(size_of::<ConditionalBranch<NoExt>>() == CONDITIONAL_BRANCH_SIZE_BUDGET);
assert!(size_of::<ConditionInfoItem<NoExt>>() == CONDITION_INFO_ITEM_SIZE_BUDGET);
assert!(size_of::<ConditionValue>() == CONDITION_VALUE_SIZE_BUDGET);
assert!(size_of::<ConfigParameter>() == CONFIG_PARAMETER_SIZE_BUDGET);
assert!(size_of::<ConflictAction<NoExt>>() == CONFLICT_ACTION_SIZE_BUDGET);
assert!(size_of::<ConflictTarget<NoExt>>() == CONFLICT_TARGET_SIZE_BUDGET);
assert!(size_of::<ConstraintCharacteristics>() == CONSTRAINT_CHARACTERISTICS_SIZE_BUDGET);
assert!(size_of::<ConstraintsTarget>() == CONSTRAINTS_TARGET_SIZE_BUDGET);
assert!(size_of::<CopyIntoSource<NoExt>>() == COPY_INTO_SOURCE_SIZE_BUDGET);
assert!(size_of::<CopyIntoStatement<NoExt>>() == COPY_INTO_STATEMENT_SIZE_BUDGET);
assert!(size_of::<CopyIntoTarget>() == COPY_INTO_TARGET_SIZE_BUDGET);
assert!(size_of::<CopyOption>() == COPY_OPTION_SIZE_BUDGET);
assert!(size_of::<CopyOptionValue>() == COPY_OPTION_VALUE_SIZE_BUDGET);
assert!(size_of::<CopySource<NoExt>>() == COPY_SOURCE_SIZE_BUDGET);
assert!(size_of::<CopyStatement<NoExt>>() == COPY_STATEMENT_SIZE_BUDGET);
assert!(size_of::<CopyTarget>() == COPY_TARGET_SIZE_BUDGET);
assert!(size_of::<CreateDatabase>() == CREATE_DATABASE_SIZE_BUDGET);
assert!(size_of::<CreateColocationGroup>() == CREATE_COLOCATION_GROUP_SIZE_BUDGET);
assert!(size_of::<CreateEvent<NoExt>>() == CREATE_EVENT_SIZE_BUDGET);
assert!(size_of::<CreateExtension>() == CREATE_EXTENSION_SIZE_BUDGET);
assert!(size_of::<CreateExtensionOption>() == CREATE_EXTENSION_OPTION_SIZE_BUDGET);
assert!(size_of::<CreateFunction<NoExt>>() == CREATE_FUNCTION_SIZE_BUDGET);
assert!(size_of::<CreateIndex<NoExt>>() == CREATE_INDEX_SIZE_BUDGET);
assert!(size_of::<CreateLogfileGroup>() == CREATE_LOGFILE_GROUP_SIZE_BUDGET);
assert!(size_of::<CreateMacro<NoExt>>() == CREATE_MACRO_SIZE_BUDGET);
assert!(size_of::<CreateProcedure<NoExt>>() == CREATE_PROCEDURE_SIZE_BUDGET);
assert!(size_of::<CreateResourceGroup>() == CREATE_RESOURCE_GROUP_SIZE_BUDGET);
assert!(size_of::<CreateSchema<NoExt>>() == CREATE_SCHEMA_SIZE_BUDGET);
assert!(size_of::<CreateSecret<NoExt>>() == CREATE_SECRET_SIZE_BUDGET);
assert!(size_of::<CreateServer>() == CREATE_SERVER_SIZE_BUDGET);
assert!(size_of::<CreateSequence<NoExt>>() == CREATE_SEQUENCE_SIZE_BUDGET);
assert!(
size_of::<CreateSpatialReferenceSystem>() == CREATE_SPATIAL_REFERENCE_SYSTEM_SIZE_BUDGET
);
assert!(size_of::<CreateStoredTrigger<NoExt>>() == CREATE_STORED_TRIGGER_SIZE_BUDGET);
assert!(size_of::<CreateTable<NoExt>>() == CREATE_TABLE_SIZE_BUDGET);
assert!(size_of::<CreateTableBody<NoExt>>() == CREATE_TABLE_BODY_SIZE_BUDGET);
assert!(size_of::<CreateTableOption<NoExt>>() == CREATE_TABLE_OPTION_SIZE_BUDGET);
assert!(size_of::<CreateTableOptionKind<NoExt>>() == CREATE_TABLE_OPTION_KIND_SIZE_BUDGET);
assert!(size_of::<CreateTablespace>() == CREATE_TABLESPACE_SIZE_BUDGET);
assert!(size_of::<CreateTrigger<NoExt>>() == CREATE_TRIGGER_SIZE_BUDGET);
assert!(size_of::<CreateType<NoExt>>() == CREATE_TYPE_SIZE_BUDGET);
assert!(size_of::<CreateTypeDefinition<NoExt>>() == CREATE_TYPE_DEFINITION_SIZE_BUDGET);
assert!(size_of::<CreateUser>() == CREATE_USER_SIZE_BUDGET);
assert!(size_of::<CreateView<NoExt>>() == CREATE_VIEW_SIZE_BUDGET);
assert!(size_of::<CreateVirtualTable>() == CREATE_VIRTUAL_TABLE_SIZE_BUDGET);
assert!(size_of::<Cte<NoExt>>() == CTE_SIZE_BUDGET);
assert!(size_of::<CteBody<NoExt>>() == CTE_BODY_SIZE_BUDGET);
assert!(size_of::<CteCycleClause<NoExt>>() == CTE_CYCLE_CLAUSE_SIZE_BUDGET);
assert!(size_of::<CteCycleMark<NoExt>>() == CTE_CYCLE_MARK_SIZE_BUDGET);
assert!(size_of::<CteSearchClause>() == CTE_SEARCH_CLAUSE_SIZE_BUDGET);
assert!(size_of::<DataType<NoExt>>() == DATA_TYPE_SIZE_BUDGET);
assert!(size_of::<DeallocateStatement>() == DEALLOCATE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<Declaration<NoExt>>() == DECLARATION_SIZE_BUDGET);
assert!(size_of::<DefaultRoleTarget>() == DEFAULT_ROLE_TARGET_SIZE_BUDGET);
assert!(size_of::<DefaultValue>() == DEFAULT_VALUE_SIZE_BUDGET);
assert!(size_of::<Definer>() == DEFINER_SIZE_BUDGET);
assert!(size_of::<Delete<NoExt>>() == DELETE_SIZE_BUDGET);
assert!(size_of::<DescribeColumn>() == DESCRIBE_COLUMN_SIZE_BUDGET);
assert!(size_of::<DescribeStatement>() == DESCRIBE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<DetachStatement>() == DETACH_STATEMENT_SIZE_BUDGET);
assert!(size_of::<DiagnosticsInfo<NoExt>>() == DIAGNOSTICS_INFO_SIZE_BUDGET);
assert!(size_of::<DmlSelection<NoExt>>() == DML_SELECTION_SIZE_BUDGET);
assert!(size_of::<DmlTarget>() == DML_TARGET_SIZE_BUDGET);
assert!(size_of::<DoArg>() == DO_ARG_SIZE_BUDGET);
assert!(size_of::<DoExpressionsStatement<NoExt>>() == DO_EXPRESSIONS_STATEMENT_SIZE_BUDGET);
assert!(size_of::<DoStatement>() == DO_STATEMENT_SIZE_BUDGET);
assert!(size_of::<DropDatabase>() == DROP_DATABASE_SIZE_BUDGET);
assert!(size_of::<DropColocationGroup>() == DROP_COLOCATION_GROUP_SIZE_BUDGET);
assert!(size_of::<DropEvent>() == DROP_EVENT_SIZE_BUDGET);
assert!(size_of::<DropIndexOnTable>() == DROP_INDEX_ON_TABLE_SIZE_BUDGET);
assert!(size_of::<DropLogfileGroup>() == DROP_LOGFILE_GROUP_SIZE_BUDGET);
assert!(size_of::<DropResourceGroup>() == DROP_RESOURCE_GROUP_SIZE_BUDGET);
assert!(size_of::<DropSecretStmt>() == DROP_SECRET_STMT_SIZE_BUDGET);
assert!(size_of::<DropServer>() == DROP_SERVER_SIZE_BUDGET);
assert!(size_of::<DropSpatialReferenceSystem>() == DROP_SPATIAL_REFERENCE_SYSTEM_SIZE_BUDGET);
assert!(size_of::<DropStatement>() == DROP_STATEMENT_SIZE_BUDGET);
assert!(size_of::<DropTablespace>() == DROP_TABLESPACE_SIZE_BUDGET);
assert!(size_of::<DropTransform<NoExt>>() == DROP_TRANSFORM_SIZE_BUDGET);
assert!(size_of::<EventSchedule<NoExt>>() == EVENT_SCHEDULE_SIZE_BUDGET);
assert!(size_of::<ExcludeConstraint<NoExt>>() == EXCLUDE_CONSTRAINT_SIZE_BUDGET);
assert!(size_of::<ExcludeElement<NoExt>>() == EXCLUDE_ELEMENT_SIZE_BUDGET);
assert!(size_of::<ExecuteStatement<NoExt>>() == EXECUTE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<ExecuteUsingStatement>() == EXECUTE_USING_STATEMENT_SIZE_BUDGET);
assert!(size_of::<ExplainOption>() == EXPLAIN_OPTION_SIZE_BUDGET);
assert!(size_of::<ExplainStatement<NoExt>>() == EXPLAIN_STATEMENT_SIZE_BUDGET);
assert!(size_of::<ExportStatement>() == EXPORT_STATEMENT_SIZE_BUDGET);
assert!(size_of::<Expr<NoExt>>() == EXPR_SIZE_BUDGET);
assert!(size_of::<ExtensionVersion>() == EXTENSION_VERSION_SIZE_BUDGET);
assert!(size_of::<ExtractExpr<NoExt>>() == EXTRACT_EXPR_SIZE_BUDGET);
assert!(size_of::<FetchCursorStatement>() == FETCH_CURSOR_STATEMENT_SIZE_BUDGET);
assert!(size_of::<FieldSelectionExpr<NoExt>>() == FIELD_SELECTION_EXPR_SIZE_BUDGET);
assert!(size_of::<FieldSelector>() == FIELD_SELECTOR_SIZE_BUDGET);
assert!(size_of::<FlushOption>() == FLUSH_OPTION_SIZE_BUDGET);
assert!(size_of::<FlushStatement>() == FLUSH_STATEMENT_SIZE_BUDGET);
assert!(size_of::<FlushTarget>() == FLUSH_TARGET_SIZE_BUDGET);
assert!(size_of::<ForceSeekTarget>() == FORCE_SEEK_TARGET_SIZE_BUDGET);
assert!(size_of::<ForeignKeyRef>() == FOREIGN_KEY_REF_SIZE_BUDGET);
assert!(size_of::<ForClause>() == FOR_CLAUSE_SIZE_BUDGET);
assert!(size_of::<ForRoot>() == FOR_ROOT_SIZE_BUDGET);
assert!(size_of::<ForXmlMode>() == FOR_XML_MODE_SIZE_BUDGET);
assert!(size_of::<FormatClause>() == FORMAT_CLAUSE_SIZE_BUDGET);
assert!(size_of::<FunctionArg<NoExt>>() == FUNCTION_ARG_SIZE_BUDGET);
assert!(size_of::<FunctionBody<NoExt>>() == FUNCTION_BODY_SIZE_BUDGET);
assert!(size_of::<FunctionCall<NoExt>>() == FUNCTION_CALL_SIZE_BUDGET);
assert!(size_of::<FunctionOption<NoExt>>() == FUNCTION_OPTION_SIZE_BUDGET);
assert!(size_of::<FunctionParam<NoExt>>() == FUNCTION_PARAM_SIZE_BUDGET);
assert!(size_of::<FunctionParamDefault<NoExt>>() == FUNCTION_PARAM_DEFAULT_SIZE_BUDGET);
assert!(size_of::<GeneratedColumn<NoExt>>() == GENERATED_COLUMN_SIZE_BUDGET);
assert!(size_of::<GetDiagnosticsStatement<NoExt>>() == GET_DIAGNOSTICS_STATEMENT_SIZE_BUDGET);
assert!(size_of::<GrantAs>() == GRANT_AS_SIZE_BUDGET);
assert!(size_of::<GrantObject<NoExt>>() == GRANT_OBJECT_SIZE_BUDGET);
assert!(size_of::<Grantee>() == GRANTEE_SIZE_BUDGET);
assert!(size_of::<PrivilegeLevelObject>() == PRIVILEGE_LEVEL_OBJECT_SIZE_BUDGET);
assert!(size_of::<PrivilegeLevel>() == PRIVILEGE_LEVEL_SIZE_BUDGET);
assert!(size_of::<WithRoleSpec>() == WITH_ROLE_SPEC_SIZE_BUDGET);
assert!(size_of::<GroupByItem<NoExt>>() == GROUP_BY_ITEM_SIZE_BUDGET);
assert!(size_of::<GroupReplicationOption>() == GROUP_REPLICATION_OPTION_SIZE_BUDGET);
assert!(size_of::<HandlerCondition>() == HANDLER_CONDITION_SIZE_BUDGET);
assert!(size_of::<HandlerStatement<NoExt>>() == HANDLER_STATEMENT_SIZE_BUDGET);
assert!(size_of::<HandlerOperation<NoExt>>() == HANDLER_OPERATION_SIZE_BUDGET);
assert!(size_of::<HandlerReadSelector<NoExt>>() == HANDLER_READ_SELECTOR_SIZE_BUDGET);
assert!(size_of::<CloneStatement>() == CLONE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<CloneDataDirectory>() == CLONE_DATA_DIRECTORY_SIZE_BUDGET);
assert!(size_of::<ImportTableStatement>() == IMPORT_TABLE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<HelpStatement>() == HELP_STATEMENT_SIZE_BUDGET);
assert!(size_of::<BinlogStatement>() == BINLOG_STATEMENT_SIZE_BUDGET);
assert!(size_of::<HierarchicalClause<NoExt>>() == HIERARCHICAL_CLAUSE_SIZE_BUDGET);
assert!(size_of::<Ident>() == IDENT_SIZE_BUDGET);
assert!(size_of::<IdentityColumn<NoExt>>() == IDENTITY_COLUMN_SIZE_BUDGET);
assert!(size_of::<IdentityOption<NoExt>>() == IDENTITY_OPTION_SIZE_BUDGET);
assert!(size_of::<IfStatement<NoExt>>() == IF_STATEMENT_SIZE_BUDGET);
assert!(size_of::<ImportStatement>() == IMPORT_STATEMENT_SIZE_BUDGET);
assert!(size_of::<IndexColumn<NoExt>>() == INDEX_COLUMN_SIZE_BUDGET);
assert!(size_of::<IndexHint>() == INDEX_HINT_SIZE_BUDGET);
assert!(size_of::<IndexedBy>() == INDEXED_BY_SIZE_BUDGET);
assert!(size_of::<Insert<NoExt>>() == INSERT_SIZE_BUDGET);
assert!(size_of::<InsertSource<NoExt>>() == INSERT_SOURCE_SIZE_BUDGET);
assert!(size_of::<InsertTarget>() == INSERT_TARGET_SIZE_BUDGET);
assert!(size_of::<InsertValue<NoExt>>() == INSERT_VALUE_SIZE_BUDGET);
assert!(size_of::<InsertValues<NoExt>>() == INSERT_VALUES_SIZE_BUDGET);
assert!(size_of::<InstanceLockStatement>() == INSTANCE_LOCK_STATEMENT_SIZE_BUDGET);
assert!(size_of::<IntoTarget>() == INTO_TARGET_SIZE_BUDGET);
assert!(size_of::<IsJsonExpr<NoExt>>() == IS_JSON_EXPR_SIZE_BUDGET);
assert!(size_of::<IterateStatement>() == ITERATE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<Join<NoExt>>() == JOIN_SIZE_BUDGET);
assert!(size_of::<JoinConstraint<NoExt>>() == JOIN_CONSTRAINT_SIZE_BUDGET);
assert!(size_of::<JoinOperator<NoExt>>() == JOIN_OPERATOR_SIZE_BUDGET);
assert!(size_of::<JsonAggregateBody<NoExt>>() == JSON_AGGREGATE_BODY_SIZE_BUDGET);
assert!(size_of::<JsonAggregateExpr<NoExt>>() == JSON_AGGREGATE_EXPR_SIZE_BUDGET);
assert!(size_of::<JsonArrayBody<NoExt>>() == JSON_ARRAY_BODY_SIZE_BUDGET);
assert!(size_of::<JsonArrayExpr<NoExt>>() == JSON_ARRAY_EXPR_SIZE_BUDGET);
assert!(size_of::<JsonBehavior<NoExt>>() == JSON_BEHAVIOR_SIZE_BUDGET);
assert!(size_of::<JsonConstructorExpr<NoExt>>() == JSON_CONSTRUCTOR_EXPR_SIZE_BUDGET);
assert!(size_of::<JsonFuncExpr<NoExt>>() == JSON_FUNC_EXPR_SIZE_BUDGET);
assert!(size_of::<JsonKeyValue<NoExt>>() == JSON_KEY_VALUE_SIZE_BUDGET);
assert!(size_of::<JsonObjectExpr<NoExt>>() == JSON_OBJECT_EXPR_SIZE_BUDGET);
assert!(size_of::<JsonPassingArg<NoExt>>() == JSON_PASSING_ARG_SIZE_BUDGET);
assert!(size_of::<JsonReturning<NoExt>>() == JSON_RETURNING_SIZE_BUDGET);
assert!(size_of::<JsonTable<NoExt>>() == JSON_TABLE_SIZE_BUDGET);
assert!(size_of::<JsonTableColumn<NoExt>>() == JSON_TABLE_COLUMN_SIZE_BUDGET);
assert!(size_of::<JsonValueExpr<NoExt>>() == JSON_VALUE_EXPR_SIZE_BUDGET);
assert!(size_of::<KeyCacheName>() == KEY_CACHE_NAME_SIZE_BUDGET);
assert!(size_of::<LambdaExpr<NoExt>>() == LAMBDA_EXPR_SIZE_BUDGET);
assert!(size_of::<LanguageName>() == LANGUAGE_NAME_SIZE_BUDGET);
assert!(size_of::<LateralView<NoExt>>() == LATERAL_VIEW_SIZE_BUDGET);
assert!(size_of::<LeaveStatement>() == LEAVE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<KillStatement<NoExt>>() == KILL_STATEMENT_SIZE_BUDGET);
assert!(size_of::<InstallStatement<NoExt>>() == INSTALL_STATEMENT_SIZE_BUDGET);
assert!(size_of::<UninstallStatement>() == UNINSTALL_STATEMENT_SIZE_BUDGET);
assert!(
size_of::<InstallComponentSetElement<NoExt>>() == INSTALL_COMPONENT_SET_ELEMENT_SIZE_BUDGET
);
assert!(
size_of::<InstallComponentSetValue<NoExt>>() == INSTALL_COMPONENT_SET_VALUE_SIZE_BUDGET
);
assert!(size_of::<Limit<NoExt>>() == LIMIT_SIZE_BUDGET);
assert!(size_of::<LimitBy<NoExt>>() == LIMIT_BY_SIZE_BUDGET);
assert!(size_of::<ListComprehension<NoExt>>() == LIST_COMPREHENSION_SIZE_BUDGET);
assert!(size_of::<Literal>() == LITERAL_SIZE_BUDGET);
assert!(size_of::<LoadDataEnclosed>() == LOAD_DATA_ENCLOSED_SIZE_BUDGET);
assert!(size_of::<LoadDataFieldOrVar>() == LOAD_DATA_FIELD_OR_VAR_SIZE_BUDGET);
assert!(size_of::<LoadDataFields>() == LOAD_DATA_FIELDS_SIZE_BUDGET);
assert!(size_of::<LoadDataIgnoreRows>() == LOAD_DATA_IGNORE_ROWS_SIZE_BUDGET);
assert!(size_of::<LoadDataLines>() == LOAD_DATA_LINES_SIZE_BUDGET);
assert!(size_of::<LoadDataStatement<NoExt>>() == LOAD_DATA_STATEMENT_SIZE_BUDGET);
assert!(size_of::<LoadIndexStatement>() == LOAD_INDEX_STATEMENT_SIZE_BUDGET);
assert!(size_of::<LoadIndexTable>() == LOAD_INDEX_TABLE_SIZE_BUDGET);
assert!(size_of::<LoadIndexTargets>() == LOAD_INDEX_TARGETS_SIZE_BUDGET);
assert!(size_of::<LoadStatement>() == LOAD_STATEMENT_SIZE_BUDGET);
assert!(size_of::<LoadTarget>() == LOAD_TARGET_SIZE_BUDGET);
assert!(size_of::<LockTablesStatement>() == LOCK_TABLES_STATEMENT_SIZE_BUDGET);
assert!(size_of::<LockingClause>() == LOCKING_CLAUSE_SIZE_BUDGET);
assert!(size_of::<LoopStatement<NoExt>>() == LOOP_STATEMENT_SIZE_BUDGET);
assert!(size_of::<MacroBody<NoExt>>() == MACRO_BODY_SIZE_BUDGET);
assert!(size_of::<MacroParam<NoExt>>() == MACRO_PARAM_SIZE_BUDGET);
assert!(size_of::<MapEntry<NoExt>>() == MAP_ENTRY_SIZE_BUDGET);
assert!(size_of::<MapExpr<NoExt>>() == MAP_EXPR_SIZE_BUDGET);
assert!(size_of::<MatchRecognize<NoExt>>() == MATCH_RECOGNIZE_SIZE_BUDGET);
assert!(size_of::<MatchRecognizePattern>() == MATCH_RECOGNIZE_PATTERN_SIZE_BUDGET);
assert!(size_of::<Measure<NoExt>>() == MEASURE_SIZE_BUDGET);
assert!(size_of::<Merge<NoExt>>() == MERGE_SIZE_BUDGET);
assert!(size_of::<MergeAction<NoExt>>() == MERGE_ACTION_SIZE_BUDGET);
assert!(size_of::<MergeWhenClause<NoExt>>() == MERGE_WHEN_CLAUSE_SIZE_BUDGET);
assert!(size_of::<ModuleArg>() == MODULE_ARG_SIZE_BUDGET);
assert!(size_of::<AccountName>() == ACCOUNT_NAME_SIZE_BUDGET);
assert!(size_of::<NamedOperatorExpr<NoExt>>() == NAMED_OPERATOR_EXPR_SIZE_BUDGET);
assert!(size_of::<NamedWindow<NoExt>>() == NAMED_WINDOW_SIZE_BUDGET);
assert!(size_of::<ObjectName>() == OBJECT_NAME_SIZE_BUDGET);
assert!(size_of::<ObjectReference<NoExt>>() == OBJECT_REFERENCE_SIZE_BUDGET);
assert!(size_of::<OnConflict<NoExt>>() == ON_CONFLICT_SIZE_BUDGET);
assert!(size_of::<OpenCursorStatement>() == OPEN_CURSOR_STATEMENT_SIZE_BUDGET);
assert!(size_of::<OpenJson<NoExt>>() == OPEN_JSON_SIZE_BUDGET);
assert!(size_of::<OpenJsonColumn<NoExt>>() == OPEN_JSON_COLUMN_SIZE_BUDGET);
assert!(size_of::<OperatorArgs<NoExt>>() == OPERATOR_ARGS_SIZE_BUDGET);
assert!(size_of::<OrderByAll>() == ORDER_BY_ALL_SIZE_BUDGET);
assert!(size_of::<OrderByExpr<NoExt>>() == ORDER_BY_EXPR_SIZE_BUDGET);
assert!(size_of::<OrderByUsing>() == ORDER_BY_USING_SIZE_BUDGET);
assert!(size_of::<PartitionBound<NoExt>>() == PARTITION_BOUND_SIZE_BUDGET);
assert!(size_of::<PartitionElem<NoExt>>() == PARTITION_ELEM_SIZE_BUDGET);
assert!(size_of::<PartitionSelection>() == PARTITION_SELECTION_SIZE_BUDGET);
assert!(size_of::<PartitionSpec<NoExt>>() == PARTITION_SPEC_SIZE_BUDGET);
assert!(size_of::<PasswordLockOption>() == PASSWORD_LOCK_OPTION_SIZE_BUDGET);
assert!(size_of::<PipeAggregateExpr<NoExt>>() == PIPE_AGGREGATE_EXPR_SIZE_BUDGET);
assert!(size_of::<PipeOperator<NoExt>>() == PIPE_OPERATOR_SIZE_BUDGET);
assert!(size_of::<PipeRenameItem>() == PIPE_RENAME_ITEM_SIZE_BUDGET);
assert!(size_of::<Pivot<NoExt>>() == PIVOT_SIZE_BUDGET);
assert!(size_of::<PivotColumn<NoExt>>() == PIVOT_COLUMN_SIZE_BUDGET);
assert!(size_of::<PivotExpr<NoExt>>() == PIVOT_EXPR_SIZE_BUDGET);
assert!(size_of::<PivotValueSource<NoExt>>() == PIVOT_VALUE_SOURCE_SIZE_BUDGET);
assert!(size_of::<PostfixOperatorExpr<NoExt>>() == POSTFIX_OPERATOR_EXPR_SIZE_BUDGET);
assert!(size_of::<PragmaStatement>() == PRAGMA_STATEMENT_SIZE_BUDGET);
assert!(size_of::<PrefixOperatorExpr<NoExt>>() == PREFIX_OPERATOR_EXPR_SIZE_BUDGET);
assert!(size_of::<PrepareFromStatement>() == PREPARE_FROM_STATEMENT_SIZE_BUDGET);
assert!(size_of::<PrepareSource>() == PREPARE_SOURCE_SIZE_BUDGET);
assert!(size_of::<PrepareStatement<NoExt>>() == PREPARE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<Privilege>() == PRIVILEGE_SIZE_BUDGET);
assert!(size_of::<Privileges>() == PRIVILEGES_SIZE_BUDGET);
assert!(size_of::<PurgeStatement<NoExt>>() == PURGE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<PurgeTarget<NoExt>>() == PURGE_TARGET_SIZE_BUDGET);
assert!(size_of::<Query<NoExt>>() == QUERY_SIZE_BUDGET);
assert!(size_of::<ReferentialAction>() == REFERENTIAL_ACTION_SIZE_BUDGET);
assert!(size_of::<RefreshMaterializedView>() == REFRESH_MATERIALIZED_VIEW_SIZE_BUDGET);
assert!(size_of::<ReindexStatement>() == REINDEX_STATEMENT_SIZE_BUDGET);
assert!(size_of::<RenameStatement>() == RENAME_STATEMENT_SIZE_BUDGET);
assert!(size_of::<ResourceLimit>() == RESOURCE_LIMIT_SIZE_BUDGET);
assert!(size_of::<Returning<NoExt>>() == RETURNING_SIZE_BUDGET);
assert!(size_of::<RepeatStatement<NoExt>>() == REPEAT_STATEMENT_SIZE_BUDGET);
assert!(size_of::<ReplicaThreadOption>() == REPLICA_THREAD_OPTION_SIZE_BUDGET);
assert!(size_of::<ReplicaUntilCondition>() == REPLICA_UNTIL_CONDITION_SIZE_BUDGET);
assert!(size_of::<ReplicationFilterRule>() == REPLICATION_FILTER_RULE_SIZE_BUDGET);
assert!(size_of::<ReplicationStatement>() == REPLICATION_STATEMENT_SIZE_BUDGET);
assert!(size_of::<ResourceGroupThreadPriority>() == RESOURCE_GROUP_THREAD_PRIORITY_SIZE_BUDGET);
assert!(size_of::<ResourceGroupVcpu>() == RESOURCE_GROUP_VCPU_SIZE_BUDGET);
assert!(size_of::<ReturnStatement<NoExt>>() == RETURN_STATEMENT_SIZE_BUDGET);
assert!(size_of::<RewriteDbPair>() == REWRITE_DB_PAIR_SIZE_BUDGET);
assert!(size_of::<RoleSpec>() == ROLE_SPEC_SIZE_BUDGET);
assert!(size_of::<RoutineSignature<NoExt>>() == ROUTINE_SIGNATURE_SIZE_BUDGET);
assert!(size_of::<RowExpr<NoExt>>() == ROW_EXPR_SIZE_BUDGET);
assert!(size_of::<RowsFromItem<NoExt>>() == ROWS_FROM_ITEM_SIZE_BUDGET);
assert!(size_of::<SampleClause>() == SAMPLE_CLAUSE_SIZE_BUDGET);
assert!(size_of::<SecretOption<NoExt>>() == SECRET_OPTION_SIZE_BUDGET);
assert!(size_of::<Select<NoExt>>() == SELECT_SIZE_BUDGET);
assert!(size_of::<SelectDistinct<NoExt>>() == SELECT_DISTINCT_SIZE_BUDGET);
assert!(size_of::<SelectItem<NoExt>>() == SELECT_ITEM_SIZE_BUDGET);
assert!(
size_of::<SemiStructuredAccessExpr<NoExt>>() == SEMI_STRUCTURED_ACCESS_EXPR_SIZE_BUDGET
);
assert!(
size_of::<SemiStructuredPathSegment<NoExt>>() == SEMI_STRUCTURED_PATH_SEGMENT_SIZE_BUDGET
);
assert!(size_of::<ServerOption>() == SERVER_OPTION_SIZE_BUDGET);
assert!(size_of::<SessionStatement<NoExt>>() == SESSION_STATEMENT_SIZE_BUDGET);
assert!(size_of::<SetCharacterSetValue>() == SET_CHARACTER_SET_VALUE_SIZE_BUDGET);
assert!(size_of::<SetExpr<NoExt>>() == SET_EXPR_SIZE_BUDGET);
assert!(size_of::<SetNamesValue>() == SET_NAMES_VALUE_SIZE_BUDGET);
assert!(size_of::<SetParameterValue>() == SET_PARAMETER_VALUE_SIZE_BUDGET);
assert!(size_of::<SetValue>() == SET_VALUE_SIZE_BUDGET);
assert!(size_of::<SetVariableAssignment<NoExt>>() == SET_VARIABLE_ASSIGNMENT_SIZE_BUDGET);
assert!(size_of::<SetVariableValue<NoExt>>() == SET_VARIABLE_VALUE_SIZE_BUDGET);
assert!(size_of::<Setting<NoExt>>() == SETTING_SIZE_BUDGET);
assert!(size_of::<ShowFilter<NoExt>>() == SHOW_FILTER_SIZE_BUDGET);
assert!(size_of::<ShowFrom>() == SHOW_FROM_SIZE_BUDGET);
assert!(size_of::<ShowFunctionsFilter>() == SHOW_FUNCTIONS_FILTER_SIZE_BUDGET);
assert!(size_of::<ShowLimit>() == SHOW_LIMIT_SIZE_BUDGET);
assert!(size_of::<ShowRef<NoExt>>() == SHOW_REF_SIZE_BUDGET);
assert!(size_of::<ShowRefTarget<NoExt>>() == SHOW_REF_TARGET_SIZE_BUDGET);
assert!(size_of::<ShowStatement<NoExt>>() == SHOW_STATEMENT_SIZE_BUDGET);
assert!(size_of::<ShowTarget<NoExt>>() == SHOW_TARGET_SIZE_BUDGET);
assert!(size_of::<SignalItem<NoExt>>() == SIGNAL_ITEM_SIZE_BUDGET);
assert!(size_of::<SignalStatement<NoExt>>() == SIGNAL_STATEMENT_SIZE_BUDGET);
assert!(size_of::<SizeLiteral>() == SIZE_LITERAL_SIZE_BUDGET);
assert!(size_of::<SpecialSetValue>() == SPECIAL_SET_VALUE_SIZE_BUDGET);
assert!(size_of::<SrsAttribute>() == SRS_ATTRIBUTE_SIZE_BUDGET);
assert!(size_of::<Statement<NoExt>>() == STATEMENT_SIZE_BUDGET);
assert!(size_of::<StatementInfoItem<NoExt>>() == STATEMENT_INFO_ITEM_SIZE_BUDGET);
assert!(size_of::<StructConstructorArg<NoExt>>() == STRUCT_CONSTRUCTOR_ARG_SIZE_BUDGET);
assert!(size_of::<StructConstructorExpr<NoExt>>() == STRUCT_CONSTRUCTOR_EXPR_SIZE_BUDGET);
assert!(size_of::<StructConstructorField<NoExt>>() == STRUCT_CONSTRUCTOR_FIELD_SIZE_BUDGET);
assert!(size_of::<StructExpr<NoExt>>() == STRUCT_EXPR_SIZE_BUDGET);
assert!(size_of::<StructField<NoExt>>() == STRUCT_FIELD_SIZE_BUDGET);
assert!(size_of::<StructTypeField<NoExt>>() == STRUCT_TYPE_FIELD_SIZE_BUDGET);
assert!(size_of::<SubscriptExpr<NoExt>>() == SUBSCRIPT_EXPR_SIZE_BUDGET);
assert!(size_of::<SubsetDefinition>() == SUBSET_DEFINITION_SIZE_BUDGET);
assert!(size_of::<SymbolDefinition<NoExt>>() == SYMBOL_DEFINITION_SIZE_BUDGET);
assert!(size_of::<TableAlias>() == TABLE_ALIAS_SIZE_BUDGET);
assert!(size_of::<StringFunc<NoExt>>() == STRING_FUNC_SIZE_BUDGET);
assert!(size_of::<TableConstraint<NoExt>>() == TABLE_CONSTRAINT_SIZE_BUDGET);
assert!(size_of::<TableConstraintDef<NoExt>>() == TABLE_CONSTRAINT_DEF_SIZE_BUDGET);
assert!(size_of::<TableElement<NoExt>>() == TABLE_ELEMENT_SIZE_BUDGET);
assert!(size_of::<TableFactor<NoExt>>() == TABLE_FACTOR_SIZE_BUDGET);
assert!(size_of::<TableFunctionColumn<NoExt>>() == TABLE_FUNCTION_COLUMN_SIZE_BUDGET);
assert!(size_of::<TableHint>() == TABLE_HINT_SIZE_BUDGET);
assert!(size_of::<TableLikeOption>() == TABLE_LIKE_OPTION_SIZE_BUDGET);
assert!(size_of::<TableLock>() == TABLE_LOCK_SIZE_BUDGET);
assert!(size_of::<TableMaintenanceKind>() == TABLE_MAINTENANCE_KIND_SIZE_BUDGET);
assert!(size_of::<TableMaintenanceStatement>() == TABLE_MAINTENANCE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<TableOption>() == TABLE_OPTION_SIZE_BUDGET);
assert!(size_of::<TableOptionValue>() == TABLE_OPTION_VALUE_SIZE_BUDGET);
assert!(size_of::<TableRename>() == TABLE_RENAME_SIZE_BUDGET);
assert!(size_of::<TableSample<NoExt>>() == TABLE_SAMPLE_SIZE_BUDGET);
assert!(size_of::<TableStorageParameter<NoExt>>() == TABLE_STORAGE_PARAMETER_SIZE_BUDGET);
assert!(size_of::<TableVersion<NoExt>>() == TABLE_VERSION_SIZE_BUDGET);
assert!(size_of::<TableWithJoins<NoExt>>() == TABLE_WITH_JOINS_SIZE_BUDGET);
assert!(size_of::<TablespaceOption>() == TABLESPACE_OPTION_SIZE_BUDGET);
assert!(size_of::<TlsOption>() == TLS_OPTION_SIZE_BUDGET);
assert!(size_of::<TlsRequirement>() == TLS_REQUIREMENT_SIZE_BUDGET);
assert!(size_of::<TransactionMode>() == TRANSACTION_MODE_SIZE_BUDGET);
assert!(size_of::<TransactionStatement>() == TRANSACTION_STATEMENT_SIZE_BUDGET);
assert!(size_of::<TriggerEvent>() == TRIGGER_EVENT_SIZE_BUDGET);
assert!(size_of::<TriggerOrder>() == TRIGGER_ORDER_SIZE_BUDGET);
assert!(size_of::<UnlockTablesStatement>() == UNLOCK_TABLES_STATEMENT_SIZE_BUDGET);
assert!(size_of::<Unpivot<NoExt>>() == UNPIVOT_SIZE_BUDGET);
assert!(size_of::<UnpivotColumn<NoExt>>() == UNPIVOT_COLUMN_SIZE_BUDGET);
assert!(size_of::<Update<NoExt>>() == UPDATE_SIZE_BUDGET);
assert!(size_of::<UpdateAssignment<NoExt>>() == UPDATE_ASSIGNMENT_SIZE_BUDGET);
assert!(size_of::<UpdateExtensionsStatement>() == UPDATE_EXTENSIONS_STATEMENT_SIZE_BUDGET);
assert!(size_of::<UpdateTupleSource<NoExt>>() == UPDATE_TUPLE_SOURCE_SIZE_BUDGET);
assert!(size_of::<UpdateValue<NoExt>>() == UPDATE_VALUE_SIZE_BUDGET);
assert!(size_of::<Upsert<NoExt>>() == UPSERT_SIZE_BUDGET);
assert!(size_of::<UseStatement>() == USE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<UserAttribute>() == USER_ATTRIBUTE_SIZE_BUDGET);
assert!(size_of::<UserRename>() == USER_RENAME_SIZE_BUDGET);
assert!(size_of::<UserRoleList>() == USER_ROLE_LIST_SIZE_BUDGET);
assert!(size_of::<UserSpec>() == USER_SPEC_SIZE_BUDGET);
assert!(size_of::<VacuumStatement<NoExt>>() == VACUUM_STATEMENT_SIZE_BUDGET);
assert!(size_of::<Values<NoExt>>() == VALUES_SIZE_BUDGET);
assert!(size_of::<ValuesItem<NoExt>>() == VALUES_ITEM_SIZE_BUDGET);
assert!(size_of::<VcpuRange>() == VCPU_RANGE_SIZE_BUDGET);
assert!(size_of::<WhenClause<NoExt>>() == WHEN_CLAUSE_SIZE_BUDGET);
assert!(size_of::<WhileStatement<NoExt>>() == WHILE_STATEMENT_SIZE_BUDGET);
assert!(size_of::<WildcardOptions<NoExt>>() == WILDCARD_OPTIONS_SIZE_BUDGET);
assert!(size_of::<WildcardRename>() == WILDCARD_RENAME_SIZE_BUDGET);
assert!(size_of::<WildcardReplace<NoExt>>() == WILDCARD_REPLACE_SIZE_BUDGET);
assert!(size_of::<WindowDefinition<NoExt>>() == WINDOW_DEFINITION_SIZE_BUDGET);
assert!(size_of::<WindowFrame<NoExt>>() == WINDOW_FRAME_SIZE_BUDGET);
assert!(size_of::<WindowFrameBound<NoExt>>() == WINDOW_FRAME_BOUND_SIZE_BUDGET);
assert!(size_of::<WindowSpec<NoExt>>() == WINDOW_SPEC_SIZE_BUDGET);
assert!(size_of::<With<NoExt>>() == WITH_SIZE_BUDGET);
assert!(size_of::<XaStatement>() == XA_STATEMENT_SIZE_BUDGET);
assert!(size_of::<Xid>() == XID_SIZE_BUDGET);
assert!(size_of::<XmlAttribute<NoExt>>() == XML_ATTRIBUTE_SIZE_BUDGET);
assert!(size_of::<XmlFunc<NoExt>>() == XML_FUNC_SIZE_BUDGET);
assert!(size_of::<XmlNamespace<NoExt>>() == XML_NAMESPACE_SIZE_BUDGET);
assert!(size_of::<XmlTable<NoExt>>() == XML_TABLE_SIZE_BUDGET);
assert!(size_of::<XmlTableColumn<NoExt>>() == XML_TABLE_COLUMN_SIZE_BUDGET);
};