File show_meta.c¶
File List > cubrid > src > parser > show_meta.c
Go to the documentation of this file
/*
* Copyright 2008 Search Solution Corporation
* Copyright 2016 CUBRID Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/*
* show_meta.c - show statement infos, including column defination, semantic check.
*/
#ident "$Id$"
#include "config.h"
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <ctype.h>
#include "authenticate.h"
#include "show_meta.h"
#include "error_manager.h"
#include "parser.h"
#include "schema_manager.h"
#include "dbtype.h"
#include "error_code.h"
#include "db.h"
enum
{
ARG_REQUIRED = false, /* argument is required */
ARG_OPTIONAL = true /* argument is optional */
};
enum
{
ORDER_DESC = false, /* order by descending */
ORDER_ASC = true /* order by ascending */
};
typedef enum
{
SHOW_ONLY,
SHOW_ALL
} SHOW_ONLY_ALL;
static bool show_Inited = false;
static SHOWSTMT_METADATA *show_Metas[SHOWSTMT_END];
static int init_db_attribute_list (SHOWSTMT_METADATA * md);
static void free_db_attribute_list (SHOWSTMT_METADATA * md);
/* check functions */
static PT_NODE *pt_check_access_status (PARSER_CONTEXT * parser, PT_NODE * node);
static PT_NODE *pt_check_table_in_show_heap (PARSER_CONTEXT * parser, PT_NODE * node);
static PT_NODE *pt_check_show_index (PARSER_CONTEXT * parser, PT_NODE * node);
/* meta functions */
static SHOWSTMT_METADATA *metadata_of_volume_header (void);
static SHOWSTMT_METADATA *metadata_of_access_status (void);
static SHOWSTMT_METADATA *metadata_of_active_log_header (void);
static SHOWSTMT_METADATA *metadata_of_archive_log_header (void);
static SHOWSTMT_METADATA *metadata_of_slotted_page_header (void);
static SHOWSTMT_METADATA *metadata_of_slotted_page_slots (void);
static SHOWSTMT_METADATA *metadata_of_heap_header (SHOW_ONLY_ALL flag);
static SHOWSTMT_METADATA *metadata_of_heap_capacity (SHOW_ONLY_ALL flag);
static SHOWSTMT_METADATA *metadata_of_index_header (SHOW_ONLY_ALL flag);
static SHOWSTMT_METADATA *metadata_of_index_capacity (SHOW_ONLY_ALL flag);
static SHOWSTMT_METADATA *metadata_of_global_critical_sections (void);
static SHOWSTMT_METADATA *metadata_of_job_queues (void);
static SHOWSTMT_METADATA *metadata_of_timezones (void);
static SHOWSTMT_METADATA *metadata_of_full_timezones (void);
static SHOWSTMT_METADATA *metadata_of_tran_tables (void);
static SHOWSTMT_METADATA *metadata_of_threads (void);
static SHOWSTMT_METADATA *metadata_of_page_buffer_status (void);
static SHOWSTMT_METADATA *
metadata_of_volume_header (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Volume_id", "int"},
{"Magic_symbol", "varchar(100)"},
{"Io_page_size", "short"},
{"Purpose", "varchar(24)"},
{"Type", "varchar(24)"},
{"Sector_size_in_pages", "int"},
{"Num_total_sectors", "int"},
{"Num_free_sectors", "int"},
{"Num_max_sectors", "int"},
{"Hint_alloc_sector", "int"},
{"Sector_alloc_table_size_in_pages", "int"},
{"Sector_alloc_table_first_page", "int"},
{"Last_system_page", "int"},
{"Creation_time", "datetime"},
{"Db_charset", "int"},
{"Checkpoint_lsa", "varchar(64)"},
{"Boot_hfid", "varchar(64)"},
{"Full_name", "varchar(255)"},
{"Next_volume_id", "int"},
{"Next_vol_full_name", "varchar(255)"},
{"Remarks", "varchar(64)"}
};
static const SHOWSTMT_NAMED_ARG args[] = {
{NULL, AVT_INTEGER, ARG_REQUIRED}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_VOLUME_HEADER, true /* only_for_dba */ , "show volume header of ",
cols, DIM (cols), NULL, 0, args, DIM (args), NULL, NULL
};
return &md;
}
static SHOWSTMT_METADATA *
metadata_of_active_log_header (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Volume_id", "int"},
{"Magic_symbol", "varchar(32)"},
{"Magic_symbol_location", "int"},
{"Creation_time", "datetime"},
{"Release", "varchar(32)"},
{"Compatibility_disk_version", "varchar(32)"},
{"Db_page_size", "int"},
{"Log_page_size", "int"},
{"Shutdown", "int"},
{"Next_trans_id", "int"},
{"Num_avg_trans", "int"},
{"Num_avg_locks", "int"},
{"Num_active_log_pages", "int"},
{"Db_charset", "int"},
{"First_active_log_page", "bigint"},
{"Current_append", "varchar(64)"},
{"Checkpoint", "varchar(64)"},
{"Next_archive_page_id", "bigint"},
{"Active_physical_page_id", "int"},
{"Next_archive_num", "int"},
{"Last_archive_num_for_syscrashes", "int"},
{"Last_deleted_archive_num", "int"},
{"Backup_lsa_level0", "varchar(64)"},
{"Backup_lsa_level1", "varchar(64)"},
{"Backup_lsa_level2", "varchar(64)"},
{"Log_prefix", "varchar(256)"},
{"Has_logging_been_skipped", "int"},
{"Perm_status", "varchar(64)"},
{"Backup_info_level0", "varchar(128)"},
{"Backup_info_level1", "varchar(128)"},
{"Backup_info_level2", "varchar(128)"},
{"Ha_server_state", "varchar(32)"},
{"Ha_file", "varchar(32)"},
{"Eof_lsa", "varchar(64)"},
{"Smallest_lsa_at_last_checkpoint", "varchar(64)"},
{"Next_mvcc_id", "bigint"},
{"Mvcc_op_log_lsa", "varchar(32)"},
{"Last_block_oldest_mvcc_id", "bigint"},
{"Last_block_newest_mvcc_id", "bigint"}
};
static const SHOWSTMT_NAMED_ARG args[] = {
{NULL, AVT_STRING, ARG_OPTIONAL}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_ACTIVE_LOG_HEADER, true /* only_for_dba */ , "show log header of ",
cols, DIM (cols), NULL, 0, args, DIM (args), NULL, NULL
};
return &md;
}
static SHOWSTMT_METADATA *
metadata_of_archive_log_header (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Volume_id", "int"},
{"Magic_symbol", "varchar(32)"},
{"Magic_symbol_location", "int"},
{"Creation_time", "datetime"},
{"Next_trans_id", "bigint"},
{"Num_pages", "int"},
{"First_page_id", "bigint"},
{"Archive_num", "int"}
};
static const SHOWSTMT_NAMED_ARG args[] = {
{NULL, AVT_STRING, ARG_OPTIONAL}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_ARCHIVE_LOG_HEADER, true /* only_for_dba */ , "show archive log header of ",
cols, DIM (cols), NULL, 0, args, DIM (args), NULL, NULL
};
return &md;
}
static SHOWSTMT_METADATA *
metadata_of_slotted_page_header (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Volume_id", "int"},
{"Page_id", "int"},
{"Num_slots", "int"},
{"Num_records", "int"},
{"Anchor_type", "varchar(32)"},
{"Alignment", "varchar(8)"},
{"Total_free_area", "int"},
{"Contiguous_free_area", "int"},
{"Free_space_offset", "int"},
{"Need_update_best_hint", "int"},
{"Is_saving", "int"},
{"Flags", "int"}
};
static const SHOWSTMT_NAMED_ARG args[] = {
{"volume", AVT_INTEGER, ARG_REQUIRED},
{"page", AVT_INTEGER, ARG_REQUIRED}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_SLOTTED_PAGE_HEADER, true /* only_for_dba */ , "show slotted page header of ",
cols, DIM (cols), NULL, 0, args, DIM (args), NULL, NULL
};
return &md;
}
static SHOWSTMT_METADATA *
metadata_of_slotted_page_slots (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Volume_id", "int"},
{"Page_id", "int"},
{"Slot_id", "int"},
{"Offset", "int"},
{"Type", "varchar(32)"},
{"Length", "int"},
{"Waste", "int"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{3, ORDER_ASC}
};
static const SHOWSTMT_NAMED_ARG args[] = {
{"volume", AVT_INTEGER, ARG_REQUIRED},
{"page", AVT_INTEGER, ARG_REQUIRED}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_SLOTTED_PAGE_SLOTS, true /* only_for_dba */ , "show slotted page slots of ",
cols, DIM (cols), orderby, DIM (orderby), args, DIM (args), NULL, NULL
};
return &md;
}
static SHOWSTMT_METADATA *
metadata_of_access_status (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"user_name", "varchar(32)"},
{"last_access_time", "datetime"},
{"last_access_host", "varchar(32)"},
{"program_name", "varchar(32)"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_ACCESS_STATUS, true /* only_for_dba */ , "show access status",
cols, DIM (cols), orderby, DIM (orderby), NULL, 0, pt_check_access_status, NULL
};
return &md;
}
static SHOWSTMT_METADATA *
metadata_of_heap_header (SHOW_ONLY_ALL flag)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Table_name", "varchar(256)"},
{"Class_oid", "varchar(64)"},
{"Volume_id", "int"},
{"File_id", "int"},
{"Header_page_id", "int"},
{"Overflow_vfid", "varchar(64)"},
{"Next_vpid", "varchar(64)"},
{"Unfill_space", "int"},
{"Estimates_num_pages", "bigint"},
{"Estimates_num_recs", "bigint"},
{"Estimates_avg_rec_len", "int"},
{"Estimates_num_high_best", "int"},
{"Estimates_num_others_high_best", "int"},
{"Estimates_head", "int"},
{"Estimates_best_list", "varchar(512)"},
{"Estimates_num_second_best", "int"},
{"Estimates_head_second_best", "int"},
{"Estimates_tail_second_best", "int"},
{"Estimates_num_substitutions", "int"},
{"Estimates_second_best_list", "varchar(256)"},
{"Estimates_last_vpid", "varchar(64)"},
{"Estimates_full_search_vpid", "varchar(64)"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC}
};
static const SHOWSTMT_NAMED_ARG args[] = {
{NULL, AVT_IDENTIFIER, ARG_REQUIRED}
};
static SHOWSTMT_METADATA md_only = {
SHOWSTMT_HEAP_HEADER, true /* only_for_dba */ , "show heap header of ",
cols, DIM (cols), NULL, 0, args, DIM (args), pt_check_table_in_show_heap, NULL
};
static SHOWSTMT_METADATA md_all = {
SHOWSTMT_ALL_HEAP_HEADER, true /* only_for_dba */ , "show all heap header of ",
cols, DIM (cols), orderby, DIM (orderby), args, DIM (args), pt_check_table_in_show_heap, NULL
};
return (flag == SHOW_ALL) ? &md_all : &md_only;
}
static SHOWSTMT_METADATA *
metadata_of_heap_capacity (SHOW_ONLY_ALL flag)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Table_name", "varchar(256)"},
{"Class_oid", "varchar(64)"},
{"Volume_id", "int"},
{"File_id", "int"},
{"Header_page_id", "int"},
{"Num_recs", "bigint"},
{"Num_relocated_recs", "bigint"},
{"Num_overflowed_recs", "bigint"},
{"Num_pages", "bigint"},
{"Avg_rec_len", "int"},
{"Avg_free_space_per_page", "int"},
{"Avg_free_space_per_page_except_last_page", "int"},
{"Avg_overhead_per_page", "int"},
{"Repr_id", "int"},
{"Num_total_attrs", "int"},
{"Num_fixed_width_attrs", "int"},
{"Num_variable_width_attrs", "int"},
{"Num_shared_attrs", "int"},
{"Num_class_attrs", "int"},
{"Total_size_fixed_width_attrs", "int"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC}
};
static const SHOWSTMT_NAMED_ARG args[] = {
{NULL, AVT_IDENTIFIER, ARG_REQUIRED}
};
static SHOWSTMT_METADATA md_only = {
SHOWSTMT_HEAP_CAPACITY, true /* only_for_dba */ , "show heap capacity of ",
cols, DIM (cols), orderby, DIM (orderby), args, DIM (args), pt_check_table_in_show_heap, NULL
};
static SHOWSTMT_METADATA md_all = {
SHOWSTMT_ALL_HEAP_CAPACITY, true /* only_for_dba */ , "show all heap capacity of ",
cols, DIM (cols), orderby, DIM (orderby), args, DIM (args), pt_check_table_in_show_heap, NULL
};
return (flag == SHOW_ALL) ? &md_all : &md_only;
}
/* for show index header */
static SHOWSTMT_METADATA *
metadata_of_index_header (SHOW_ONLY_ALL flag)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Table_name", "varchar(256)"},
{"Index_name", "varchar(256)"},
{"Btid", "varchar(64)"},
{"Node_level", "int"},
{"Max_key_len", "int"},
{"Num_oids", "bigint"},
{"Num_nulls", "bigint"},
{"Num_keys", "bigint"},
{"Topclass_oid", "varchar(64)"},
{"Unique", "int"},
{"Overflow_vfid", "varchar(32)"},
{"Key_type", "varchar(256)"},
{"Columns", "varchar(256)"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC},
{2, ORDER_ASC}
};
static const SHOWSTMT_NAMED_ARG args1[] = {
{NULL, AVT_IDENTIFIER, ARG_REQUIRED}
};
static const SHOWSTMT_NAMED_ARG args2[] = {
{NULL, AVT_IDENTIFIER, ARG_REQUIRED},
{NULL, AVT_IDENTIFIER, ARG_REQUIRED}
};
static SHOWSTMT_METADATA md_all = {
SHOWSTMT_ALL_INDEXES_HEADER, true /* only_for_dba */ , "show all indexes header of ",
cols, DIM (cols), orderby, DIM (orderby), args1, DIM (args1), pt_check_show_index, NULL
};
static SHOWSTMT_METADATA md_only = {
SHOWSTMT_INDEX_HEADER, true /* only_for_dba */ , "show index header of ",
cols, DIM (cols), NULL, 0, args2, DIM (args2), pt_check_show_index, NULL
};
return (flag == SHOW_ALL) ? &md_all : &md_only;
}
/* for show index capacity */
static SHOWSTMT_METADATA *
metadata_of_index_capacity (SHOW_ONLY_ALL flag)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Table_name", "varchar(256)"},
{"Index_name", "varchar(256)"},
{"Btid", "varchar(64)"},
{"Num_distinct_key", "int"},
{"Total_value", "bigint"},
{"Deduplicate_distinct_key", "int"}, /* support for SUPPORT_DEDUPLICATE_KEY_MODE */
{"Num_fence_key", "int"},
{"Avg_num_value_per_key", "int"},
{"Avg_num_value_per_deduplicate_key", "int"}, /* support for SUPPORT_DEDUPLICATE_KEY_MODE */
{"Num_leaf_page", "int"},
{"Num_non_leaf_page", "int"},
{"Num_ovf_page", "int"},
{"Num_total_page", "int"},
{"Height", "int"},
{"Avg_key_len", "int"},
{"Avg_rec_len", "int"},
{"Total_space", "varchar(64)"},
{"Total_used_space_non_ovf", "varchar(64)"},
{"Total_free_space_non_ovf", "varchar(64)"},
{"Total_used_space_ovf", "varchar(64)"},
{"Total_free_space_ovf", "varchar(64)"},
{"Avg_num_key_per_page_non_ovf", "int"},
{"Avg_free_space_per_page_non_ovf", "varchar(64)"},
{"Avg_num_ovf_page_per_key", "int"},
{"Avg_free_space_per_page_ovf", "varchar(64)"},
{"Max_num_ovf_page_a_key", "int"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC},
{2, ORDER_ASC}
};
static const SHOWSTMT_NAMED_ARG args1[] = {
{NULL, AVT_IDENTIFIER, ARG_REQUIRED}
};
static const SHOWSTMT_NAMED_ARG args2[] = {
{NULL, AVT_IDENTIFIER, ARG_REQUIRED},
{NULL, AVT_IDENTIFIER, ARG_REQUIRED}
};
static SHOWSTMT_METADATA md_all = {
SHOWSTMT_ALL_INDEXES_CAPACITY, true /* only_for_dba */ , "show all indexes capacity of ",
cols, DIM (cols), orderby, DIM (orderby), args1, DIM (args1), pt_check_show_index, NULL
};
static SHOWSTMT_METADATA md_only = {
SHOWSTMT_INDEX_CAPACITY, true /* only_for_dba */ , "show index capacity of ",
cols, DIM (cols), NULL, 0, args2, DIM (args2), pt_check_show_index, NULL
};
return (flag == SHOW_ALL) ? &md_all : &md_only;
}
/* for show critical sections */
static SHOWSTMT_METADATA *
metadata_of_global_critical_sections (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Index", "int"},
{"Name", "varchar(32)"},
{"Num_holders", "varchar(16)"},
{"Num_waiting_readers", "int"},
{"Num_waiting_writers", "int"},
{"Owner_thread_index", "int"},
{"Owner_tran_index", "int"},
{"Total_enter_count", "bigint"},
{"Total_waiter_count", "bigint"},
{"Waiting_promoter_thread_index", "int"},
{"Max_waiting_msecs", "numeric(10,3)"},
{"Total_waiting_msecs", "numeric(10,3)"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_GLOBAL_CRITICAL_SECTIONS, true /* only_for_dba */ , "show critical sections",
cols, DIM (cols), orderby, DIM (orderby), NULL, 0, NULL, NULL
};
return &md;
}
static SHOWSTMT_METADATA *
metadata_of_job_queues (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Jobq_index", "int"},
{"Num_total_workers", "int"},
{"Num_busy_workers", "int"},
{"Num_connection_workers", "int"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_JOB_QUEUES, true /* only_for_dba */ , "show job queue",
cols, DIM (cols), orderby, DIM (orderby), NULL, 0, NULL, NULL
};
return &md;
}
/* for show timezones */
static SHOWSTMT_METADATA *
metadata_of_timezones (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"timezone_region", "varchar(32)"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_TIMEZONES, false /* only_for_dba */ , "show timezones",
cols, DIM (cols), orderby, DIM (orderby), NULL, 0, NULL, NULL
};
return &md;
}
/* for show full timezones */
static SHOWSTMT_METADATA *
metadata_of_full_timezones (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"timezone_region", "varchar(32)"},
{"region_offset", "varchar(32)"},
{"dst_offset", "varchar(32)"},
{"dst_abbreviation", "varchar(32)"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_FULL_TIMEZONES, false /* only_for_dba */ , "show full timezones",
cols, DIM (cols), orderby, DIM (orderby), NULL, 0, NULL, NULL
};
return &md;
}
/* for show transaction descriptors */
static SHOWSTMT_METADATA *
metadata_of_tran_tables (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Tran_index", "int"},
{"Tran_id", "int"},
{"Is_loose_end", "int"},
{"State", "varchar(64)"},
{"Isolation", "varchar(64)"},
{"Wait_msecs", "int"},
{"Head_lsa", "varchar(64)"},
{"Tail_lsa", "varchar(64)"},
{"Undo_next_lsa", "varchar(64)"},
{"Postpone_next_lsa", "varchar(64)"},
{"Savepoint_lsa", "varchar(64)"},
{"Topop_lsa", "varchar(64)"},
{"Tail_top_result_lsa", "varchar(64)"},
{"Client_id", "int"},
{"Client_type", "varchar(40)"},
{"Client_info", "varchar(256)"},
{"Client_db_user", "varchar(40)"},
{"Client_program", "varchar(256)"},
{"Client_login_user", "varchar(16)"},
{"Client_host", "varchar(64)"},
{"Client_pid", "int"},
{"Topop_depth", "int"},
{"Num_unique_btrees", "int"},
{"Max_unique_btrees", "int"},
{"Interrupt", "int"},
{"Num_transient_classnames", "int"},
{"Repl_max_records", "int"},
{"Repl_records", "varchar(20)"},
{"Repl_current_index", "int"},
{"Repl_append_index", "int"},
{"Repl_flush_marked_index", "int"},
{"Repl_insert_lsa", "varchar(64)"},
{"Repl_update_lsa", "varchar(64)"},
{"First_save_entry", "varchar(20)"},
{"Tran_unique_stats", "varchar(20)"},
{"Modified_class_list", "varchar(20)"},
{"Num_temp_files", "int"},
{"Waiting_for_res", "varchar(20)"},
{"Has_deadlock_priority", "int"},
{"Suppress_replication", "int"},
{"Query_timeout", "datetime"},
{"Query_start_time", "datetime"},
{"Tran_start_time", "datetime"},
{"Xasl_id", "varchar(64)"},
{"Disable_modifications", "int"},
{"Abort_reason", "varchar(40)"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_TRAN_TABLES, true /* only_for_dba */ , "show transaction tables",
cols, DIM (cols), orderby, DIM (orderby), NULL, 0, NULL, NULL
};
return &md;
}
static SHOWSTMT_METADATA *
metadata_of_threads (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Index", "int"},
{"Jobq_index", "int"},
{"Thread_id", "bigint"},
{"Tran_index", "int"},
{"Type", "varchar(8)"},
{"Status", "varchar(8)"},
{"Resume_status", "varchar(32)"},
{"Net_request", "varchar(64)"},
{"Conn_client_id", "int"},
{"Conn_request_id", "int"},
{"Conn_index", "int"},
{"Last_error_code", "int"},
{"Last_error_msg", "varchar(256)"},
{"Private_heap_id", "varchar(20)"},
{"Query_entry", "varchar(20)"},
{"Interrupted", "int"},
{"Shutdown", "int"},
{"Check_interrupt", "int"},
{"Wait_for_latch_promote", "int"},
{"Lockwait_blocked_mode", "varchar(24)"},
{"Lockwait_start_time", "datetime"},
{"Lockwait_msecs", "int"},
{"Lockwait_state", "varchar(24)"},
{"Next_wait_thread_index", "int"},
{"Next_tran_wait_thread_index", "int"},
{"Next_worker_thread_index", "int"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_THREADS, true /* only_for_dba */ , "show threads",
cols, DIM (cols), orderby, DIM (orderby), NULL, 0, NULL, NULL
};
return &md;
}
static SHOWSTMT_METADATA *
metadata_of_page_buffer_status (void)
{
static const SHOWSTMT_COLUMN cols[] = {
{"Hit_rate", "numeric(13,10)"},
{"Num_hit", "bigint"},
{"Num_page_request", "bigint"},
{"Pool_size", "int"},
{"Page_size", "int"},
{"Free_pages", "int"},
{"Victim_candidate_pages", "int"},
{"Clean_pages", "int"},
{"Dirty_pages", "int"},
{"Num_index_pages", "int"},
{"Num_data_pages", "int"},
{"Num_system_pages", "int"},
{"Num_temp_pages", "int"},
{"Num_pages_created", "bigint"},
{"Num_pages_written", "bigint"},
{"Pages_written_rate", "numeric(20,10)"},
{"Num_pages_read", "bigint"},
{"Pages_read_rate", "numeric(20,10)"},
{"Num_flusher_waiting_threads", "int"}
};
static const SHOWSTMT_COLUMN_ORDERBY orderby[] = {
{1, ORDER_ASC}
};
static SHOWSTMT_METADATA md = {
SHOWSTMT_PAGE_BUFFER_STATUS, true /* only_for_dba */ , "show page buffer status",
cols, DIM (cols), orderby, DIM (orderby), NULL, 0, NULL, NULL
};
return &md;
}
/*
* showstmt_get_metadata() - return show statement column infos
* return:-
* show_type(in): SHOW statement type
*/
const SHOWSTMT_METADATA *
showstmt_get_metadata (SHOWSTMT_TYPE show_type)
{
const SHOWSTMT_METADATA *show_meta = NULL;
assert_release (SHOWSTMT_START < show_type);
assert_release (show_type < SHOWSTMT_END);
show_meta = show_Metas[show_type];
assert_release (show_meta != NULL);
assert_release (show_meta->show_type == show_type);
return show_meta;
}
/*
* showstmt_get_attributes () - return all DB_ATTRIBUTE
* return:-
* show_type(in): SHOW statement type
*/
DB_ATTRIBUTE *
showstmt_get_attributes (SHOWSTMT_TYPE show_type)
{
const SHOWSTMT_METADATA *show_meta = NULL;
show_meta = showstmt_get_metadata (show_type);
return show_meta->showstmt_attrs;
}
/*
* pt_check_show_heap () - check table exists or not
* return: PT_NODE pointer
*
* parser(in):
* node(in):
*/
static PT_NODE *
pt_check_table_in_show_heap (PARSER_CONTEXT * parser, PT_NODE * node)
{
int error = NO_ERROR;
PT_NODE *show_args_node = NULL, *spec, *derived_table;
PT_NODE *partition_node = NULL;
SHOWSTMT_TYPE show_type;
int partition_type = DB_NOT_PARTITIONED_CLASS;
const char *table_name = NULL;
MOP cls;
SM_CLASS *sm_class = NULL;
int save;
if (node->node_type != PT_SELECT)
{
return node;
}
spec = node->info.query.q.select.from;
assert (spec != NULL);
derived_table = spec->info.spec.derived_table;
assert (derived_table != NULL);
show_type = derived_table->info.showstmt.show_type;
assert (show_type == SHOWSTMT_HEAP_HEADER || show_type == SHOWSTMT_ALL_HEAP_HEADER
|| show_type == SHOWSTMT_HEAP_CAPACITY || show_type == SHOWSTMT_ALL_HEAP_CAPACITY);
show_args_node = derived_table->info.showstmt.show_args;
assert (show_args_node != NULL);
assert (show_args_node->node_type == PT_VALUE);
assert (show_args_node->type_enum == PT_TYPE_CHAR);
table_name = (const char *) show_args_node->info.value.data_value.str->bytes;
cls = sm_find_class (table_name);
if (cls == NULL)
{
PT_ERRORmf (parser, show_args_node, MSGCAT_SET_ERROR, -(ER_LC_UNKNOWN_CLASSNAME), table_name);
return node;
}
AU_DISABLE (save);
error = au_fetch_class_force (cls, &sm_class, AU_FETCH_READ);
AU_ENABLE (save);
if (error == NO_ERROR)
{
if (sm_get_class_type (sm_class) != SM_CLASS_CT)
{
PT_ERRORm (parser, show_args_node, MSGCAT_SET_ERROR, -(ER_OBJ_NOT_A_CLASS));
return node;
}
}
error = sm_partitioned_class_type (cls, &partition_type, NULL, NULL);
if (error != NO_ERROR)
{
PT_ERRORc (parser, show_args_node, er_msg ());
return node;
}
partition_node = pt_make_integer_value (parser, partition_type);
if (partition_node == NULL)
{
PT_INTERNAL_ERROR (parser, "allocate new node");
return node;
}
parser_append_node (partition_node, show_args_node);
return node;
}
/*
* init_db_attribute_list () : init DB_ATTRIBUTE list for each show statement
* return: error code
* md(in/out):
*/
static int
init_db_attribute_list (SHOWSTMT_METADATA * md)
{
int i;
DB_DOMAIN *domain;
DB_ATTRIBUTE *attrs = NULL, *att;
if (md == NULL)
{
return NO_ERROR;
}
for (i = md->num_cols - 1; i >= 0; i--)
{
domain = pt_string_to_db_domain (md->cols[i].type, NULL);
if (domain == NULL)
{
goto on_error;
}
domain = tp_domain_cache (domain);
att = classobj_make_attribute (md->cols[i].name, domain->type, ID_ATTRIBUTE);
if (att == NULL)
{
goto on_error;
}
att->domain = domain;
att->auto_increment = NULL;
if (attrs == NULL)
{
attrs = att;
}
else
{
att->order_link = attrs;
attrs = att;
}
}
md->showstmt_attrs = attrs;
return NO_ERROR;
on_error:
while (attrs != NULL)
{
att = attrs;
attrs = (DB_ATTRIBUTE *) att->order_link;
att->order_link = NULL;
classobj_free_attribute (att);
}
assert (er_errid () != NO_ERROR);
return er_errid ();
}
/*
* free_db_attribute_list () : free DB_ATTRIBUTE list for each show statement
* return:
* md(in/out):
*/
static void
free_db_attribute_list (SHOWSTMT_METADATA * md)
{
DB_ATTRIBUTE *attrs = NULL, *att;
if (md == NULL)
{
return;
}
attrs = md->showstmt_attrs;
md->showstmt_attrs = NULL;
while (attrs != NULL)
{
att = attrs;
attrs = (DB_ATTRIBUTE *) att->order_link;
att->order_link = NULL;
classobj_free_attribute (att);
}
}
/*
* showstmt_metadata_init() -- initialize the metadata of show statements
* return error code>
*/
int
showstmt_metadata_init (void)
{
int error;
unsigned int i;
if (show_Inited)
{
return NO_ERROR;
}
memset (show_Metas, 0, sizeof (show_Metas));
show_Metas[SHOWSTMT_VOLUME_HEADER] = metadata_of_volume_header ();
show_Metas[SHOWSTMT_ACCESS_STATUS] = metadata_of_access_status ();
show_Metas[SHOWSTMT_ACTIVE_LOG_HEADER] = metadata_of_active_log_header ();
show_Metas[SHOWSTMT_ARCHIVE_LOG_HEADER] = metadata_of_archive_log_header ();
show_Metas[SHOWSTMT_SLOTTED_PAGE_HEADER] = metadata_of_slotted_page_header ();
show_Metas[SHOWSTMT_SLOTTED_PAGE_SLOTS] = metadata_of_slotted_page_slots ();
show_Metas[SHOWSTMT_HEAP_HEADER] = metadata_of_heap_header (SHOW_ONLY);
show_Metas[SHOWSTMT_ALL_HEAP_HEADER] = metadata_of_heap_header (SHOW_ALL);
show_Metas[SHOWSTMT_HEAP_CAPACITY] = metadata_of_heap_capacity (SHOW_ONLY);
show_Metas[SHOWSTMT_ALL_HEAP_CAPACITY] = metadata_of_heap_capacity (SHOW_ALL);
show_Metas[SHOWSTMT_INDEX_HEADER] = metadata_of_index_header (SHOW_ONLY);
show_Metas[SHOWSTMT_INDEX_CAPACITY] = metadata_of_index_capacity (SHOW_ONLY);
show_Metas[SHOWSTMT_ALL_INDEXES_HEADER] = metadata_of_index_header (SHOW_ALL);
show_Metas[SHOWSTMT_ALL_INDEXES_CAPACITY] = metadata_of_index_capacity (SHOW_ALL);
show_Metas[SHOWSTMT_GLOBAL_CRITICAL_SECTIONS] = metadata_of_global_critical_sections ();
show_Metas[SHOWSTMT_JOB_QUEUES] = metadata_of_job_queues ();
show_Metas[SHOWSTMT_TIMEZONES] = metadata_of_timezones ();
show_Metas[SHOWSTMT_FULL_TIMEZONES] = metadata_of_full_timezones ();
show_Metas[SHOWSTMT_TRAN_TABLES] = metadata_of_tran_tables ();
show_Metas[SHOWSTMT_THREADS] = metadata_of_threads ();
show_Metas[SHOWSTMT_PAGE_BUFFER_STATUS] = metadata_of_page_buffer_status ();
for (i = 0; i < DIM (show_Metas); i++)
{
error = init_db_attribute_list (show_Metas[i]);
if (error != NO_ERROR)
{
goto on_error;
}
}
show_Inited = true;
return NO_ERROR;
on_error:
for (i = 0; i < DIM (show_Metas); i++)
{
free_db_attribute_list (show_Metas[i]);
}
return error;
}
/*
* showstmt_metadata_final() -- free the metadata of show statements
*/
void
showstmt_metadata_final (void)
{
unsigned int i;
if (!show_Inited)
{
return;
}
for (i = 0; i < DIM (show_Metas); i++)
{
free_db_attribute_list (show_Metas[i]);
}
show_Inited = false;
}
static PT_NODE *
pt_check_access_status (PARSER_CONTEXT * parser, PT_NODE * node)
{
DB_VALUE oid_val;
MOP classop;
PT_NODE *entity = NULL;
PT_NODE *derived_table = NULL;
PT_NODE *arg = NULL;
if (!au_is_dba_group_member (Au_user))
{
PT_ERRORmf (parser, NULL, MSGCAT_SET_ERROR, -(ER_AU_DBA_ONLY), "show access status");
return node;
}
entity = node->info.query.q.select.from;
assert (entity != NULL);
derived_table = entity->info.spec.derived_table;
assert (derived_table != NULL);
classop = sm_find_class ("db_user");
if (classop == NULL)
{
assert (er_errid () != NO_ERROR);
PT_ERRORc (parser, node, er_msg ());
return node;
}
db_make_oid (&oid_val, &classop->oid_info.oid);
arg = pt_dbval_to_value (parser, &oid_val);
derived_table->info.showstmt.show_args = parser_append_node (arg, derived_table->info.showstmt.show_args);
return node;
}
/*
* pt_check_show_index () - semantic check for show index.
* return:
* parser(in):
* node(in):
*/
static PT_NODE *
pt_check_show_index (PARSER_CONTEXT * parser, PT_NODE * node)
{
PT_NODE *show_args_node = NULL;
MOP cls;
const char *table_name = NULL;
const char *index_name = NULL;
SM_CLASS *sm_class = NULL;
SM_CLASS_CONSTRAINT *sm_all_constraints = NULL;
SM_CLASS_CONSTRAINT *sm_constraint = NULL;
PT_NODE *entity = NULL;
PT_NODE *derived_table = NULL;
SHOWSTMT_TYPE show_type;
int error = NO_ERROR;
int save;
int partition_type = DB_NOT_PARTITIONED_CLASS;
PT_NODE *partition_node = NULL;
if (node->node_type != PT_SELECT)
{
return node;
}
entity = node->info.query.q.select.from;
assert (entity != NULL);
derived_table = entity->info.spec.derived_table;
assert (derived_table != NULL);
show_type = derived_table->info.showstmt.show_type;
assert (show_type == SHOWSTMT_INDEX_HEADER || show_type == SHOWSTMT_INDEX_CAPACITY
|| show_type == SHOWSTMT_ALL_INDEXES_HEADER || show_type == SHOWSTMT_ALL_INDEXES_CAPACITY);
show_args_node = derived_table->info.showstmt.show_args;
assert (show_args_node != NULL);
assert (show_args_node->node_type == PT_VALUE);
assert (show_args_node->type_enum == PT_TYPE_CHAR);
assert (show_args_node->info.value.data_value.str->length < DB_MAX_IDENTIFIER_LENGTH);
/* check table name */
table_name = (const char *) show_args_node->info.value.data_value.str->bytes;
cls = sm_find_class (table_name);
if (cls == NULL)
{
PT_ERRORmf (parser, show_args_node, MSGCAT_SET_ERROR, -(ER_LC_UNKNOWN_CLASSNAME), table_name);
return node;
}
AU_DISABLE (save);
error = au_fetch_class_force (cls, &sm_class, AU_FETCH_READ);
AU_ENABLE (save);
if (error == NO_ERROR)
{
if (sm_get_class_type (sm_class) != SM_CLASS_CT)
{
PT_ERRORm (parser, show_args_node, MSGCAT_SET_ERROR, -(ER_OBJ_NOT_A_CLASS));
return node;
}
}
/* check index name */
if (show_type == SHOWSTMT_INDEX_HEADER || show_type == SHOWSTMT_INDEX_CAPACITY)
{
show_args_node = show_args_node->next;
assert (show_args_node != NULL);
assert (show_args_node->node_type == PT_VALUE);
assert (show_args_node->type_enum == PT_TYPE_CHAR);
assert (show_args_node->info.value.data_value.str->length < DB_MAX_IDENTIFIER_LENGTH);
index_name = (const char *) show_args_node->info.value.data_value.str->bytes;
sm_all_constraints = sm_class_constraints (cls);
sm_constraint = classobj_find_constraint_by_name (sm_all_constraints, index_name);
if (sm_all_constraints == NULL || sm_constraint == NULL)
{
PT_ERRORmf (parser, show_args_node, MSGCAT_SET_ERROR, -(ER_SM_NO_INDEX), index_name);
return node;
}
}
/* get partition type and pass it by args */
error = sm_partitioned_class_type (cls, &partition_type, NULL, NULL);
if (error != NO_ERROR)
{
PT_ERRORc (parser, show_args_node, er_msg ());
return node;
}
partition_node = pt_make_integer_value (parser, partition_type);
if (partition_node == NULL)
{
PT_INTERNAL_ERROR (parser, "allocate new node");
return node;
}
parser_append_node (partition_node, show_args_node);
return node;
}