Struct mariadb_sys::TABLE

#[repr(C)]
pub struct TABLE {

    pub s: *mut TABLE_SHARE,
    pub file: *mut handler,
    pub next: *mut TABLE,
    pub prev: *mut TABLE,
    pub share_all_next: *mut TABLE,
    pub share_all_prev: *mut *mut TABLE,
    pub global_free_next: *mut TABLE,
    pub global_free_prev: *mut *mut TABLE,
    pub instance: uint32,
    pub in_use: *mut THD,
    pub record: [*mut uchar; 3],
    pub write_row_record: *mut uchar,
    pub insert_values: *mut uchar,
    pub covering_keys: key_map,
    pub intersect_keys: key_map,
    pub keys_in_use_for_query: key_map,
    pub keys_in_use_for_group_by: key_map,
    pub keys_in_use_for_order_by: key_map,
    pub constraint_dependent_keys: key_map,
    pub key_info: *mut KEY,
    pub field: *mut *mut Field,
    pub vfield: *mut *mut Field,
    pub default_field: *mut *mut Field,
    pub next_number_field: *mut Field,
    pub found_next_number_field: *mut Field,
    pub check_constraints: *mut *mut Virtual_column_info,
    pub triggers: *mut Table_triggers_list,
    pub pos_in_table_list: *mut TABLE_LIST,
    pub pos_in_locked_tables: *mut TABLE_LIST,
    pub internal_tables: *mut TABLE_LIST,
    pub group: *mut ORDER,
    pub alias: String,
    pub null_flags: *mut uchar,
    pub def_read_set: MY_BITMAP,
    pub def_write_set: MY_BITMAP,
    pub tmp_set: MY_BITMAP,
    pub def_rpl_write_set: MY_BITMAP,
    pub eq_join_set: MY_BITMAP,
    pub cond_set: MY_BITMAP,
    pub read_set: *mut MY_BITMAP,
    pub write_set: *mut MY_BITMAP,
    pub rpl_write_set: *mut MY_BITMAP,
    pub has_value_set: MY_BITMAP,
    pub query_id: query_id_t,
    pub collected_stats: *mut Table_statistics,
    pub used_stat_records: ha_rows,
    pub opt_range_keys: key_map,
    pub opt_range: *mut TABLE_OPT_RANGE,
    pub const_key_parts: *mut key_part_map,
    pub opt_range_condition_rows: ha_rows,
    pub cond_selectivity: f64,
    pub cond_selectivity_sampling_explain: *mut List,
    pub map: table_map,
    pub lock_position: uint,
    pub lock_data_start: uint,
    pub lock_count: uint,
    pub tablenr: uint,
    pub used_fields: uint,
    pub temp_pool_slot: uint,
    pub status: uint,
    pub db_stat: uint,
    pub derived_select_number: uint,
    pub maybe_null: uint,
    pub current_lock: c_int,
    pub copy_blobs: bool,
    pub next_number_field_updated: bool,
    pub null_row: bool,
    pub no_rows_with_nulls: bool,
    pub null_catch_flags: uint8,
    pub force_index: bool,
    pub force_index_join: bool,
    pub force_index_order: bool,
    pub force_index_group: bool,
    pub distinct: bool,
    pub const_table: bool,
    pub no_rows: bool,
    pub used_for_duplicate_elimination: bool,
    pub keep_row_order: bool,
    pub no_keyread: bool,
    pub locked_by_logger: bool,
    pub locked_by_name: bool,
    pub fulltext_searched: bool,
    pub no_cache: bool,
    pub open_by_handler: bool,
    pub auto_increment_field_not_null: bool,
    pub insert_or_update: bool,
    pub alias_name_used: bool,
    pub get_fields_in_item_tree: bool,
    pub vcol_refix_list: List,
    pub m_needs_reopen: bool,
    pub created: bool,
    pub master_had_triggers: bool,
    pub reginfo: REGINFO,
    pub mem_root: MEM_ROOT,
    pub blob_storage: *mut Blob_mem_storage,
    pub grant: GRANT_INFO,
    pub expr_arena: *mut Query_arena,
    pub part_info: *mut partition_info,
    pub all_partitions_pruned_away: bool,
    pub max_keys: uint,
    pub stats_is_read: bool,
    pub histograms_are_read: bool,
    pub mdl_ticket: *mut MDL_ticket,
    pub spl_opt_info: *mut SplM_opt_info,
    pub keys_usable_for_splitting: key_map,
    pub notnull_cond: *mut Item,
    pub stats_cb: *mut TABLE_STATISTICS_CB,
    pub online_alter_cache: *mut online_alter_cache_data,
    pub with_impossible_ranges: key_map,
    pub range_rowid_filter_cost_info_elems: uint,
    pub range_rowid_filter_cost_info: *mut Range_rowid_filter_cost_info,
    pub range_rowid_filter_cost_info_ptr: *mut *mut Range_rowid_filter_cost_info,
    pub vers_write: bool,
}

Fields

s: *mut TABLE_SHARE

file: *mut handler

next: *mut TABLE

prev: *mut TABLE

share_all_next: *mut TABLE

Links for the list of all TABLE objects for this share. Declared as private to avoid direct manipulation with those objects. One should use methods of I_P_List template instead.

share_all_prev: *mut *mut TABLE

Links for the list of all TABLE objects for this share. Declared as private to avoid direct manipulation with those objects. One should use methods of I_P_List template instead.

global_free_next: *mut TABLE

global_free_prev: *mut *mut TABLE

instance: uint32

in_use: *mut THD

Table cache instance this TABLE is belonging to

record: [*mut uchar; 3]

write_row_record: *mut uchar

insert_values: *mut uchar

covering_keys: key_map

intersect_keys: key_map

keys_in_use_for_query: key_map

keys_in_use_for_group_by: key_map

keys_in_use_for_order_by: key_map

constraint_dependent_keys: key_map

key_info: *mut KEY

field: *mut *mut Field

vfield: *mut *mut Field

default_field: *mut *mut Field

next_number_field: *mut Field

found_next_number_field: *mut Field

check_constraints: *mut *mut Virtual_column_info

triggers: *mut Table_triggers_list

pos_in_table_list: *mut TABLE_LIST

pos_in_locked_tables: *mut TABLE_LIST

internal_tables: *mut TABLE_LIST

group: *mut ORDER

alias: String

null_flags: *mut uchar

def_read_set: MY_BITMAP

def_write_set: MY_BITMAP

tmp_set: MY_BITMAP

def_rpl_write_set: MY_BITMAP

eq_join_set: MY_BITMAP

cond_set: MY_BITMAP

read_set: *mut MY_BITMAP

write_set: *mut MY_BITMAP

rpl_write_set: *mut MY_BITMAP

has_value_set: MY_BITMAP

query_id: query_id_t

collected_stats: *mut Table_statistics

used_stat_records: ha_rows

opt_range_keys: key_map

opt_range: *mut TABLE_OPT_RANGE

const_key_parts: *mut key_part_map

opt_range_condition_rows: ha_rows

cond_selectivity: f64

cond_selectivity_sampling_explain: *mut List

map: table_map

lock_position: uint

lock_data_start: uint

lock_count: uint

tablenr: uint

used_fields: uint

temp_pool_slot: uint

status: uint

db_stat: uint

derived_select_number: uint

maybe_null: uint

current_lock: c_int

copy_blobs: bool

next_number_field_updated: bool

null_row: bool

no_rows_with_nulls: bool

null_catch_flags: uint8

force_index: bool

force_index_join: bool

force_index_order: bool

Flag set when the statement contains FORCE INDEX FOR ORDER BY See TABLE_LIST::process_index_hints().

force_index_group: bool

Flag set when the statement contains FORCE INDEX FOR GROUP BY See TABLE_LIST::process_index_hints().

distinct: bool

const_table: bool

no_rows: bool

used_for_duplicate_elimination: bool

keep_row_order: bool

Forces DYNAMIC Aria row format for internal temporary tables.

no_keyread: bool

locked_by_logger: bool

If set, indicate that the table is not replicated by the server.

locked_by_name: bool

fulltext_searched: bool

no_cache: bool

open_by_handler: bool

auto_increment_field_not_null: bool

insert_or_update: bool

alias_name_used: bool

get_fields_in_item_tree: bool

vcol_refix_list: List

m_needs_reopen: bool

created: bool

master_had_triggers: bool

reginfo: REGINFO

mem_root: MEM_ROOT

blob_storage: *mut Blob_mem_storage

Initialized in Item_func_group_concat::setup for appropriate temporary table if GROUP_CONCAT is used with ORDER BY | DISTINCT and BLOB field count > 0.

grant: GRANT_INFO

expr_arena: *mut Query_arena

part_info: *mut partition_info

all_partitions_pruned_away: bool

max_keys: uint

stats_is_read: bool

histograms_are_read: bool

mdl_ticket: *mut MDL_ticket

spl_opt_info: *mut SplM_opt_info

keys_usable_for_splitting: key_map

notnull_cond: *mut Item

stats_cb: *mut TABLE_STATISTICS_CB

online_alter_cache: *mut online_alter_cache_data

with_impossible_ranges: key_map

range_rowid_filter_cost_info_elems: uint

range_rowid_filter_cost_info: *mut Range_rowid_filter_cost_info

range_rowid_filter_cost_info_ptr: *mut *mut Range_rowid_filter_cost_info

vers_write: bool

System Versioning support

Implementations

impl TABLE

pub unsafe fn init(&mut self, thd: *mut THD, tl: *mut TABLE_LIST)

pub unsafe fn fill_item_list(&self, item_list: *mut List) -> bool

pub unsafe fn reset_item_list(&self, item_list: *mut List, skip: uint)

pub unsafe fn clear_column_bitmaps(&mut self)

pub unsafe fn prepare_for_position(&mut self)

pub unsafe fn prepare_for_keyread( &mut self, index: uint, map: *mut MY_BITMAP ) -> *mut MY_BITMAP

pub unsafe fn mark_index_columns(&mut self, index: uint, bitmap: *mut MY_BITMAP)

pub unsafe fn mark_index_columns_no_reset( &mut self, index: uint, bitmap: *mut MY_BITMAP )

pub unsafe fn mark_index_columns_for_read(&mut self, index: uint)

pub unsafe fn restore_column_maps_after_keyread( &mut self, backup: *mut MY_BITMAP )

pub unsafe fn mark_auto_increment_column(&mut self, insert_fl: bool)

pub unsafe fn mark_columns_needed_for_update(&mut self)

pub unsafe fn mark_columns_needed_for_delete(&mut self)

pub unsafe fn mark_columns_needed_for_insert(&mut self)

pub unsafe fn mark_columns_per_binlog_row_image(&mut self)

pub unsafe fn mark_virtual_columns_for_write(&mut self, insert_fl: bool) -> bool

pub unsafe fn check_virtual_columns_marked_for_read(&mut self) -> bool

pub unsafe fn check_virtual_columns_marked_for_write(&mut self) -> bool

pub unsafe fn mark_default_fields_for_write(&mut self, insert_fl: bool)

pub unsafe fn mark_columns_used_by_virtual_fields(&mut self)

pub unsafe fn mark_check_constraint_columns_for_read(&mut self)

pub unsafe fn verify_constraints(&mut self, ignore_failure: bool) -> c_int

pub unsafe fn free_engine_stats(&mut self)

pub unsafe fn update_engine_independent_stats(&mut self)

pub unsafe fn mark_table_for_reopen(&mut self)

pub unsafe fn init_expr_arena(&mut self, mem_root: *mut MEM_ROOT) -> bool

pub unsafe fn alloc_keys(&mut self, key_count: uint) -> bool

pub unsafe fn check_tmp_key( &mut self, key: uint, key_parts: uint, next_field_no: Option<unsafe extern "C" fn(arg1: *mut uchar) -> uint>, arg: *mut uchar ) -> bool

pub unsafe fn add_tmp_key( &mut self, key: uint, key_parts: uint, next_field_no: Option<unsafe extern "C" fn(arg1: *mut uchar) -> uint>, arg: *mut uchar, unique: bool ) -> bool

pub unsafe fn create_key_part_by_field( &mut self, key_part_info: *mut KEY_PART_INFO, field: *mut Field, fieldnr: uint )

pub unsafe fn use_index( &mut self, key_to_save: c_int, map_to_update: *mut key_map )

pub unsafe fn is_filled_at_execution(&mut self) -> bool

pub unsafe fn update_const_key_parts(&mut self, conds: *mut COND) -> bool

pub unsafe fn move_fields( &mut self, ptr: *mut *mut Field, to: *const uchar, from: *const uchar )

pub unsafe fn remember_blob_values(&mut self, blob_storage: *mut String)

pub unsafe fn restore_blob_values(&mut self, blob_storage: *mut String)

pub unsafe fn actual_n_key_parts(&mut self, keyinfo: *mut KEY) -> uint

pub unsafe fn actual_key_flags(&mut self, keyinfo: *mut KEY) -> ulong

pub unsafe fn update_virtual_field( &mut self, vf: *mut Field, ignore_warnings: bool ) -> c_int

pub unsafe fn update_virtual_fields( &mut self, h: *mut handler, update_mode: Type ) -> c_int

pub unsafe fn update_default_fields(&mut self, ignore_errors: bool) -> c_int

pub unsafe fn evaluate_update_default_function(&mut self)

pub unsafe fn reset_default_fields(&mut self)

pub unsafe fn prepare_triggers_for_insert_stmt_or_event(&mut self)

pub unsafe fn prepare_triggers_for_delete_stmt_or_event(&mut self) -> bool

pub unsafe fn prepare_triggers_for_update_stmt_or_event(&mut self) -> bool

pub unsafe fn field_to_fill(&mut self) -> *mut *mut Field

pub unsafe fn validate_default_values_of_unset_fields( &self, thd: *mut THD ) -> bool

pub unsafe fn check_assignability_explicit_fields( fields: List, values: List, ignore: bool ) -> bool

pub unsafe fn check_assignability_all_visible_fields( &self, values: *mut List, ignore: bool ) -> bool

pub unsafe fn insert_all_rows_into_tmp_table( &mut self, thd: *mut THD, tmp_table: *mut TABLE, tmp_table_param: *mut TMP_TABLE_PARAM, with_cleanup: bool ) -> bool

pub unsafe fn vcol_fix_expr(&mut self, thd: *mut THD) -> bool

pub unsafe fn vcol_cleanup_expr(&mut self, thd: *mut THD) -> bool

pub unsafe fn find_field_by_name(&self, str_: *const LEX_CSTRING) -> *mut Field

pub unsafe fn export_structure( &mut self, thd: *mut THD, defs: *mut Row_definition_list ) -> bool

pub unsafe fn set_spl_opt_info(&mut self, spl_info: *mut SplM_opt_info)

pub unsafe fn deny_splitting(&mut self)

pub unsafe fn get_materialization_cost(&mut self) -> f64

pub unsafe fn add_splitting_info_for_key_field( &mut self, key_field: *mut KEY_FIELD )

pub unsafe fn init_cost_info_for_usable_range_rowid_filters( &mut self, thd: *mut THD )

pub unsafe fn prune_range_rowid_filters(&mut self)

pub unsafe fn trace_range_rowid_filters(&self, thd: *mut THD)

pub unsafe fn best_range_rowid_filter( &mut self, access_key_no: uint, records: f64, fetch_cost: f64, index_only_cost: f64, prev_records: f64, records_out: *mut f64 ) -> *mut Range_rowid_filter_cost_info

pub unsafe fn vers_start_id(&self) -> ulonglong

pub unsafe fn vers_end_id(&self) -> ulonglong

pub unsafe fn vers_switch_partition( &mut self, thd: *mut THD, table_list: *mut TABLE_LIST, ot_ctx: *mut Open_table_context ) -> bool

pub unsafe fn update_generated_fields(&mut self) -> c_int

pub unsafe fn period_make_insert( &mut self, src: *mut Item, dst: *mut Field ) -> c_int

pub unsafe fn insert_portion_of_time( &mut self, thd: *mut THD, period_conds: *const vers_select_conds_t, rows_inserted: *mut ha_rows ) -> c_int

pub unsafe fn vers_check_update(&mut self, items: *mut List) -> bool

pub unsafe fn check_period_overlaps( key: *const KEY, lhs: *const uchar, rhs: *const uchar ) -> bool

pub unsafe fn delete_row(&mut self) -> c_int

pub unsafe fn vers_update_fields(&mut self) -> bool

pub unsafe fn vers_update_end(&mut self)

pub unsafe fn find_constraint_correlated_indexes(&mut self)

Trait Implementations

impl Debug for TABLE

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.