�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Finnobase%2F'>innobase</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Finnobase%2Fut%2F'>ut</a>/</p><hr><h3>✏️ Editing: ut0ut.cc</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*****************************************************************************

Copyright (c) 1994, 2017, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, 2022, MariaDB Corporation.

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 the Free Software
Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA

*****************************************************************************/

/***************************************************************//**
@file ut/ut0ut.cc
Various utilities for Innobase.

Created 5/11/1994 Heikki Tuuri
********************************************************************/

#include &quot;ha_prototypes.h&quot;

#if HAVE_SYS_TIME_H
#include &lt;sys/time.h&gt;
#endif

#ifndef UNIV_INNOCHECKSUM
#include &lt;mysql_com.h&gt;
#include &quot;ut0ut.h&quot;
#include &quot;trx0trx.h&quot;
#include &lt;string&gt;
#include &quot;log.h&quot;
#include &quot;my_cpu.h&quot;
#ifndef DBUG_OFF
#include &quot;rem0rec.h&quot;
#endif

/**********************************************************//**
Returns the number of milliseconds since some epoch.  The
value may wrap around.  It should only be used for heuristic
purposes.
@return ms since epoch */
ulint
ut_time_ms(void)
/*============*/
{
	return static_cast&lt;ulint&gt;(my_interval_timer() / 1000000);
}
#endif /* !UNIV_INNOCHECKSUM */

/**********************************************************//**
Prints a timestamp to a file. */
void
ut_print_timestamp(
/*===============*/
	FILE*  file) /*!&lt; in: file where to print */
{
#ifdef _WIN32
	SYSTEMTIME cal_tm;
	GetLocalTime(&amp;cal_tm);
#else
	time_t	   tm;
	struct tm  cal_tm;
	time(&amp;tm);
	localtime_r(&amp;tm, &amp;cal_tm);
#endif
	fprintf(file,
		IF_WIN(&quot;%u-%02u-%02u %02u:%02u:%02u %#zx&quot;,
		       &quot;%d-%02d-%02d %02d:%02d:%02d %#zx&quot;),
#ifdef _WIN32
		cal_tm.wYear,
		cal_tm.wMonth,
		cal_tm.wDay,
		cal_tm.wHour,
		cal_tm.wMinute,
		cal_tm.wSecond,
#else
		cal_tm.tm_year + 1900,
		cal_tm.tm_mon + 1,
		cal_tm.tm_mday,
		cal_tm.tm_hour,
		cal_tm.tm_min,
		cal_tm.tm_sec,
#endif
#ifdef UNIV_INNOCHECKSUM
		ulint{0}
#else
		ulint(pthread_self())
#endif
		);
}

#ifndef UNIV_INNOCHECKSUM

/**********************************************************//**
Sprintfs a timestamp to a buffer, 13..14 chars plus terminating NUL. */
void
ut_sprintf_timestamp(
/*=================*/
	char*	buf) /*!&lt; in: buffer where to sprintf */
{
#ifdef _WIN32
	SYSTEMTIME cal_tm;
	GetLocalTime(&amp;cal_tm);

	sprintf(buf, &quot;%02u%02u%02u %2u:%02u:%02u&quot;,
		cal_tm.wYear % 100,
		cal_tm.wMonth,
		cal_tm.wDay,
		cal_tm.wHour,
		cal_tm.wMinute,
		cal_tm.wSecond);
#else
	time_t	   tm;
	struct tm  cal_tm;
	time(&amp;tm);
	localtime_r(&amp;tm, &amp;cal_tm);
	sprintf(buf, &quot;%02d%02d%02d %2d:%02d:%02d&quot;,
		cal_tm.tm_year % 100,
		cal_tm.tm_mon + 1,
		cal_tm.tm_mday,
		cal_tm.tm_hour,
		cal_tm.tm_min,
		cal_tm.tm_sec);
#endif
}

/*************************************************************//**
Prints the contents of a memory buffer in hex and ascii. */
void
ut_print_buf(
/*=========*/
	FILE*		file,	/*!&lt; in: file where to print */
	const void*	buf,	/*!&lt; in: memory buffer */
	ulint		len)	/*!&lt; in: length of the buffer */
{
	const byte*	data;
	ulint		i;

	fprintf(file, &quot; len &quot; ULINTPF &quot;; hex &quot;, len);

	for (data = (const byte*) buf, i = 0; i &lt; len; i++) {
		fprintf(file, &quot;%02x&quot;, *data++);
	}

	fputs(&quot;; asc &quot;, file);

	data = (const byte*) buf;

	for (i = 0; i &lt; len; i++) {
		int	c = (int) *data++;
		putc(isprint(c) ? c : &#039; &#039;, file);
	}

	putc(&#039;;&#039;, file);
}

/*************************************************************//**
Prints the contents of a memory buffer in hex. */
void
ut_print_buf_hex(
/*=============*/
	std::ostream&amp;	o,	/*!&lt; in/out: output stream */
	const void*	buf,	/*!&lt; in: memory buffer */
	ulint		len)	/*!&lt; in: length of the buffer */
{
	const byte*		data;
	ulint			i;

	static const char	hexdigit[16] = {
		&#039;0&#039;,&#039;1&#039;,&#039;2&#039;,&#039;3&#039;,&#039;4&#039;,&#039;5&#039;,&#039;6&#039;,&#039;7&#039;,&#039;8&#039;,&#039;9&#039;,&#039;A&#039;,&#039;B&#039;,&#039;C&#039;,&#039;D&#039;,&#039;E&#039;,&#039;F&#039;
	};

	o &lt;&lt; &quot;(0x&quot;;

	for (data = static_cast&lt;const byte*&gt;(buf), i = 0; i &lt; len; i++) {
		byte	b = *data++;
		o &lt;&lt; hexdigit[int(b) &gt;&gt; 4] &lt;&lt; hexdigit[b &amp; 15];
	}

	o &lt;&lt; &quot;)&quot;;
}

/*************************************************************//**
Prints the contents of a memory buffer in hex and ascii. */
void
ut_print_buf(
/*=========*/
	std::ostream&amp;	o,	/*!&lt; in/out: output stream */
	const void*	buf,	/*!&lt; in: memory buffer */
	ulint		len)	/*!&lt; in: length of the buffer */
{
	const byte*	data;
	ulint		i;

	for (data = static_cast&lt;const byte*&gt;(buf), i = 0; i &lt; len; i++) {
		int	c = static_cast&lt;int&gt;(*data++);
		o &lt;&lt; (isprint(c) ? static_cast&lt;char&gt;(c) : &#039; &#039;);
	}

	ut_print_buf_hex(o, buf, len);
}

/** Get a fixed-length string, quoted as an SQL identifier.
If the string contains a slash &#039;/&#039;, the string will be
output as two identifiers separated by a period (.),
as in SQL database_name.identifier.
 @param		[in]	trx		transaction (NULL=no quotes).
 @param		[in]	name		table name.
 @retval	String quoted as an SQL identifier.
*/
std::string
ut_get_name(
	const trx_t*	trx,
	const char*	name)
{
	/* 2 * NAME_LEN for database and table name,
	and some slack for the #mysql50# prefix and quotes */
	char		buf[3 * NAME_LEN];
	const char*	bufend;

	bufend = innobase_convert_name(buf, sizeof buf,
				       name, strlen(name),
				       trx ? trx-&gt;mysql_thd : NULL);
	buf[bufend - buf] = &#039;\0&#039;;
	return(std::string(buf, 0, size_t(bufend - buf)));
}

/**********************************************************************//**
Outputs a fixed-length string, quoted as an SQL identifier.
If the string contains a slash &#039;/&#039;, the string will be
output as two identifiers separated by a period (.),
as in SQL database_name.identifier. */
void
ut_print_name(
/*==========*/
	FILE*		f,	/*!&lt; in: output stream */
	const trx_t*	trx,	/*!&lt; in: transaction */
	const char*	name)	/*!&lt; in: name to print */
{
	/* 2 * NAME_LEN for database and table name,
	and some slack for the #mysql50# prefix and quotes */
	char		buf[3 * NAME_LEN];
	const char*	bufend;

	bufend = innobase_convert_name(buf, sizeof buf,
				       name, strlen(name),
				       trx ? trx-&gt;mysql_thd : NULL);

	if (fwrite(buf, 1, size_t(bufend - buf), f) != size_t(bufend - buf)) {
		perror(&quot;fwrite&quot;);
	}
}

/**********************************************************************//**
Catenate files. */
void
ut_copy_file(
/*=========*/
	FILE*	dest,	/*!&lt; in: output file */
	FILE*	src)	/*!&lt; in: input file to be appended to output */
{
	long	len = ftell(src);
	char	buf[4096];

	rewind(src);
	do {
		size_t	maxs = len &lt; (long) sizeof buf
			? (size_t) len
			: sizeof buf;
		size_t	size = fread(buf, 1, maxs, src);
		if (fwrite(buf, 1, size, dest) != size) {
			perror(&quot;fwrite&quot;);
		}
		len -= (long) size;
		if (size &lt; maxs) {
			break;
		}
	} while (len &gt; 0);
}

/** Convert an error number to a human readable text message.
The returned string is static and should not be freed or modified.
@param[in]	num	InnoDB internal error number
@return string, describing the error */
const char*
ut_strerr(
	dberr_t	num)
{
	switch (num) {
	case DB_SUCCESS:
		return(&quot;Success&quot;);
	case DB_SUCCESS_LOCKED_REC:
		return(&quot;Success, record lock created&quot;);
	case DB_ERROR:
		return(&quot;Generic error&quot;);
	case DB_READ_ONLY:
		return(&quot;Read only transaction&quot;);
	case DB_INTERRUPTED:
		return(&quot;Operation interrupted&quot;);
	case DB_OUT_OF_MEMORY:
		return(&quot;Cannot allocate memory&quot;);
	case DB_OUT_OF_FILE_SPACE:
		return(&quot;Out of disk space&quot;);
	case DB_LOCK_WAIT:
		return(&quot;Lock wait&quot;);
	case DB_DEADLOCK:
		return(&quot;Deadlock&quot;);
	case DB_RECORD_CHANGED:
		return(&quot;Record changed&quot;);
#ifdef WITH_WSREP
	case DB_ROLLBACK:
		return(&quot;Rollback&quot;);
#endif
	case DB_DUPLICATE_KEY:
		return(&quot;Duplicate key&quot;);
	case DB_MISSING_HISTORY:
		return(&quot;Required history data has been deleted&quot;);
	case DB_TABLE_NOT_FOUND:
		return(&quot;Table not found&quot;);
	case DB_TOO_BIG_RECORD:
		return(&quot;Record too big&quot;);
	case DB_TOO_BIG_INDEX_COL:
		return(&quot;Index columns size too big&quot;);
	case DB_LOCK_WAIT_TIMEOUT:
		return(&quot;Lock wait timeout&quot;);
	case DB_NO_REFERENCED_ROW:
		return(&quot;Referenced key value not found&quot;);
	case DB_ROW_IS_REFERENCED:
		return(&quot;Row is referenced&quot;);
	case DB_CANNOT_ADD_CONSTRAINT:
		return(&quot;Cannot add constraint&quot;);
	case DB_CORRUPTION:
		return(&quot;Data structure corruption&quot;);
	case DB_CANNOT_DROP_CONSTRAINT:
		return(&quot;Cannot drop constraint&quot;);
	case DB_TABLESPACE_EXISTS:
		return(&quot;Tablespace already exists&quot;);
	case DB_TABLESPACE_DELETED:
		return(&quot;Tablespace deleted or being deleted&quot;);
	case DB_TABLESPACE_NOT_FOUND:
		return(&quot;Tablespace not found&quot;);
	case DB_LOCK_TABLE_FULL:
		return(&quot;Lock structs have exhausted the buffer pool&quot;);
	case DB_FOREIGN_DUPLICATE_KEY:
		return(&quot;Foreign key activated with duplicate keys&quot;);
	case DB_FOREIGN_EXCEED_MAX_CASCADE:
		return(&quot;Foreign key cascade delete/update exceeds max depth&quot;);
	case DB_TOO_MANY_CONCURRENT_TRXS:
		return(&quot;Too many concurrent transactions&quot;);
	case DB_UNSUPPORTED:
		return(&quot;Unsupported&quot;);
	case DB_INVALID_NULL:
		return(&quot;NULL value encountered in NOT NULL column&quot;);
	case DB_STATS_DO_NOT_EXIST:
		return(&quot;Persistent statistics do not exist&quot;);
	case DB_FAIL:
		return(&quot;Failed, retry may succeed&quot;);
	case DB_OVERFLOW:
		return(&quot;Overflow&quot;);
	case DB_UNDERFLOW:
		return(&quot;Underflow&quot;);
	case DB_STRONG_FAIL:
		return(&quot;Failed, retry will not succeed&quot;);
	case DB_ZIP_OVERFLOW:
		return(&quot;Zip overflow&quot;);
	case DB_RECORD_NOT_FOUND:
		return(&quot;Record not found&quot;);
	case DB_CHILD_NO_INDEX:
		return(&quot;No index on referencing keys in referencing table&quot;);
	case DB_PARENT_NO_INDEX:
		return(&quot;No index on referenced keys in referenced table&quot;);
	case DB_FTS_INVALID_DOCID:
		return(&quot;FTS Doc ID cannot be zero&quot;);
	case DB_INDEX_CORRUPT:
		return(&quot;Index corrupted&quot;);
	case DB_UNDO_RECORD_TOO_BIG:
		return(&quot;Undo record too big&quot;);
	case DB_END_OF_INDEX:
		return(&quot;End of index&quot;);
	case DB_IO_ERROR:
		return(&quot;I/O error&quot;);
	case DB_NOT_FOUND:
		return(&quot;not found&quot;);
	case DB_ONLINE_LOG_TOO_BIG:
		return(&quot;Log size exceeded during online index creation&quot;);
	case DB_IDENTIFIER_TOO_LONG:
		return(&quot;Identifier name is too long&quot;);
	case DB_FTS_EXCEED_RESULT_CACHE_LIMIT:
		return(&quot;FTS query exceeds result cache limit&quot;);
	case DB_TEMP_FILE_WRITE_FAIL:
		return(&quot;Temp file write failure&quot;);
	case DB_CANT_CREATE_GEOMETRY_OBJECT:
		return(&quot;Can&#039;t create specificed geometry data object&quot;);
	case DB_CANNOT_OPEN_FILE:
		return(&quot;Cannot open a file&quot;);
	case DB_TABLE_CORRUPT:
		return(&quot;Table is corrupted&quot;);
	case DB_FTS_TOO_MANY_WORDS_IN_PHRASE:
		return(&quot;Too many words in a FTS phrase or proximity search&quot;);
	case DB_DECRYPTION_FAILED:
		return(&quot;Table is compressed or encrypted but uncompress or decrypt failed.&quot;);
	case DB_IO_PARTIAL_FAILED:
		return(&quot;Partial IO failed&quot;);
	case DB_COMPUTE_VALUE_FAILED:
		return(&quot;Compute generated column failed&quot;);
	case DB_NO_FK_ON_S_BASE_COL:
		return(&quot;Cannot add foreign key on the base column &quot;
		       &quot;of stored column&quot;);
	case DB_IO_NO_PUNCH_HOLE:
		return (&quot;File system does not support punch hole (trim) operation.&quot;);
	case DB_PAGE_CORRUPTED:
		return(&quot;Page read from tablespace is corrupted.&quot;);

	/* do not add default: in order to produce a warning if new code
	is added to the enum but not added here */
	}

	/* we abort here because if unknown error code is given, this could
	mean that memory corruption has happened and someone&#039;s error-code
	variable has been overwritten with bogus data */
	ut_error;

	/* NOT REACHED */
	return(&quot;Unknown error&quot;);
}

namespace ib {

std::ostream &amp;operator&lt;&lt;(std::ostream &amp;lhs, const bytes_iec &amp;rhs)
{
  static const char *sizes[]= {&quot;B&quot;, &quot;KiB&quot;, &quot;MiB&quot;, &quot;GiB&quot;, &quot;TiB&quot;, &quot;PiB&quot;,
                              &quot;EiB&quot;, &quot;ZiB&quot;, &quot;YiB&quot;};
  size_t i= 0;
  double d= rhs.get_double();
  for (; d &gt; 512.0 &amp;&amp; i &lt; array_elements(sizes); i++, d/= 1024.0);
  lhs.precision(3);
  lhs &lt;&lt; std::fixed &lt;&lt; d &lt;&lt; sizes[i];
  return lhs;
}

ATTRIBUTE_COLD logger&amp; logger::operator&lt;&lt;(dberr_t err)
{
  m_oss &lt;&lt; ut_strerr(err);
  return *this;
}

info::~info()
{
	sql_print_information(&quot;InnoDB: %s&quot;, m_oss.str().c_str());
}

warn::~warn()
{
	sql_print_warning(&quot;InnoDB: %s&quot;, m_oss.str().c_str());
}

/** true if error::~error() was invoked, false otherwise */
bool error::logged;

error::~error()
{
	sql_print_error(&quot;InnoDB: %s&quot;, m_oss.str().c_str());
	logged = true;
}

#ifdef _MSC_VER
/* disable warning
  &quot;ib::fatal::~fatal&#039;: destructor never returns, potential memory leak&quot;
   on Windows.
*/
#pragma warning (push)
#pragma warning (disable : 4722)
#endif

ATTRIBUTE_NORETURN
fatal::~fatal()
{
	sql_print_error(&quot;[FATAL] InnoDB: %s&quot;, m_oss.str().c_str());
	abort();
}

#ifdef _MSC_VER
#pragma warning (pop)
#endif

error_or_warn::~error_or_warn()
{
	if (m_error) {
		sql_print_error(&quot;InnoDB: %s&quot;, m_oss.str().c_str());
	} else {
		sql_print_warning(&quot;InnoDB: %s&quot;, m_oss.str().c_str());
	}
}

fatal_or_error::~fatal_or_error()
{
	sql_print_error(m_fatal ? &quot;[FATAL] InnoDB: %s&quot; : &quot;InnoDB: %s&quot;,
			m_oss.str().c_str());
	if (m_fatal) {
		abort();
	}
}

} // namespace ib

#ifndef DBUG_OFF
static char dbug_print_buf[1024];

const char * dbug_print_rec(const rec_t* rec, const rec_offs* offsets)
{
	rec_printer r(rec, offsets);
	strmake(dbug_print_buf, r.str().c_str(), sizeof(dbug_print_buf) - 1);
	return dbug_print_buf;
}

const char * dbug_print_rec(const rec_t* rec, ulint info, const rec_offs* offsets)
{
	rec_printer r(rec, info, offsets);
	strmake(dbug_print_buf, r.str().c_str(), sizeof(dbug_print_buf) - 1);
	return dbug_print_buf;
}

const char * dbug_print_rec(const dtuple_t* tuple)
{
	rec_printer r(tuple);
	strmake(dbug_print_buf, r.str().c_str(), sizeof(dbug_print_buf) - 1);
	return dbug_print_buf;
}

const char * dbug_print_rec(const dfield_t* field, ulint n)
{
	rec_printer r(field, n);
	strmake(dbug_print_buf, r.str().c_str(), sizeof(dbug_print_buf) - 1);
	return dbug_print_buf;
}

const char * dbug_print_rec(const rec_t* rec, dict_index_t* index)
{
	rec_offs	offsets_[REC_OFFS_NORMAL_SIZE];
	rec_offs*	offsets		= offsets_;
	rec_offs_init(offsets_);
	mem_heap_t*	tmp_heap	= NULL;
	offsets = rec_get_offsets(rec, index, offsets, index-&gt;n_core_fields,
				  ULINT_UNDEFINED, &amp;tmp_heap);
	rec_printer r(rec, offsets);
	strmake(dbug_print_buf, r.str().c_str(), sizeof(dbug_print_buf) - 1);
	return dbug_print_buf;
}
#endif /* !DBUG_OFF */

#endif /* !UNIV_INNOCHECKSUM */
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Finnobase%2Fut'>🔙 Back</a></p>