database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

log0recv.c Change Innobase text to InnoDB

Browse Source 
log0log.c	Change Innobase text to InnoDB
srv0start.c	Change Innobase text to InnoDB
srv0srv.c	Change Innobase text to InnoDB
ha_innobase.cc	Change Innobase text to InnoDB
This commit is contained in:
heikki@donna.mysql.fi
2001-04-13 16:36:54 +03:00
parent b897f84d74
commit fc6dcf4df7
6 changed files with 161 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
BitKeeper/etc/logging_ok
View File

@ -1,2 +1,3 @@
paul@central.snake.net
monty@donna.mysql.fi
heikki@donna.mysql.fi

16
innobase/log/log0log.c
View File

@ -1,7 +1,7 @@
/******************************************************
Database log
(c) 1995-1997 Innobase Oy
(c) 1995-1997 InnoDB Oy
Created 12/9/1995 Heikki Tuuri
*******************************************************/
@ -1886,12 +1886,12 @@ loop:
if (!ret) {
fprintf(stderr,
"Innobase: Cannot create or open archive log file %s.\n",
"InnoDB: Cannot create or open archive log file %s.\n",
name);
fprintf(stderr, "Innobase: Cannot continue operation.\n"
"Innobase: Check that the log archive directory exists,\n"
"Innobase: you have access rights to it, and\n"
"Innobase: there is space available.\n");
fprintf(stderr, "InnoDB: Cannot continue operation.\n"
"InnoDB: Check that the log archive directory exists,\n"
"InnoDB: you have access rights to it, and\n"
"InnoDB: there is space available.\n");
exit(1);
}
@ -2628,7 +2628,7 @@ logs_empty_and_mark_files_at_shutdown(void)
dulint lsn;
ulint arch_log_no;
fprintf(stderr, "Innobase: Starting shutdown...\n");
fprintf(stderr, "InnoDB: Starting shutdown...\n");
/* Wait until the master thread and all other operations are idle: our
algorithm only works if the server is idle at shutdown */
@ -2718,7 +2718,7 @@ loop:
fil_flush_file_spaces(FIL_TABLESPACE);
fprintf(stderr, "Innobase: Shutdown completed\n");
fprintf(stderr, "InnoDB: Shutdown completed\n");
}
/**********************************************************

60
innobase/log/log0recv.c
View File

@ -1,7 +1,7 @@
/******************************************************
Recovery
(c) 1997 Innobase Oy
(c) 1997 InnoDB Oy
Created 9/20/1997 Heikki Tuuri
*******************************************************/
@ -412,7 +412,7 @@ recv_find_max_checkpoint(
+ LOG_CHECKPOINT_CHECKSUM_1)) {
if (log_debug_writes) {
fprintf(stderr,
"Innobase: Checkpoint in group %lu at %lu invalid, %lu, %lu\n",
"InnoDB: Checkpoint in group %lu at %lu invalid, %lu, %lu\n",
group->id, field,
fold & 0xFFFFFFFF,
mach_read_from_4(buf
@ -431,7 +431,7 @@ recv_find_max_checkpoint(
+ LOG_CHECKPOINT_CHECKSUM_2)) {
if (log_debug_writes) {
fprintf(stderr,
"Innobase: Checkpoint in group %lu at %lu invalid, %lu, %lu\n",
"InnoDB: Checkpoint in group %lu at %lu invalid, %lu, %lu\n",
group->id, field,
fold & 0xFFFFFFFF,
mach_read_from_4(buf
@ -451,7 +451,7 @@ recv_find_max_checkpoint(
if (log_debug_writes) {
fprintf(stderr,
"Innobase: Checkpoint number %lu found in group %lu\n",
"InnoDB: Checkpoint number %lu found in group %lu\n",
ut_dulint_get_low(checkpoint_no), group->id);
}
@ -470,7 +470,7 @@ recv_find_max_checkpoint(
if (*max_group == NULL) {
fprintf(stderr, "Innobase: No valid checkpoint found\n");
fprintf(stderr, "InnoDB: No valid checkpoint found\n");
return(DB_ERROR);
}
@ -866,7 +866,7 @@ recv_recover_page(
if (log_debug_writes) {
fprintf(stderr,
"Innobase: Applying log rec type %lu len %lu to space %lu page no %lu\n",
"InnoDB: Applying log rec type %lu len %lu to space %lu page no %lu\n",
(ulint)recv->type, recv->len, recv_addr->space,
recv_addr->page_no);
}
@ -1015,7 +1015,7 @@ loop:
if (recv_addr->state == RECV_NOT_PROCESSED) {
if (!has_printed) {
fprintf(stderr,
"Innobase: Starting an apply batch of log records to the database...\n");
"InnoDB: Starting an apply batch of log records to the database...\n");
has_printed = TRUE;
}
@ -1082,7 +1082,7 @@ loop:
recv_sys_empty_hash();
if (has_printed) {
fprintf(stderr, "Innobase: Apply batch completed\n");
fprintf(stderr, "InnoDB: Apply batch completed\n");
}
mutex_exit(&(recv_sys->mutex));
@ -1454,7 +1454,7 @@ loop:
if (log_debug_writes) {
fprintf(stderr,
"Innobase: Parsed a single log rec type %lu len %lu space %lu page no %lu\n",
"InnoDB: Parsed a single log rec type %lu len %lu space %lu page no %lu\n",
(ulint)type, len, space, page_no);
}
@ -1503,7 +1503,7 @@ loop:
if (log_debug_writes) {
fprintf(stderr,
"Innobase: Parsed a multi log rec type %lu len %lu space %lu page no %lu\n",
"InnoDB: Parsed a multi log rec type %lu len %lu space %lu page no %lu\n",
(ulint)type, len, space, page_no);
}
@ -1824,7 +1824,7 @@ recv_scan_log_recs(
if (more_data) {
fprintf(stderr,
"Innobase: Doing recovery: scanned up to log sequence number %lu %lu\n",
"InnoDB: Doing recovery: scanned up to log sequence number %lu %lu\n",
ut_dulint_get_high(*group_scanned_lsn),
ut_dulint_get_low(*group_scanned_lsn));
@ -1877,7 +1877,7 @@ recv_group_scan_log_recs(
if (log_debug_writes) {
fprintf(stderr,
"Innobase: Scanned group %lu up to log sequence number %lu %lu\n",
"InnoDB: Scanned group %lu up to log sequence number %lu %lu\n",
group->id,
ut_dulint_get_high(*group_scanned_lsn),
ut_dulint_get_low(*group_scanned_lsn));
@ -1977,11 +1977,11 @@ recv_recovery_from_checkpoint_start(
|| ut_dulint_cmp(checkpoint_lsn, min_flushed_lsn) != 0) {
fprintf(stderr,
"Innobase: Database was not shut down normally.\n"
"Innobase: Starting recovery from log files...\n");
"InnoDB: Database was not shut down normally.\n"
"InnoDB: Starting recovery from log files...\n");
fprintf(stderr,
"Innobase: Starting log scan based on checkpoint at\n"
"Innobase: log sequence number %lu %lu\n",
"InnoDB: Starting log scan based on checkpoint at\n"
"InnoDB: log sequence number %lu %lu\n",
ut_dulint_get_high(checkpoint_lsn),
ut_dulint_get_low(checkpoint_lsn));
}
@ -2134,7 +2134,7 @@ recv_recovery_from_checkpoint_finish(void)
if (log_debug_writes) {
fprintf(stderr,
"Innobase: Log records applied to the database\n");
"InnoDB: Log records applied to the database\n");
}
/* Free the resources of the recovery system */
@ -2246,12 +2246,12 @@ try_open_again:
fil_release_right_to_open();
ask_again:
fprintf(stderr,
"Innobase: Do you want to copy additional archived log files\n"
"Innobase: to the directory\n");
"InnoDB: Do you want to copy additional archived log files\n"
"InnoDB: to the directory\n");
fprintf(stderr,
"Innobase: or were these all the files needed in recovery?\n");
"InnoDB: or were these all the files needed in recovery?\n");
fprintf(stderr,
"Innobase: (Y == copy more files; N == this is all)?");
"InnoDB: (Y == copy more files; N == this is all)?");
input_char = getchar();
@ -2271,13 +2271,13 @@ ask_again:
ut_a(file_size_high == 0);
fprintf(stderr, "Innobase: Opened archived log file %s\n", name);
fprintf(stderr, "InnoDB: Opened archived log file %s\n", name);
ret = os_file_close(file_handle);
if (file_size < LOG_FILE_HDR_SIZE) {
fprintf(stderr,
"Innobase: Archive file header incomplete %s\n", name);
"InnoDB: Archive file header incomplete %s\n", name);
return(TRUE);
}
@ -2302,14 +2302,14 @@ ask_again:
|| mach_read_from_4(buf + LOG_FILE_NO)
!= group->archived_file_no) {
fprintf(stderr,
"Innobase: Archive file header inconsistent %s\n", name);
"InnoDB: Archive file header inconsistent %s\n", name);
return(TRUE);
}
if (!mach_read_from_4(buf + LOG_FILE_ARCH_COMPLETED)) {
fprintf(stderr,
"Innobase: Archive file not completely written %s\n", name);
"InnoDB: Archive file not completely written %s\n", name);
return(TRUE);
}
@ -2321,7 +2321,7 @@ ask_again:
if (ut_dulint_cmp(recv_sys->parse_start_lsn, start_lsn) < 0) {
fprintf(stderr,
"Innobase: Archive log file %s starts from too big a lsn\n",
"InnoDB: Archive log file %s starts from too big a lsn\n",
name);
return(TRUE);
}
@ -2332,7 +2332,7 @@ ask_again:
if (ut_dulint_cmp(recv_sys->scanned_lsn, start_lsn) != 0) {
fprintf(stderr,
"Innobase: Archive log file %s starts from a wrong lsn\n",
"InnoDB: Archive log file %s starts from a wrong lsn\n",
name);
return(TRUE);
}
@ -2354,7 +2354,7 @@ ask_again:
if (log_debug_writes) {
fprintf(stderr,
"Innobase: Archive read starting at lsn %lu %lu, len %lu from file %s\n",
"InnoDB: Archive read starting at lsn %lu %lu, len %lu from file %s\n",
ut_dulint_get_high(start_lsn),
ut_dulint_get_low(start_lsn),
len, name);
@ -2375,7 +2375,7 @@ ask_again:
if (ret) {
fprintf(stderr,
"Innobase: Archive log file %s does not scan right\n",
"InnoDB: Archive log file %s does not scan right\n",
name);
return(TRUE);
}
@ -2435,7 +2435,7 @@ recv_recovery_from_archive_start(
if (!group) {
fprintf(stderr,
"Innobase: There is no log group defined with id %lu!\n",
"InnoDB: There is no log group defined with id %lu!\n",
group_id);
return(DB_ERROR);
}

22
innobase/srv/srv0srv.c
View File

@ -7,7 +7,7 @@ thread is usually allocated per processor. Win32
documentation does not know any UMS threads, which suggests
that the concept is internal to SQL Server 7. It may mean that
SQL Server 7 does all the scheduling of threads itself, even
in i/o waits. We should maybe modify Innobase to use the same
in i/o waits. We should maybe modify InnoDB to use the same
technique, because thread switches within NT may be too slow.
SQL Server 7 also mentions fibers, which are cooperatively
@ -20,7 +20,7 @@ Windows 2000 will have something called thread pooling
Another possibility could be to use some very fast user space
thread library. This might confuse NT though.
(c) 1995 Innobase Oy
(c) 1995 InnoDB Oy
Created 10/8/1995 Heikki Tuuri
*******************************************************/
@ -1093,7 +1093,7 @@ srv_read_init_val(
return(DB_ERROR);
}
printf("Error in Innobase booting: keyword %s not found\n",
printf("Error in InnoDB booting: keyword %s not found\n",
keyword);
printf("from the initfile!\n");
@ -1114,7 +1114,7 @@ skip_keyword:
}
printf(
"Error in Innobase booting: could not read first value after %s\n",
"Error in InnoDB booting: could not read first value after %s\n",
keyword);
printf("from the initfile!\n");
@ -1140,7 +1140,7 @@ skip_keyword:
}
printf(
"Error in Innobase booting: could not read second value after %s\n",
"Error in InnoDB booting: could not read second value after %s\n",
keyword);
printf("from the initfile!\n");
@ -1156,7 +1156,7 @@ skip_keyword:
}
printf(
"Error in Innobase booting: numerical value too big after %s\n",
"Error in InnoDB booting: numerical value too big after %s\n",
keyword);
printf("in the initfile!\n");
@ -1173,7 +1173,7 @@ skip_keyword:
}
printf(
"Error in Innobase booting: numerical value too big after %s\n",
"Error in InnoDB booting: numerical value too big after %s\n",
keyword);
printf("in the initfile!\n");
@ -1523,7 +1523,7 @@ srv_general_init(void)
}
/*************************************************************************
Normalizes init parameter values to use units we use inside Innobase. */
Normalizes init parameter values to use units we use inside InnoDB. */
static
ulint
srv_normalize_init_values(void)
@ -1552,7 +1552,7 @@ srv_normalize_init_values(void)
}
/*************************************************************************
Boots the Innobase server. */
Boots the InnoDB server. */
ulint
srv_boot(void)
@ -1562,7 +1562,7 @@ srv_boot(void)
ulint err;
/* Transform the init parameter values given by MySQL to
use units we use inside Innobase: */
use units we use inside InnoDB: */
err = srv_normalize_init_values();
@ -1797,7 +1797,7 @@ loop:
}
/***********************************************************************
Tells the Innobase server that there has been activity in the database
Tells the InnoDB server that there has been activity in the database
and wakes up the master thread if it is suspended (not sleeping). Used
in the MySQL interface. Note that there is a small chance that the master
thread stays suspended (we do not protect our operation with the kernel

82
innobase/srv/srv0start.c
View File

@ -1,7 +1,7 @@
/************************************************************************
Starts the Innobase database server
Starts the InnoDB database server
(c) 1996-2000 Innobase Oy
(c) 1996-2000 InnoDB Oy
Created 2/16/1996 Heikki Tuuri
*************************************************************************/
@ -207,7 +207,7 @@ open_or_create_log_file(
if (ret == FALSE) {
if (os_file_get_last_error() != OS_FILE_ALREADY_EXISTS) {
fprintf(stderr,
"Innobase: Error in creating or opening %s\n", name);
"InnoDB: Error in creating or opening %s\n", name);
return(DB_ERROR);
}
@ -216,7 +216,7 @@ open_or_create_log_file(
name, OS_FILE_OPEN, OS_FILE_AIO, &ret);
if (!ret) {
fprintf(stderr,
"Innobase: Error in opening %s\n", name);
"InnoDB: Error in opening %s\n", name);
return(DB_ERROR);
}
@ -227,8 +227,8 @@ open_or_create_log_file(
if (size != UNIV_PAGE_SIZE * srv_log_file_size
|| size_high != 0) {
fprintf(stderr,
"Innobase: Error: log file %s is of different size\n"
"Innobase: than specified in the .cnf file!\n", name);
"InnoDB: Error: log file %s is of different size\n"
"InnoDB: than specified in the .cnf file!\n", name);
return(DB_ERROR);
}
@ -236,16 +236,16 @@ open_or_create_log_file(
*log_file_created = TRUE;
fprintf(stderr,
"Innobase: Log file %s did not exist: new to be created\n",
"InnoDB: Log file %s did not exist: new to be created\n",
name);
printf("Innobase: Setting log file %s size to %lu\n",
printf("InnoDB: Setting log file %s size to %lu\n",
name, UNIV_PAGE_SIZE * srv_log_file_size);
ret = os_file_set_size(name, files[i],
UNIV_PAGE_SIZE * srv_log_file_size, 0);
if (!ret) {
fprintf(stderr,
"Innobase: Error in creating %s: probably out of disk space\n",
"InnoDB: Error in creating %s: probably out of disk space\n",
name);
return(DB_ERROR);
@ -335,7 +335,7 @@ open_or_create_data_files(
if (os_file_get_last_error() !=
OS_FILE_ALREADY_EXISTS) {
fprintf(stderr,
"Innobase: Error in creating or opening %s\n",
"InnoDB: Error in creating or opening %s\n",
name);
return(DB_ERROR);
@ -343,9 +343,9 @@ open_or_create_data_files(
if (one_created) {
fprintf(stderr,
"Innobase: Error: data files can only be added at the end\n");
"InnoDB: Error: data files can only be added at the end\n");
fprintf(stderr,
"Innobase: of a tablespace, but data file %s existed beforehand.\n",
"InnoDB: of a tablespace, but data file %s existed beforehand.\n",
name);
return(DB_ERROR);
}
@ -355,7 +355,7 @@ open_or_create_data_files(
if (!ret) {
fprintf(stderr,
"Innobase: Error in opening %s\n", name);
"InnoDB: Error in opening %s\n", name);
return(DB_ERROR);
}
@ -366,8 +366,8 @@ open_or_create_data_files(
if (size != UNIV_PAGE_SIZE * srv_data_file_sizes[i]
|| size_high != 0) {
fprintf(stderr,
"Innobase: Error: data file %s is of different size\n"
"Innobase: than specified in the .cnf file!\n", name);
"InnoDB: Error: data file %s is of different size\n"
"InnoDB: than specified in the .cnf file!\n", name);
return(DB_ERROR);
}
@ -382,26 +382,26 @@ open_or_create_data_files(
if (i > 0) {
fprintf(stderr,
"Innobase: Data file %s did not exist: new to be created\n", name);
"InnoDB: Data file %s did not exist: new to be created\n", name);
} else {
fprintf(stderr,
"Innobase: The first specified data file %s did not exist:\n"
"Innobase: a new database to be created!\n", name);
"InnoDB: The first specified data file %s did not exist:\n"
"InnoDB: a new database to be created!\n", name);
*create_new_db = TRUE;
}
printf("Innobase: Setting file %s size to %lu\n",
printf("InnoDB: Setting file %s size to %lu\n",
name, UNIV_PAGE_SIZE * srv_data_file_sizes[i]);
printf(
"Innobase: Database physically writes the file full: wait...\n");
"InnoDB: Database physically writes the file full: wait...\n");
ret = os_file_set_size(name, files[i],
UNIV_PAGE_SIZE * srv_data_file_sizes[i], 0);
if (!ret) {
fprintf(stderr,
"Innobase: Error in creating %s: probably out of disk space\n", name);
"InnoDB: Error in creating %s: probably out of disk space\n", name);
return(DB_ERROR);
}
@ -503,7 +503,7 @@ test_measure_cont(
}
/********************************************************************
Starts Innobase and creates a new database if database files
Starts InnoDB and creates a new database if database files
are not found and the user wants. Server parameters are
read from a file of name "srv_init" in the ib_home directory. */
@ -606,7 +606,7 @@ innobase_start_or_create_for_mysql(void)
&sum_of_new_sizes);
if (err != DB_SUCCESS) {
fprintf(stderr, "Innobase: Could not open data files\n");
fprintf(stderr, "InnoDB: Could not open data files\n");
return((int) err);
}
@ -634,12 +634,12 @@ innobase_start_or_create_for_mysql(void)
if ((log_opened && create_new_db)
|| (log_opened && log_created)) {
fprintf(stderr,
"Innobase: Error: all log files must be created at the same time.\n"
"Innobase: If you want bigger or smaller log files,\n"
"Innobase: shut down the database and make sure there\n"
"Innobase: were no errors in shutdown.\n"
"Innobase: Then delete the existing log files. Edit the .cnf file\n"
"Innobase: and start the database again.\n");
"InnoDB: Error: all log files must be created at the same time.\n"
"InnoDB: If you want bigger or smaller log files,\n"
"InnoDB: shut down the database and make sure there\n"
"InnoDB: were no errors in shutdown.\n"
"InnoDB: Then delete the existing log files. Edit the .cnf file\n"
"InnoDB: and start the database again.\n");
return(DB_ERROR);
}
@ -652,9 +652,9 @@ innobase_start_or_create_for_mysql(void)
if (ut_dulint_cmp(max_flushed_lsn, min_flushed_lsn) != 0
|| max_arch_log_no != min_arch_log_no) {
fprintf(stderr,
"Innobase: Cannot initialize created log files because\n"
"Innobase: data files were not in sync with each other\n"
"Innobase: or the data files are corrupt./n");
"InnoDB: Cannot initialize created log files because\n"
"InnoDB: data files were not in sync with each other\n"
"InnoDB: or the data files are corrupt./n");
return(DB_ERROR);
}
@ -662,11 +662,11 @@ innobase_start_or_create_for_mysql(void)
if (ut_dulint_cmp(max_flushed_lsn, ut_dulint_create(0, 1000))
< 0) {
fprintf(stderr,
"Innobase: Cannot initialize created log files because\n"
"Innobase: data files are corrupt, or new data files were\n"
"Innobase: created when the database was started previous\n"
"Innobase: time but the database was not shut down\n"
"Innobase: normally after that.\n");
"InnoDB: Cannot initialize created log files because\n"
"InnoDB: data files are corrupt, or new data files were\n"
"InnoDB: created when the database was started previous\n"
"InnoDB: time but the database was not shut down\n"
"InnoDB: normally after that.\n");
return(DB_ERROR);
}
@ -694,7 +694,7 @@ innobase_start_or_create_for_mysql(void)
} else if (srv_archive_recovery) {
fprintf(stderr,
"Innobase: Starting archive recovery from a backup...\n");
"InnoDB: Starting archive recovery from a backup...\n");
err = recv_recovery_from_archive_start(
min_flushed_lsn,
@ -776,7 +776,7 @@ innobase_start_or_create_for_mysql(void)
/* Create the thread which watches the timeouts for lock waits */
os_thread_create(&srv_lock_timeout_monitor_thread, NULL,
thread_ids + 2 + SRV_MAX_N_IO_THREADS);
fprintf(stderr, "Innobase: Started\n");
fprintf(stderr, "InnoDB: Started\n");
srv_was_started = TRUE;
srv_is_being_started = FALSE;
@ -789,7 +789,7 @@ innobase_start_or_create_for_mysql(void)
}
/********************************************************************
Shuts down the Innobase database. */
Shuts down the InnoDB database. */
int
innobase_shutdown_for_mysql(void)
@ -799,7 +799,7 @@ innobase_shutdown_for_mysql(void)
if (!srv_was_started) {
if (srv_is_being_started) {
fprintf(stderr,
"Innobase: Warning: shutting down not properly started database\n");
"InnoDB: Warning: shutting down not properly started database\n");
}
return(DB_SUCCESS);
}

140
sql/ha_innobase.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & Innobase Oy
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & InnoDB Oy
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -14,10 +14,10 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* This file defines the Innobase handler: the interface between MySQL and
Innobase */
/* This file defines the InnoDB handler: the interface between MySQL and
InnoDB */
/* TODO list for the Innobase handler:
/* TODO list for the InnoDB handler:
- Ask Monty if strings of different languages can exist in the same
database. Answer: in near future yes, but not yet.
*/
@ -40,7 +40,7 @@ Innobase */
/* We must declare this here because we undef SAFE_MUTEX below */
pthread_mutex_t innobase_mutex;
/* Store MySQL definition of 'byte': in Linux it is char while Innobase
/* Store MySQL definition of 'byte': in Linux it is char while InnoDB
uses unsigned char */
typedef byte mysql_byte;
@ -50,7 +50,7 @@ typedef byte mysql_byte;
#define INSIDE_HA_INNOBASE_CC
/* Include necessary Innobase headers */
/* Include necessary InnoDB headers */
extern "C" {
#include "../innobase/include/univ.i"
#include "../innobase/include/srv0start.h"
@ -88,7 +88,7 @@ bool innobase_flush_log_at_trx_commit, innobase_log_archive,
/* innobase_data_file_path=ibdata:15,idata2:1,... */
/* The following counter is used to convey information to Innobase
/* The following counter is used to convey information to InnoDB
about server activity: in selects it is not sensible to call
srv_active_wake_master_thread after each fetch or search, we only do
it every INNOBASE_WAKE_INTERVAL'th step. */
@ -128,13 +128,13 @@ innobase_active_small(void)
}
/************************************************************************
Converts an Innobase error code to a MySQL error code. */
Converts an InnoDB error code to a MySQL error code. */
static
int
convert_error_code_to_mysql(
/*========================*/
/* out: MySQL error code */
int error) /* in: Innobase error code */
int error) /* in: InnoDB error code */
{
if (error == DB_SUCCESS) {
@ -180,14 +180,14 @@ convert_error_code_to_mysql(
}
/*************************************************************************
Gets the Innobase transaction handle for a MySQL handler object, creates
an Innobase transaction struct if the corresponding MySQL thread struct still
Gets the InnoDB transaction handle for a MySQL handler object, creates
an InnoDB transaction struct if the corresponding MySQL thread struct still
lacks one. */
static
trx_t*
check_trx_exists(
/*=============*/
/* out: Innobase transaction handle */
/* out: InnoDB transaction handle */
THD* thd) /* in: user thread handle */
{
trx_t* trx;
@ -201,10 +201,10 @@ check_trx_exists(
thd->transaction.all.innobase_tid = trx;
/* The execution of a single SQL statement is denoted by
a 'transaction' handle which is a dummy pointer: Innobase
a 'transaction' handle which is a dummy pointer: InnoDB
remembers internally where the latest SQL statement
started, and if error handling requires rolling back the
latest statement, Innobase does a rollback to a savepoint. */
latest statement, InnoDB does a rollback to a savepoint. */
thd->transaction.stmt.innobase_tid =
(void*)&innodb_dummy_stmt_trx_handle;
@ -214,7 +214,7 @@ check_trx_exists(
}
/*************************************************************************
Updates the user_thd field in a handle and also allocates a new Innobase
Updates the user_thd field in a handle and also allocates a new InnoDB
transaction handle if needed, and updates the transaction fields in the
prebuilt struct. */
inline
@ -418,7 +418,7 @@ innobase_parse_log_group_home_dirs(void)
}
/*************************************************************************
Opens an Innobase database. */
Opens an InnoDB database. */
bool
innobase_init(void)
@ -443,13 +443,13 @@ innobase_init(void)
current_dir[1]=FN_LIBCHAR;
current_dir[2]=0;
/* Set Innobase initialization parameters according to the values
/* Set InnoDB initialization parameters according to the values
read from MySQL .cnf file */
if (!innobase_data_file_path)
{
fprintf(stderr,
"Can't initialize Innobase as 'innobase_data_file_path' is not set\n");
"Can't initialize InnoDB as 'innobase_data_file_path' is not set\n");
innodb_skip=1;
DBUG_RETURN(FALSE); // Continue without innobase
}
@ -504,7 +504,7 @@ innobase_init(void)
}
/***********************************************************************
Closes an Innobase database. */
Closes an InnoDB database. */
bool
innobase_end(void)
@ -527,7 +527,7 @@ innobase_end(void)
}
/********************************************************************
Flushes Innobase logs to disk and makes a checkpoint. Really, a commit
Flushes InnoDB logs to disk and makes a checkpoint. Really, a commit
flushes logs, and the name of this function should be innobase_checkpoint. */
bool
@ -545,7 +545,7 @@ innobase_flush_logs(void)
}
/*************************************************************************
Gets the free space in an Innobase database: returned in units of kB. */
Gets the free space in an InnoDB database: returned in units of kB. */
uint
innobase_get_free_space(void)
@ -556,7 +556,7 @@ innobase_get_free_space(void)
}
/*********************************************************************
Commits a transaction in an Innobase database. */
Commits a transaction in an InnoDB database. */
int
innobase_commit(
@ -564,7 +564,7 @@ innobase_commit(
/* out: 0 or error number */
THD* thd, /* in: MySQL thread handle of the user for whom
the transaction should be committed */
void* trx_handle)/* in: Innobase trx handle or NULL: NULL means
void* trx_handle)/* in: InnoDB trx handle or NULL: NULL means
that the current SQL statement ended, and we should
mark the start of a new statement with a savepoint */
{
@ -588,7 +588,7 @@ innobase_commit(
DBUG_PRINT("error", ("error: %d", error));
}
#endif
/* Tell Innobase server that there might be work for
/* Tell InnoDB server that there might be work for
utility threads: */
srv_active_wake_master_thread();
@ -597,7 +597,7 @@ innobase_commit(
}
/*********************************************************************
Rolls back a transaction in an Innobase database. */
Rolls back a transaction in an InnoDB database. */
int
innobase_rollback(
@ -605,7 +605,7 @@ innobase_rollback(
/* out: 0 or error number */
THD* thd, /* in: handle to the MySQL thread of the user
whose transaction should be rolled back */
void* trx_handle)/* in: Innobase trx handle or a dummy stmt handle */
void* trx_handle)/* in: InnoDB trx handle or a dummy stmt handle */
{
int error = 0;
trx_t* trx;
@ -626,7 +626,7 @@ innobase_rollback(
}
/*********************************************************************
Frees a possible Innobase trx object associated with the current
Frees a possible InnoDB trx object associated with the current
THD. */
int
@ -660,7 +660,7 @@ innobase_print_error(
/*****************************************************************************
** Innobase database tables
** InnoDB database tables
*****************************************************************************/
/********************************************************************
@ -770,7 +770,7 @@ ha_innobase::open(
ref_length = buff_len;
/* Get pointer to a table object in Innobase dictionary cache */
/* Get pointer to a table object in InnoDB dictionary cache */
if (NULL == (ib_table = dict_table_get(norm_name, NULL))) {
@ -824,7 +824,7 @@ ha_innobase::initialize(void)
}
/**********************************************************************
Closes a handle to an Innobase table. */
Closes a handle to an InnoDB table. */
int
ha_innobase::close(void)
@ -838,7 +838,7 @@ ha_innobase::close(void)
my_free((char*) upd_buff, MYF(0));
free_share(share);
/* Tell Innobase server that there might be work for
/* Tell InnoDB server that there might be work for
utility threads: */
srv_active_wake_master_thread();
@ -924,9 +924,9 @@ reset_null_bits(
extern "C" {
/*****************************************************************
Innobase uses this function is to compare two data fields for which the
InnoDB uses this function is to compare two data fields for which the
data type is such that we must use MySQL code to compare them. NOTE that the
prototype of this function is in rem0cmp.c in Innobase source code!
prototype of this function is in rem0cmp.c in InnoDB source code!
If you change this function, remember to update the prototype there! */
int
@ -972,7 +972,7 @@ innobase_mysql_cmp(
}
/******************************************************************
Converts a MySQL type to an Innobase type. */
Converts a MySQL type to an InnoDB type. */
inline
ulint
get_innobase_type_from_mysql_type(
@ -1231,7 +1231,7 @@ skip_field:
}
/************************************************************************
Stores a row in an Innobase database, to the table specified in this
Stores a row in an InnoDB database, to the table specified in this
handle. */
int
@ -1295,7 +1295,7 @@ ha_innobase::write_row(
error = convert_error_code_to_mysql(error);
/* Tell Innobase server that there might be work for
/* Tell InnoDB server that there might be work for
utility threads: */
innobase_active_small();
@ -1304,7 +1304,7 @@ ha_innobase::write_row(
}
/******************************************************************
Converts field data for storage in an Innobase update vector. */
Converts field data for storage in an InnoDB update vector. */
inline
mysql_byte*
innobase_convert_and_store_changed_col(
@ -1315,7 +1315,7 @@ innobase_convert_and_store_changed_col(
mysql_byte* buf, /* in: buffer we can use in conversion */
mysql_byte* data, /* in: column data to store */
ulint len, /* in: data len */
ulint col_type,/* in: data type in Innobase type numbers */
ulint col_type,/* in: data type in InnoDB type numbers */
ulint is_unsigned)/* in: != 0 if an unsigned integer type */
{
uint i;
@ -1330,7 +1330,7 @@ innobase_convert_and_store_changed_col(
}
} else if (col_type == DATA_INT) {
/* Store integer data in Innobase in a big-endian
/* Store integer data in InnoDB in a big-endian
format, sign bit negated, if signed */
for (i = 0; i < len; i++) {
@ -1365,7 +1365,7 @@ calc_row_difference(
mysql_byte* new_row, /* in: new row in MySQL format */
struct st_table* table, /* in: table in MySQL data dictionary */
mysql_byte* upd_buff, /* in: buffer to use */
row_prebuilt_t* prebuilt, /* in: Innobase prebuilt struct */
row_prebuilt_t* prebuilt, /* in: InnoDB prebuilt struct */
THD* thd) /* in: user thread */
{
Field* field;
@ -1460,7 +1460,7 @@ calc_row_difference(
Updates a row given as a parameter to a new value. Note that we are given
whole rows, not just the fields which are updated: this incurs some
overhead for CPU when we check which fields are actually updated.
TODO: currently Innobase does not prevent the 'Halloween problem':
TODO: currently InnoDB does not prevent the 'Halloween problem':
in a searched update a single row can get updated several times
if its index columns are updated! */
@ -1504,7 +1504,7 @@ ha_innobase::update_row(
error = convert_error_code_to_mysql(error);
/* Tell Innobase server that there might be work for
/* Tell InnoDB server that there might be work for
utility threads: */
innobase_active_small();
@ -1544,7 +1544,7 @@ ha_innobase::delete_row(
error = convert_error_code_to_mysql(error);
/* Tell the Innobase server that there might be work for
/* Tell the InnoDB server that there might be work for
utility threads: */
innobase_active_small();
@ -1584,7 +1584,7 @@ ha_innobase::index_end(void)
/*************************************************************************
Converts a search mode flag understood by MySQL to a flag understood
by Innobase. */
by InnoDB. */
inline
ulint
convert_search_mode_to_innobase(
@ -1710,7 +1710,7 @@ ha_innobase::change_active_index(
/* out: 0 or error code */
uint keynr) /* in: use this index; MAX_KEY means always clustered
index, even if it was internally generated by
Innobase */
InnoDB */
{
row_prebuilt_t* prebuilt = (row_prebuilt_t*) innobase_prebuilt;
KEY* key;
@ -2011,7 +2011,7 @@ ha_innobase::rnd_pos(
Stores a reference to the current row to 'ref' field of the handle. Note
that the function parameter is illogical: we must assume that 'record'
is the current 'position' of the handle, because if row ref is actually
the row id internally generated in Innobase, then 'record' does not contain
the row id internally generated in InnoDB, then 'record' does not contain
it. We just guess that the row id must be for the record where the handle
was positioned the last time. */
@ -2073,7 +2073,7 @@ int ha_innobase::reset(void)
As MySQL will execute an external lock for every new table it uses when it
starts to process an SQL statement, we can use this function to store the
pointer to the THD in the handle. We will also use this function to communicate
to Innobase that a new SQL statement has started and that we must store a
to InnoDB that a new SQL statement has started and that we must store a
savepoint to our transaction handle, so that we are able to roll back
the SQL statement in case of an error. */
@ -2122,12 +2122,12 @@ ha_innobase::external_lock(
}
/*********************************************************************
Creates a table definition to an Innobase database. */
Creates a table definition to an InnoDB database. */
static
int
create_table_def(
/*=============*/
trx_t* trx, /* in: Innobase transaction handle */
trx_t* trx, /* in: InnoDB transaction handle */
TABLE* form, /* in: information on table
columns and indexes */
const char* table_name) /* in: table name */
@ -2181,12 +2181,12 @@ create_table_def(
}
/*********************************************************************
Creates an index in an Innobase database. */
Creates an index in an InnoDB database. */
static
int
create_index(
/*=========*/
trx_t* trx, /* in: Innobase transaction handle */
trx_t* trx, /* in: InnoDB transaction handle */
TABLE* form, /* in: information on table
columns and indexes */
const char* table_name, /* in: table name */
@ -2216,7 +2216,7 @@ create_index(
ind_type = ind_type | DICT_UNIQUE;
}
/* The '0' below specifies that everything in Innobase is currently
/* The '0' below specifies that everything in InnoDB is currently
created in tablespace 0 */
index = dict_mem_index_create((char*) table_name, key->name, 0,
@ -2238,19 +2238,19 @@ create_index(
}
/*********************************************************************
Creates an index to an Innobase table when the user has defined no
Creates an index to an InnoDB table when the user has defined no
primary index. */
static
int
create_clustered_index_when_no_primary(
/*===================================*/
trx_t* trx, /* in: Innobase transaction handle */
trx_t* trx, /* in: InnoDB transaction handle */
const char* table_name) /* in: table name */
{
dict_index_t* index;
int error;
/* The first '0' below specifies that everything in Innobase is
/* The first '0' below specifies that everything in InnoDB is
currently created in file space 0 */
index = dict_mem_index_create((char*) table_name,
@ -2264,7 +2264,7 @@ create_clustered_index_when_no_primary(
}
/*********************************************************************
Creates a new table to an Innobase database. */
Creates a new table to an InnoDB database. */
int
ha_innobase::create(
@ -2292,7 +2292,7 @@ ha_innobase::create(
normalize_table_name(norm_name, name2);
/* Create the table definition in Innobase */
/* Create the table definition in InnoDB */
if ((error = create_table_def(trx, form, norm_name))) {
@ -2323,7 +2323,7 @@ ha_innobase::create(
if (form->keys == 0 || primary_key_no == -1) {
/* Create an index which is used as the clustered index;
order the rows by their row id which is internally generated
by Innobase */
by InnoDB */
error = create_clustered_index_when_no_primary(trx,
norm_name);
@ -2337,7 +2337,7 @@ ha_innobase::create(
}
if (primary_key_no != -1) {
/* In Innobase the clustered index must always be created
/* In InnoDB the clustered index must always be created
first */
if ((error = create_index(trx, form, norm_name,
(uint) primary_key_no))) {
@ -2370,7 +2370,7 @@ ha_innobase::create(
assert(innobase_table);
/* Tell the Innobase server that there might be work for
/* Tell the InnoDB server that there might be work for
utility threads: */
srv_active_wake_master_thread();
@ -2381,10 +2381,10 @@ ha_innobase::create(
}
/*********************************************************************
Drops a table from an Innobase database. Before calling this function,
Drops a table from an InnoDB database. Before calling this function,
MySQL calls innobase_commit to commit the transaction of the current user.
Then the current user cannot have locks set on the table. Drop table
operation inside Innobase will wait sleeping in a loop until no other
operation inside InnoDB will wait sleeping in a loop until no other
user has locks on the table. */
int
@ -2411,11 +2411,11 @@ ha_innobase::delete_table(
normalize_table_name(norm_name, name);
/* Drop the table in Innobase */
/* Drop the table in InnoDB */
error = row_drop_table_for_mysql(norm_name, trx, FALSE);
/* Tell the Innobase server that there might be work for
/* Tell the InnoDB server that there might be work for
utility threads: */
srv_active_wake_master_thread();
@ -2428,7 +2428,7 @@ ha_innobase::delete_table(
}
/*************************************************************************
Renames an Innobase table. */
Renames an InnoDB table. */
int
ha_innobase::rename_table(
@ -2457,11 +2457,11 @@ ha_innobase::rename_table(
normalize_table_name(norm_from, from);
normalize_table_name(norm_to, to);
/* Rename the table in Innobase */
/* Rename the table in InnoDB */
error = row_rename_table_for_mysql(norm_from, norm_to, trx);
/* Tell the Innobase server that there might be work for
/* Tell the InnoDB server that there might be work for
utility threads: */
srv_active_wake_master_thread();
@ -2630,7 +2630,7 @@ ha_innobase::info(
}
}
/* The trx struct in Innobase contains a pthread mutex embedded:
/* The trx struct in InnoDB contains a pthread mutex embedded:
in the debug version of MySQL that it replaced by a 'safe mutex'
which is of a different size. We have to use a function to access
trx fields. Otherwise trx->error_info will be a random
@ -2646,7 +2646,7 @@ ha_innobase::info(
}
/*****************************************************************
Adds information about free space in the Innobase tablespace to a
Adds information about free space in the InnoDB tablespace to a
table comment which is printed out when a user calls SHOW TABLE STATUS. */
char*
@ -2668,7 +2668,7 @@ ha_innobase::update_table_comment(
*pos++=';';
*pos++=' ';
}
sprintf(pos, "Innobase free: %lu kB", (ulong) innobase_get_free_space());
sprintf(pos, "InnoDB free: %lu kB", (ulong) innobase_get_free_space());
return(str);
}