mirror of
https://github.com/MariaDB/server.git
synced 2025-01-19 13:32:33 +01:00
780f80be16
* Fix BUG#15650: "DELETE with LEFT JOIN crashes server with innodb_locks_unsafe_for binlog"
* Fix BUG#17134: "Partitions: uncommitted changes are visible"
* Fix BUG#17992: "Partitions: InnoDB, somehow rotten table after UPDATE"
row0ins.c: MySQL's partitioned table code does not set preduilt->sql_stat_start right
if it does an insert in the same statement after doing a search first in the same
partition table. We now write trx id always to the buffer, not just when flag
sql_stat_start is on. This will waste CPU time very sightly.
* Fix BUG#18077: "InnoDB uses full explicit table locks in stored FUNCTION"
* Fix BUG#18238: "When locks exhaust the buffer pool, InnoDB does not roll back the trx"
* Fix BUG#18252" "Disk space leak in updates of InnoDB BLOB rows in 5.0 and 5.1"
* Fix BUG#18283: "When InnoDB returns error 'lock table full', MySQL can write to binlog too much"
* Fix BUG#18350: "Use consistent read in CREATE ... SELECT ... if innodb_locks_unsafe_for_binlog"
* Fix BUG#18384: "InnoDB memory leak on duplicate key errors in 5.0 if row has many columns"
* Fix BUG#18934: "InnoDB crashes when table uses column names like DB_ROW_ID"
Refuse tables that use reserved column names.
* InnoDB's SQL parser:
- Add support for UNSIGNED types, EXIT keyword, quoted identifiers, user-function callbacks
for processing results of FETCH statements, bound literals, DATA_VARCHAR for bound literals.
- Allow bound literals of type non-INTEGER to be of length 0.
- Add make_flex.sh and update lexer/parser generation documentation.
- Add comment clarifying the difference between 'alias' and 'indirection' fields in sym_node_t.
- Remove never reached duplicate code in pars_set_dfield_type().
- Rewrite pars_info datatypes and APIs, add a few helper functions.
- Since the functions definitions in pars_info_t are accessed after pars_sql() returns
in the query graph execution stage, we can't free pars_info_t in pars_sql(). Instead,
make pars_sql() transfer ownership of pars_info_t to the created query graph, and
make que_graph_free() free it if needed.
- Allow access to system columns like DB_ROW_ID.
* Use bound literals in row_truncate_table_for_mysql, row_drop_table_for_mysql,
row_discard_tablespace_for_mysql, and row_rename_table_for_mysql.
* Setting an isolation level of the transaction to read committed weakens the locks for
this session similarly like the option innodb_locks_unsafe_for binlog. This patch removes
alnost all gap locking (used in next-key locking) and makes MySQL to release the row locks
on the rows which does not belong to result set. Additionally, nonlocking selects on
INSERT INTO SELECT, UPDATE ... (SELECT ...), and CREATE ... SELECT ... use a nonlocking
consistent read. If a binlog is used, then binlog format should be set to row based
binloging to make the execution of the complex SQL statements.
* Disable the statistic variables btr_search_n_hash_fail and n_hash_succ, n_hash_fail,
n_patt_succ, and n_searches of btr_search_t in builds without #ifdef UNIV_SEARCH_PERF_STAT.
* Make innodb.test faster. Group all consistent read test cases to a one test case and
wait their lock timeout after all have been send to the server. Decrease amount of rows
inserted in a certain test - this has no effect on the effectiveness of the test and
reduces the running time by ~10 sec. Remove temporary work-arounds from innodb.result
now that ALTER TABLE DROP FOREIGN KEY works once again.
* Make innodb_unsafe_binlog.test faster. Grout all consistent read test cases to a one
test case amd wait their lock timeout after all have been sent to the server. Remove
unnecessary option --loose_innodb_lock_wait_timeout.
* Print dictionary memory size in SHOW INNODB STATUS.
* Fix memory leaks in row_create_table_for_mysql() in rare corner cases.
* Remove code related to clustered tables. They were never implemented, and the
implementation would be challenging with ROW_FORMAT=COMPACT. Remove the table types
DICT_TABLE_CLUSTER_MEMBER and DICT_TABLE_CLUSTER and all related tests and functions.
dict_table_t: Remove mix_id, mix_len, mix_id_len, mix_id_buf, and cluster_name.
plan_t: Remove mixed_index.
dict_create_sys_tables_tuple(): Set MIX_ID=0, MIX_LEN=0, CLUSTER_NAME=NULL when
inserting into SYS_TABLES.
dict_tree_check_search_tuple(): Enclose in #ifdef UNIV_DEBUG.
* Move calling of thr_local_free() from trx_free_for_mysql() to
innobase_close_connection().
212 lines
6.5 KiB
C
212 lines
6.5 KiB
C
/***********************************************************************
|
||
Memory primitives
|
||
|
||
(c) 1994, 1995 Innobase Oy
|
||
|
||
Created 5/30/1994 Heikki Tuuri
|
||
************************************************************************/
|
||
|
||
#ifndef ut0mem_h
|
||
#define ut0mem_h
|
||
|
||
#include "univ.i"
|
||
#include <string.h>
|
||
#include <stdlib.h>
|
||
|
||
/* The total amount of memory currently allocated from the OS with malloc */
|
||
extern ulint ut_total_allocated_memory;
|
||
|
||
UNIV_INLINE
|
||
void*
|
||
ut_memcpy(void* dest, const void* sour, ulint n);
|
||
|
||
UNIV_INLINE
|
||
void*
|
||
ut_memmove(void* dest, const void* sour, ulint n);
|
||
|
||
UNIV_INLINE
|
||
int
|
||
ut_memcmp(const void* str1, const void* str2, ulint n);
|
||
|
||
|
||
/**************************************************************************
|
||
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
|
||
defined and set_to_zero is TRUE. */
|
||
|
||
void*
|
||
ut_malloc_low(
|
||
/*==========*/
|
||
/* out, own: allocated memory */
|
||
ulint n, /* in: number of bytes to allocate */
|
||
ibool set_to_zero, /* in: TRUE if allocated memory
|
||
should be set to zero if
|
||
UNIV_SET_MEM_TO_ZERO is defined */
|
||
ibool assert_on_error); /* in: if TRUE, we crash mysqld if
|
||
the memory cannot be allocated */
|
||
/**************************************************************************
|
||
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
|
||
defined. */
|
||
|
||
void*
|
||
ut_malloc(
|
||
/*======*/
|
||
/* out, own: allocated memory */
|
||
ulint n); /* in: number of bytes to allocate */
|
||
/**************************************************************************
|
||
Tests if malloc of n bytes would succeed. ut_malloc() asserts if memory runs
|
||
out. It cannot be used if we want to return an error message. Prints to
|
||
stderr a message if fails. */
|
||
|
||
ibool
|
||
ut_test_malloc(
|
||
/*===========*/
|
||
/* out: TRUE if succeeded */
|
||
ulint n); /* in: try to allocate this many bytes */
|
||
/**************************************************************************
|
||
Frees a memory bloock allocated with ut_malloc. */
|
||
|
||
void
|
||
ut_free(
|
||
/*====*/
|
||
void* ptr); /* in, own: memory block */
|
||
/**************************************************************************
|
||
Implements realloc. This is needed by /pars/lexyy.c. Otherwise, you should not
|
||
use this function because the allocation functions in mem0mem.h are the
|
||
recommended ones in InnoDB.
|
||
|
||
man realloc in Linux, 2004:
|
||
|
||
realloc() changes the size of the memory block pointed to
|
||
by ptr to size bytes. The contents will be unchanged to
|
||
the minimum of the old and new sizes; newly allocated mem<65>
|
||
ory will be uninitialized. If ptr is NULL, the call is
|
||
equivalent to malloc(size); if size is equal to zero, the
|
||
call is equivalent to free(ptr). Unless ptr is NULL, it
|
||
must have been returned by an earlier call to malloc(),
|
||
calloc() or realloc().
|
||
|
||
RETURN VALUE
|
||
realloc() returns a pointer to the newly allocated memory,
|
||
which is suitably aligned for any kind of variable and may
|
||
be different from ptr, or NULL if the request fails. If
|
||
size was equal to 0, either NULL or a pointer suitable to
|
||
be passed to free() is returned. If realloc() fails the
|
||
original block is left untouched - it is not freed or
|
||
moved. */
|
||
|
||
void*
|
||
ut_realloc(
|
||
/*=======*/
|
||
/* out, own: pointer to new mem block or NULL */
|
||
void* ptr, /* in: pointer to old block or NULL */
|
||
ulint size); /* in: desired size */
|
||
/**************************************************************************
|
||
Frees in shutdown all allocated memory not freed yet. */
|
||
|
||
void
|
||
ut_free_all_mem(void);
|
||
/*=================*/
|
||
|
||
UNIV_INLINE
|
||
char*
|
||
ut_strcpy(char* dest, const char* sour);
|
||
|
||
UNIV_INLINE
|
||
ulint
|
||
ut_strlen(const char* str);
|
||
|
||
UNIV_INLINE
|
||
int
|
||
ut_strcmp(const void* str1, const void* str2);
|
||
|
||
/**************************************************************************
|
||
Copies up to size - 1 characters from the NUL-terminated string src to
|
||
dst, NUL-terminating the result. Returns strlen(src), so truncation
|
||
occurred if the return value >= size. */
|
||
|
||
ulint
|
||
ut_strlcpy(
|
||
/*=======*/
|
||
/* out: strlen(src) */
|
||
char* dst, /* in: destination buffer */
|
||
const char* src, /* in: source buffer */
|
||
ulint size); /* in: size of destination buffer */
|
||
|
||
/**************************************************************************
|
||
Like ut_strlcpy, but if src doesn't fit in dst completely, copies the last
|
||
(size - 1) bytes of src, not the first. */
|
||
|
||
ulint
|
||
ut_strlcpy_rev(
|
||
/*===========*/
|
||
/* out: strlen(src) */
|
||
char* dst, /* in: destination buffer */
|
||
const char* src, /* in: source buffer */
|
||
ulint size); /* in: size of destination buffer */
|
||
|
||
/**************************************************************************
|
||
Compute strlen(ut_strcpyq(str, q)). */
|
||
UNIV_INLINE
|
||
ulint
|
||
ut_strlenq(
|
||
/*=======*/
|
||
/* out: length of the string when quoted */
|
||
const char* str, /* in: null-terminated string */
|
||
char q); /* in: the quote character */
|
||
|
||
/**************************************************************************
|
||
Make a quoted copy of a NUL-terminated string. Leading and trailing
|
||
quotes will not be included; only embedded quotes will be escaped.
|
||
See also ut_strlenq() and ut_memcpyq(). */
|
||
|
||
char*
|
||
ut_strcpyq(
|
||
/*=======*/
|
||
/* out: pointer to end of dest */
|
||
char* dest, /* in: output buffer */
|
||
char q, /* in: the quote character */
|
||
const char* src); /* in: null-terminated string */
|
||
|
||
/**************************************************************************
|
||
Make a quoted copy of a fixed-length string. Leading and trailing
|
||
quotes will not be included; only embedded quotes will be escaped.
|
||
See also ut_strlenq() and ut_strcpyq(). */
|
||
|
||
char*
|
||
ut_memcpyq(
|
||
/*=======*/
|
||
/* out: pointer to end of dest */
|
||
char* dest, /* in: output buffer */
|
||
char q, /* in: the quote character */
|
||
const char* src, /* in: string to be quoted */
|
||
ulint len); /* in: length of src */
|
||
|
||
/**************************************************************************
|
||
Return the number of times s2 occurs in s1. Overlapping instances of s2
|
||
are only counted once. */
|
||
|
||
ulint
|
||
ut_strcount(
|
||
/*========*/
|
||
/* out: the number of times s2 occurs in s1 */
|
||
const char* s1, /* in: string to search in */
|
||
const char* s2); /* in: string to search for */
|
||
|
||
/**************************************************************************
|
||
Replace every occurrence of s1 in str with s2. Overlapping instances of s1
|
||
are only replaced once. */
|
||
|
||
char *
|
||
ut_strreplace(
|
||
/*==========*/
|
||
/* out, own: modified string, must be
|
||
freed with mem_free() */
|
||
const char* str, /* in: string to operate on */
|
||
const char* s1, /* in: string to replace */
|
||
const char* s2); /* in: string to replace s1 with */
|
||
|
||
#ifndef UNIV_NONINL
|
||
#include "ut0mem.ic"
|
||
#endif
|
||
|
||
#endif
|