Commit 11ff89d9 authored by marko's avatar marko

branches/zip: Add @file comments, and convert decorative

/*********************************
comments to Doxygen /** style like this:
/*****************************//**

This conversion was performed by the following command:

perl -i -e 'while(<ARGV>){if (m|^/\*{30}\**$|) {
s|\*{4}$|//**| if ++$com>1; $_ .= "\@file $ARGV\n" if $com==2}
print; if(eof){$.=0;undef $com}}' */*[ch] include/univ.i
parent aa5ceec5
This diff is collapsed.
This diff is collapsed.
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file btr/btr0pcur.c
The index tree persistent cursor
Created 2/23/1996 Heikki Tuuri
......@@ -32,7 +33,7 @@ Created 2/23/1996 Heikki Tuuri
#include "rem0cmp.h"
#include "trx0trx.h"
/******************************************************************
/**************************************************************//**
Allocates memory for a persistent cursor object and initializes the cursor.
@return own: persistent cursor */
UNIV_INTERN
......@@ -50,7 +51,7 @@ btr_pcur_create_for_mysql(void)
return(pcur);
}
/******************************************************************
/**************************************************************//**
Frees the memory for a persistent cursor object. */
UNIV_INTERN
void
......@@ -76,7 +77,7 @@ btr_pcur_free_for_mysql(
mem_free(cursor);
}
/******************************************************************
/**************************************************************//**
The position of the cursor is stored by taking an initial segment of the
record the cursor is positioned on, before, or after, and copying it to the
cursor data structure, or just setting a flag if the cursor id before the
......@@ -157,7 +158,7 @@ btr_pcur_store_position(
cursor->modify_clock = buf_block_get_modify_clock(block);
}
/******************************************************************
/**************************************************************//**
Copies the stored position of a pcur to another pcur. */
UNIV_INTERN
void
......@@ -187,7 +188,7 @@ btr_pcur_copy_stored_position(
pcur_receive->old_n_fields = pcur_donate->old_n_fields;
}
/******************************************************************
/**************************************************************//**
Restores the stored position of a persistent cursor bufferfixing the page and
obtaining the specified latches. If the cursor position was saved when the
(1) cursor was positioned on a user record: this function restores the position
......@@ -349,7 +350,7 @@ btr_pcur_restore_position(
return(FALSE);
}
/******************************************************************
/**************************************************************//**
If the latch mode of the cursor is BTR_LEAF_SEARCH or BTR_LEAF_MODIFY,
releases the page latch and bufferfix reserved by the cursor.
NOTE! In the case of BTR_LEAF_MODIFY, there should not exist changes
......@@ -376,7 +377,7 @@ btr_pcur_release_leaf(
cursor->pos_state = BTR_PCUR_WAS_POSITIONED;
}
/*************************************************************
/*********************************************************//**
Moves the persistent cursor to the first record on the next page. Releases the
latch on the current page, and bufferunfixes it. Note that there must not be
modifications on the current page, as then the x-latch can be released only in
......@@ -427,7 +428,7 @@ btr_pcur_move_to_next_page(
page_check_dir(next_page);
}
/*************************************************************
/*********************************************************//**
Moves the persistent cursor backward if it is on the first record of the page.
Commits mtr. Note that to prevent a possible deadlock, the operation
first stores the position of the cursor, commits mtr, acquires the necessary
......@@ -509,7 +510,7 @@ btr_pcur_move_backward_from_page(
cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
}
/*************************************************************
/*********************************************************//**
Moves the persistent cursor to the previous record in the tree. If no records
are left, the cursor stays 'before first in tree'.
@return TRUE if the cursor was not before first in tree */
......@@ -543,7 +544,7 @@ btr_pcur_move_to_prev(
return(TRUE);
}
/******************************************************************
/**************************************************************//**
If mode is PAGE_CUR_G or PAGE_CUR_GE, opens a persistent cursor on the first
user record satisfying the search condition, in the case PAGE_CUR_L or
PAGE_CUR_LE, on the last user record. If no such user record exists, then
......
......@@ -23,7 +23,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/************************************************************************
/********************************************************************//**
@file btr/btr0sea.c
The index tree adaptive search
Created 2/17/1996 Heikki Tuuri
......@@ -88,7 +89,7 @@ before hash index building is started */
#define BTR_SEARCH_BUILD_LIMIT 100
/************************************************************************
/********************************************************************//**
Builds a hash index on a page with the given parameters. If the page already
has a hash index with different parameters, the old hash index is removed.
If index is non-NULL, this function checks if n_fields and n_bytes are
......@@ -105,7 +106,7 @@ btr_search_build_page_hash_index(
field */
ibool left_side);/*!< in: hash for searches from left side? */
/*********************************************************************
/*****************************************************************//**
This function should be called before reserving any btr search mutex, if
the intended operation might add nodes to the search system hash table.
Because of the latching order, once we have reserved the btr search system
......@@ -151,7 +152,7 @@ btr_search_check_free_space_in_heap(void)
}
}
/*********************************************************************
/*****************************************************************//**
Creates and initializes the adaptive search system at a database start. */
UNIV_INTERN
void
......@@ -172,7 +173,7 @@ btr_search_sys_create(
btr_search_sys->hash_index = ha_create(hash_size, 0, 0);
}
/************************************************************************
/********************************************************************//**
Disable the adaptive hash search system and empty the index. */
UNIV_INTERN
void
......@@ -195,7 +196,7 @@ btr_search_disable(void)
mutex_exit(&btr_search_enabled_mutex);
}
/************************************************************************
/********************************************************************//**
Enable the adaptive hash search system. */
UNIV_INTERN
void
......@@ -211,7 +212,7 @@ btr_search_enable(void)
mutex_exit(&btr_search_enabled_mutex);
}
/*********************************************************************
/*****************************************************************//**
Creates and initializes a search info struct.
@return own: search info struct */
UNIV_INTERN
......@@ -252,7 +253,7 @@ btr_search_info_create(
return(info);
}
/*********************************************************************
/*****************************************************************//**
Returns the value of ref_count. The value is protected by
btr_search_latch.
@return ref_count value. */
......@@ -278,7 +279,7 @@ btr_search_info_get_ref_count(
return(ret);
}
/*************************************************************************
/*********************************************************************//**
Updates the search info of an index about hash successes. NOTE that info
is NOT protected by any semaphore, to save CPU time! Do not assume its fields
are consistent. */
......@@ -398,7 +399,7 @@ btr_search_info_update_hash(
}
}
/*************************************************************************
/*********************************************************************//**
Updates the block search info on hash successes. NOTE that info and
block->n_hash_helps, n_fields, n_bytes, side are NOT protected by any
semaphore, to save CPU time! Do not assume the fields are consistent.
......@@ -476,7 +477,7 @@ btr_search_update_block_hash_info(
return(FALSE);
}
/*************************************************************************
/*********************************************************************//**
Updates a hash node reference when it has been unsuccessfully used in a
search which could have succeeded with the used hash parameters. This can
happen because when building a hash index for a page, we do not check
......@@ -546,7 +547,7 @@ btr_search_update_hash_ref(
}
}
/*************************************************************************
/*********************************************************************//**
Updates the search info. */
UNIV_INTERN
void
......@@ -623,7 +624,7 @@ btr_search_info_update_slow(
}
}
/**********************************************************************
/******************************************************************//**
Checks if a guessed position for a tree cursor is right. Note that if
mode is PAGE_CUR_LE, which is used in inserts, and the function returns
TRUE, then cursor->up_match and cursor->low_match both have sensible values.
......@@ -769,7 +770,7 @@ btr_search_check_guess(
return(success);
}
/**********************************************************************
/******************************************************************//**
Tries to guess the right search position based on the hash search info
of the index. Note that if mode is PAGE_CUR_LE, which is used in inserts,
and the function returns TRUE, then cursor->up_match and cursor->low_match
......@@ -978,7 +979,7 @@ btr_search_guess_on_hash(
return(FALSE);
}
/************************************************************************
/********************************************************************//**
Drops a page hash index. */
UNIV_INTERN
void
......@@ -1145,7 +1146,7 @@ btr_search_drop_page_hash_index(
mem_free(folds);
}
/************************************************************************
/********************************************************************//**
Drops a page hash index when a page is freed from a fseg to the file system.
Drops possible hash index if the page happens to be in the buffer pool. */
UNIV_INTERN
......@@ -1191,7 +1192,7 @@ btr_search_drop_page_hash_when_freed(
mtr_commit(&mtr);
}
/************************************************************************
/********************************************************************//**
Builds a hash index on a page with the given parameters. If the page already
has a hash index with different parameters, the old hash index is removed.
If index is non-NULL, this function checks if n_fields and n_bytes are
......@@ -1386,7 +1387,7 @@ btr_search_build_page_hash_index(
}
}
/************************************************************************
/********************************************************************//**
Moves or deletes hash entries for moved records. If new_page is already hashed,
then the hash index for page, if any, is dropped. If new_page is not hashed,
and page is hashed, then a new hash index is built to new_page with the same
......@@ -1452,7 +1453,7 @@ btr_search_move_or_delete_hash_entries(
rw_lock_s_unlock(&btr_search_latch);
}
/************************************************************************
/********************************************************************//**
Updates the page hash index when a single record is deleted from a page. */
UNIV_INTERN
void
......@@ -1505,7 +1506,7 @@ btr_search_update_hash_on_delete(
rw_lock_x_unlock(&btr_search_latch);
}
/************************************************************************
/********************************************************************//**
Updates the page hash index when a single record is inserted on a page. */
UNIV_INTERN
void
......@@ -1556,7 +1557,7 @@ btr_search_update_hash_node_on_insert(
}
}
/************************************************************************
/********************************************************************//**
Updates the page hash index when a single record is inserted on a page. */
UNIV_INTERN
void
......@@ -1706,7 +1707,7 @@ btr_search_update_hash_on_insert(
}
}
/************************************************************************
/********************************************************************//**
Validates the search system.
@return TRUE if ok */
UNIV_INTERN
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file buf/buf0buddy.c
Binary buddy allocator for compressed pages
Created December 2006 by Marko Makela
......@@ -44,7 +45,7 @@ static ulint buf_buddy_n_frames;
Protected by buf_pool_mutex. */
UNIV_INTERN buf_buddy_stat_t buf_buddy_stat[BUF_BUDDY_SIZES + 1];
/**************************************************************************
/**********************************************************************//**
Get the offset of the buddy of a compressed page frame.
@return the buddy relative of page */
UNIV_INLINE
......@@ -66,7 +67,7 @@ buf_buddy_get(
}
}
/**************************************************************************
/**********************************************************************//**
Add a block to the head of the appropriate buddy free list. */
UNIV_INLINE
void
......@@ -92,7 +93,7 @@ buf_buddy_add_to_free(
#endif /* UNIV_DEBUG_VALGRIND */
}
/**************************************************************************
/**********************************************************************//**
Remove a block from the appropriate buddy free list. */
UNIV_INLINE
void
......@@ -122,7 +123,7 @@ buf_buddy_remove_from_free(
#endif /* UNIV_DEBUG_VALGRIND */
}
/**************************************************************************
/**********************************************************************//**
Try to allocate a block from buf_pool->zip_free[].
@return allocated block, or NULL if buf_pool->zip_free[] was empty */
static
......@@ -175,7 +176,7 @@ buf_buddy_alloc_zip(
return(bpage);
}
/**************************************************************************
/**********************************************************************//**
Deallocate a buffer frame of UNIV_PAGE_SIZE. */
static
void
......@@ -214,7 +215,7 @@ buf_buddy_block_free(
ut_d(buf_buddy_n_frames--);
}
/**************************************************************************
/**********************************************************************//**
Allocate a buffer block to the buddy allocator. */
static
void
......@@ -240,7 +241,7 @@ buf_buddy_block_register(
ut_d(buf_buddy_n_frames++);
}
/**************************************************************************
/**********************************************************************//**
Allocate a block from a bigger object.
@return allocated block */
static
......@@ -280,7 +281,7 @@ buf_buddy_alloc_from(
return(buf);
}
/**************************************************************************
/**********************************************************************//**
Allocate a block. The thread calling this function must hold
buf_pool_mutex and must not hold buf_pool_zip_mutex or any block->mutex.
The buf_pool_mutex may only be released and reacquired if lru != NULL.
......@@ -340,7 +341,7 @@ buf_buddy_alloc_low(
return(block);
}
/**************************************************************************
/**********************************************************************//**
Try to relocate the control block of a compressed page.
@return TRUE if relocated */
static
......@@ -394,7 +395,7 @@ buf_buddy_relocate_block(
return(TRUE);
}
/**************************************************************************
/**********************************************************************//**
Try to relocate a block.
@return TRUE if relocated */
static
......@@ -502,7 +503,7 @@ buf_buddy_relocate(
return(FALSE);
}
/**************************************************************************
/**********************************************************************//**
Deallocate a block. */
UNIV_INTERN
void
......
This diff is collapsed.
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file buf/buf0flu.c
The database buffer buf_pool flush algorithm
Created 11/11/1995 Heikki Tuuri
......@@ -44,7 +45,7 @@ Created 11/11/1995 Heikki Tuuri
#include "trx0sys.h"
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
/**********************************************************************
/******************************************************************//**
Validates the flush list.
@return TRUE if ok */
static
......@@ -53,7 +54,7 @@ buf_flush_validate_low(void);
/*========================*/
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
/************************************************************************
/********************************************************************//**
Inserts a modified block into the flush list. */
UNIV_INTERN
void
......@@ -79,7 +80,7 @@ buf_flush_insert_into_flush_list(
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
}
/************************************************************************
/********************************************************************//**
Inserts a modified block into the flush list in the right sorted position.
This function is used by recovery, because there the modifications do not
necessarily come in the order of lsn's. */
......@@ -122,7 +123,7 @@ buf_flush_insert_sorted_into_flush_list(
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
}
/************************************************************************
/********************************************************************//**
Returns TRUE if the file page block is immediately suitable for replacement,
i.e., the transition FILE_PAGE => NOT_USED allowed.
@return TRUE if can replace immediately */
......@@ -155,7 +156,7 @@ buf_flush_ready_for_replace(
return(FALSE);
}
/************************************************************************
/********************************************************************//**
Returns TRUE if the block is modified and ready for flushing.
@return TRUE if can flush immediately */
UNIV_INLINE
......@@ -192,7 +193,7 @@ buf_flush_ready_for_flush(
return(FALSE);
}
/************************************************************************
/********************************************************************//**
Remove a block from the flush list of modified blocks. */
UNIV_INTERN
void
......@@ -231,7 +232,7 @@ buf_flush_remove(
ut_ad(ut_list_node_313->in_flush_list)));
}
/************************************************************************
/********************************************************************//**
Updates the flush system data structures when a write is completed. */
UNIV_INTERN
void
......@@ -269,7 +270,7 @@ buf_flush_write_complete(
}
}
/************************************************************************
/********************************************************************//**
Flushes possible buffered writes from the doublewrite memory buffer to disk,
and also wakes up the aio thread if simulated aio is used. It is very
important to call this function after a batch of writes has been posted,
......@@ -516,7 +517,7 @@ buf_flush_buffered_writes(void)
mutex_exit(&(trx_doublewrite->mutex));
}
/************************************************************************
/********************************************************************//**
Posts a buffer page for writing. If the doublewrite memory buffer is
full, calls buf_flush_buffered_writes and waits for for free space to
appear. */
......@@ -576,7 +577,7 @@ buf_flush_post_to_doublewrite_buf(
}
#endif /* !UNIV_HOTBACKUP */
/************************************************************************
/********************************************************************//**
Initializes a page for writing to the tablespace. */
UNIV_INTERN
void
......@@ -655,7 +656,7 @@ buf_flush_init_for_writing(
}
#ifndef UNIV_HOTBACKUP
/************************************************************************
/********************************************************************//**
Does an asynchronous write of a buffer page. NOTE: in simulated aio and
also when the doublewrite buffer is used, we must call
buf_flush_buffered_writes after we have posted a batch of writes! */
......@@ -743,7 +744,7 @@ buf_flush_write_block_low(
}
}
/************************************************************************
/********************************************************************//**
Writes a flushable page asynchronously from the buffer pool to a file.
NOTE: in simulated aio we must call
os_aio_simulated_wake_handler_threads after we have posted a batch of
......@@ -857,7 +858,7 @@ buf_flush_page(
buf_flush_write_block_low(bpage);
}
/***************************************************************
/***********************************************************//**
Flushes to disk all flushable pages within the flush area.
@return number of pages flushed */
static
......@@ -948,7 +949,7 @@ buf_flush_try_neighbors(
return(count);
}
/***********************************************************************
/*******************************************************************//**
This utility flushes dirty blocks from the end of the LRU list or flush_list.
NOTE 1: in the case of an LRU flush the calling thread may own latches to
pages: to avoid deadlocks, this function must be written so that it cannot
......@@ -1104,7 +1105,7 @@ buf_flush_batch(
return(page_count);
}
/**********************************************************************
/******************************************************************//**
Waits until a flush batch of the given type ends */
UNIV_INTERN
void
......@@ -1117,7 +1118,7 @@ buf_flush_wait_batch_end(
os_event_wait(buf_pool->no_flush[type]);
}
/**********************************************************************
/******************************************************************//**
Gives a recommendation of how many blocks should be flushed to establish
a big enough margin of replaceable blocks near the end of the LRU list
and in the free list.
......@@ -1169,7 +1170,7 @@ buf_flush_LRU_recommendation(void)
- n_replaceable);
}
/*************************************************************************
/*********************************************************************//**
Flushes pages from the end of the LRU list if there is too small a margin
of replaceable pages there or in the free list. VERY IMPORTANT: this function
is called also by threads which have locks on pages. To avoid deadlocks, we
......@@ -1197,7 +1198,7 @@ buf_flush_free_margin(void)
}
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
/**********************************************************************
/******************************************************************//**
Validates the flush list.
@return TRUE if ok */
static
......@@ -1226,7 +1227,7 @@ buf_flush_validate_low(void)
return(TRUE);
}
/**********************************************************************
/******************************************************************//**
Validates the flush list.
@return TRUE if ok */
UNIV_INTERN
......
This diff is collapsed.
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file buf/buf0rea.c
The database buffer read
Created 11/5/1995 Heikki Tuuri
......@@ -59,7 +60,7 @@ read-ahead is not done: this is to prevent flooding the buffer pool with
i/o-fixed buffer blocks */
#define BUF_READ_AHEAD_PEND_LIMIT 2
/************************************************************************
/********************************************************************//**
Low-level function which reads a page asynchronously from a file to the
buffer buf_pool if it is not already there, in which case does nothing.
Sets the io_fix flag and sets an exclusive lock on the buffer frame. The
......@@ -169,7 +170,7 @@ buf_read_page_low(
return(1);
}
/************************************************************************
/********************************************************************//**
Applies a random read-ahead in buf_pool if there are at least a threshold
value of accessed pages from the random read-ahead area. Does not read any
page, not even the one at the position (space, offset), if the read-ahead
......@@ -325,7 +326,7 @@ buf_read_ahead_random(
return(count);
}
/************************************************************************
/********************************************************************//**
High-level function which reads a page asynchronously from a file to the
buffer buf_pool if it is not already there. Sets the io_fix flag and sets
an exclusive lock on the buffer frame. The flag is cleared and the x-lock
......@@ -376,7 +377,7 @@ buf_read_page(
return(count + count2);
}
/************************************************************************
/********************************************************************//**
Applies linear read-ahead if in the buf_pool the page is a border page of
a linear read-ahead area and all the pages in the area have been accessed.
Does not read any page if the read-ahead mechanism is not activated. Note
......@@ -643,7 +644,7 @@ buf_read_ahead_linear(
return(count);
}
/************************************************************************
/********************************************************************//**
Issues read requests for pages which the ibuf module wants to read in, in
order to contract the insert buffer tree. Technically, this function is like
a read-ahead function. */
......@@ -721,7 +722,7 @@ buf_read_ibuf_merge_pages(
#endif /* UNIV_DEBUG */
}
/************************************************************************
/********************************************************************//**
Issues read requests for pages which recovery wants to read in. */
UNIV_INTERN
void
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/************************************************************************
/********************************************************************//**
@file data/data0data.c
SQL data field and tuple
Created 5/30/1994 Heikki Tuuri
......@@ -51,7 +52,7 @@ UNIV_INTERN ulint data_dummy;
#endif /* UNIV_DEBUG */
#ifndef UNIV_HOTBACKUP
/*************************************************************************
/*********************************************************************//**
Tests if dfield data length and content is equal to the given.
@return TRUE if equal */
UNIV_INTERN
......@@ -80,7 +81,7 @@ dfield_data_is_binary_equal(
return(TRUE);
}
/****************************************************************
/************************************************************//**
Compare two data tuples, respecting the collation of character fields.
@return 1, 0 , -1 if tuple1 is greater, equal, less, respectively,
than tuple2 */
......@@ -122,7 +123,7 @@ dtuple_coll_cmp(
return(0);
}
/*************************************************************************
/*********************************************************************//**
Sets number of fields used in a tuple. Normally this is set in
dtuple_create, but if you want later to set it smaller, you can use this. */
UNIV_INTERN
......@@ -138,7 +139,7 @@ dtuple_set_n_fields(
tuple->n_fields_cmp = n_fields;
}
/**************************************************************
/**********************************************************//**
Checks that a data field is typed.
@return TRUE if ok */
static
......@@ -160,7 +161,7 @@ dfield_check_typed_no_assert(
return(TRUE);
}
/**************************************************************
/**********************************************************//**
Checks that a data tuple is typed.
@return TRUE if ok */
UNIV_INTERN
......@@ -198,7 +199,7 @@ dtuple_check_typed_no_assert(
#endif /* !UNIV_HOTBACKUP */
#ifdef UNIV_DEBUG
/**************************************************************
/**********************************************************//**
Checks that a data field is typed. Asserts an error if not.
@return TRUE if ok */
UNIV_INTERN
......@@ -221,7 +222,7 @@ dfield_check_typed(
return(TRUE);
}
/**************************************************************
/**********************************************************//**
Checks that a data tuple is typed. Asserts an error if not.
@return TRUE if ok */
UNIV_INTERN
......@@ -243,7 +244,7 @@ dtuple_check_typed(
return(TRUE);
}
/**************************************************************
/**********************************************************//**
Validates the consistency of a tuple which must be complete, i.e,
all fields must have been set.
@return TRUE if ok */
......@@ -296,7 +297,7 @@ dtuple_validate(
#endif /* UNIV_DEBUG */
#ifndef UNIV_HOTBACKUP
/*****************************************************************
/*************************************************************//**
Pretty prints a dfield value according to its data type. */
UNIV_INTERN
void
......@@ -338,7 +339,7 @@ dfield_print(
}
}
/*****************************************************************
/*************************************************************//**
Pretty prints a dfield value according to its data type. Also the hex string
is printed if a string contains non-printable characters. */
UNIV_INTERN
......@@ -510,7 +511,7 @@ dfield_print_also_hex(
}
}
/*****************************************************************
/*************************************************************//**
Print a dfield value using ut_print_buf. */
static
void
......@@ -533,7 +534,7 @@ dfield_print_raw(
}
}
/**************************************************************
/**********************************************************//**
The following function prints the contents of a tuple. */
UNIV_INTERN
void
......@@ -561,7 +562,7 @@ dtuple_print(
ut_ad(dtuple_validate(tuple));
}
/******************************************************************
/**************************************************************//**
Moves parts of long fields in entry to the big record vector so that
the size of tuple drops below the maximum record size allowed in the
database. Moves data only from those fields which are not necessary
......@@ -722,7 +723,7 @@ dtuple_convert_big_rec(
return(vector);
}
/******************************************************************
/**************************************************************//**
Puts back to entry the data stored in vector. Note that to ensure the
fields in entry can accommodate the data, vector must have been created
from entry with dtuple_convert_big_rec. */
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file data/data0type.c
Data types
Created 1/16/1996 Heikki Tuuri
......@@ -38,7 +39,7 @@ charset-collation code for them. */
UNIV_INTERN ulint data_mysql_default_charset_coll;
/*************************************************************************
/*********************************************************************//**
Determine how many bytes the first n characters of the given string occupy.
If the string is shorter than n characters, returns the number of bytes
the characters in the string occupy.
......@@ -79,7 +80,7 @@ dtype_get_at_most_n_mbchars(
}
#endif /* UNIV_HOTBACKUP */
/*************************************************************************
/*********************************************************************//**
Checks if a data main type is a string type. Also a BLOB is considered a
string type.
@return TRUE if string type */
......@@ -99,7 +100,7 @@ dtype_is_string_type(
return(FALSE);
}
/*************************************************************************
/*********************************************************************//**
Checks if a type is a binary string type. Note that for tables created with
< 4.0.14, we do not know if a DATA_BLOB column is a BLOB or a TEXT column. For
those DATA_BLOB columns this function currently returns FALSE.
......@@ -121,7 +122,7 @@ dtype_is_binary_string_type(
return(FALSE);
}
/*************************************************************************
/*********************************************************************//**
Checks if a type is a non-binary string type. That is, dtype_is_string_type is
TRUE and dtype_is_binary_string_type is FALSE. Note that for tables created
with < 4.0.14, we do not know if a DATA_BLOB column is a BLOB or a TEXT column.
......@@ -143,7 +144,7 @@ dtype_is_non_binary_string_type(
return(FALSE);
}
/*************************************************************************
/*********************************************************************//**
Forms a precise type from the < 4.1.2 format precise type plus the
charset-collation code. */
UNIV_INTERN
......@@ -160,7 +161,7 @@ dtype_form_prtype(
return(old_prtype + (charset_coll << 16));
}
/*************************************************************************
/*********************************************************************//**
Validates a data type structure.
@return TRUE if ok */
UNIV_INTERN
......@@ -185,7 +186,7 @@ dtype_validate(
}
#ifndef UNIV_HOTBACKUP
/*************************************************************************
/*********************************************************************//**
Prints a data type structure. */
UNIV_INTERN
void
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file dict/dict0boot.c
Data dictionary creation and booting
Created 4/18/1996 Heikki Tuuri
......@@ -39,7 +40,7 @@ Created 4/18/1996 Heikki Tuuri
#include "log0recv.h"
#include "os0file.h"
/**************************************************************************
/**********************************************************************//**
Gets a pointer to the dictionary header and x-latches its page.
@return pointer to the dictionary header, page x-latched */
UNIV_INTERN
......@@ -60,7 +61,7 @@ dict_hdr_get(
return(header);
}
/**************************************************************************
/**********************************************************************//**
Returns a new table, index, or tree id.
@return the new id */
UNIV_INTERN
......@@ -89,7 +90,7 @@ dict_hdr_get_new_id(
return(id);
}
/**************************************************************************
/**********************************************************************//**
Writes the current value of the row id counter to the dictionary header file
page. */
UNIV_INTERN
......@@ -114,7 +115,7 @@ dict_hdr_flush_row_id(void)
mtr_commit(&mtr);
}
/*********************************************************************
/*****************************************************************//**
Creates the file page for the dictionary header. This function is
called only at the database creation.
@return TRUE if succeed */
......@@ -217,7 +218,7 @@ dict_hdr_create(
return(TRUE);
}
/*********************************************************************
/*****************************************************************//**
Initializes the data dictionary memory structures when the database is
started. This function is also called when the data dictionary is created. */
UNIV_INTERN
......@@ -429,7 +430,7 @@ dict_boot(void)
mutex_exit(&(dict_sys->mutex));
}
/*********************************************************************
/*****************************************************************//**
Inserts the basic system table data into themselves in the database
creation. */
static
......@@ -440,7 +441,7 @@ dict_insert_initial_data(void)
/* Does nothing yet */
}
/*********************************************************************
/*****************************************************************//**
Creates and initializes the data dictionary at the database creation. */
UNIV_INTERN
void
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file dict/dict0crea.c
Database object creation
Created 1/8/1996 Heikki Tuuri
......@@ -42,7 +43,7 @@ Created 1/8/1996 Heikki Tuuri
#include "usr0sess.h"
#include "ut0vec.h"
/*********************************************************************
/*****************************************************************//**
Based on a table object, this function builds the entry to be inserted
in the SYS_TABLES system table.
@return the tuple which should be inserted */
......@@ -134,7 +135,7 @@ dict_create_sys_tables_tuple(
return(entry);
}
/*********************************************************************
/*****************************************************************//**
Based on a table object, this function builds the entry to be inserted
in the SYS_COLUMNS system table.
@return the tuple which should be inserted */
......@@ -216,7 +217,7 @@ dict_create_sys_columns_tuple(
return(entry);
}
/*******************************************************************
/***************************************************************//**
Builds a table definition to insert.
@return DB_SUCCESS or error code */
static
......@@ -295,7 +296,7 @@ dict_build_table_def_step(
return(DB_SUCCESS);
}
/*******************************************************************
/***************************************************************//**
Builds a column definition to insert.
@return DB_SUCCESS */
static
......@@ -313,7 +314,7 @@ dict_build_col_def_step(
return(DB_SUCCESS);
}
/*********************************************************************
/*****************************************************************//**
Based on an index object, this function builds the entry to be inserted
in the SYS_INDEXES system table.
@return the tuple which should be inserted */
......@@ -403,7 +404,7 @@ dict_create_sys_indexes_tuple(
return(entry);
}
/*********************************************************************
/*****************************************************************//**
Based on an index object, this function builds the entry to be inserted
in the SYS_FIELDS system table.
@return the tuple which should be inserted */
......@@ -479,7 +480,7 @@ dict_create_sys_fields_tuple(
return(entry);
}
/*********************************************************************
/*****************************************************************//**
Creates the tuple with which the index entry is searched for writing the index
tree root page number, if such a tree is created.
@return the tuple for search */
......@@ -515,7 +516,7 @@ dict_create_search_tuple(
return(search_tuple);
}
/*******************************************************************
/***************************************************************//**
Builds an index definition row to insert.
@return DB_SUCCESS or error code */
static
......@@ -567,7 +568,7 @@ dict_build_index_def_step(
return(DB_SUCCESS);
}
/*******************************************************************
/***************************************************************//**
Builds a field definition row to insert.
@return DB_SUCCESS */
static
......@@ -588,7 +589,7 @@ dict_build_field_def_step(
return(DB_SUCCESS);
}
/*******************************************************************
/***************************************************************//**
Creates an index tree for the index if it is not a member of a cluster.
@return DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
static
......@@ -645,7 +646,7 @@ dict_create_index_tree_step(
return(DB_SUCCESS);
}
/***********************************************************************
/*******************************************************************//**
Drops the index tree associated with a row in SYS_INDEXES table. */
UNIV_INTERN
void
......@@ -708,7 +709,7 @@ dict_drop_index_tree(
FIL_NULL, mtr);
}
/***********************************************************************
/*******************************************************************//**
Truncates the index tree associated with a row in SYS_INDEXES table.
@return new root page number, or FIL_NULL on failure */
UNIV_INTERN
......@@ -843,7 +844,7 @@ dict_truncate_index_tree(
return(FIL_NULL);
}
/*************************************************************************
/*********************************************************************//**
Creates a table create graph.
@return own: table create node */
UNIV_INTERN
......@@ -879,7 +880,7 @@ tab_create_graph_create(
return(node);
}
/*************************************************************************
/*********************************************************************//**
Creates an index create graph.
@return own: index create node */
UNIV_INTERN
......@@ -916,7 +917,7 @@ ind_create_graph_create(
return(node);
}
/***************************************************************
/***********************************************************//**
Creates a table. This is a high-level function used in SQL execution graphs.
@return query thread to run next or NULL */
UNIV_INTERN
......@@ -1022,7 +1023,7 @@ dict_create_table_step(
return(thr);
}
/***************************************************************
/***********************************************************//**
Creates an index. This is a high-level function used in SQL execution
graphs.
@return query thread to run next or NULL */
......@@ -1153,7 +1154,7 @@ dict_create_index_step(
return(thr);
}
/********************************************************************
/****************************************************************//**
Creates the foreign key constraints system tables inside InnoDB
at database creation or database start if they are not found or are
not of the right form.
......@@ -1274,7 +1275,7 @@ dict_create_or_check_foreign_constraint_tables(void)
return(error);
}
/********************************************************************
/****************************************************************//**
Evaluate the given foreign key SQL statement.
@return error code or DB_SUCCESS */
static
......@@ -1339,7 +1340,7 @@ dict_foreign_eval_sql(
return(DB_SUCCESS);
}
/************************************************************************
/********************************************************************//**
Add a single foreign key field definition to the data dictionary tables in
the database.
@return error code or DB_SUCCESS */
......@@ -1374,7 +1375,7 @@ dict_create_add_foreign_field_to_dictionary(
table, foreign, trx));
}
/************************************************************************
/********************************************************************//**
Add a single foreign key definition to the data dictionary tables in the
database. We also generate names to constraints that were not named by the
user. A generated constraint has a name of the format
......@@ -1449,7 +1450,7 @@ dict_create_add_foreign_to_dictionary(
return(error);
}
/************************************************************************
/********************************************************************//**
Adds foreign key definitions to data dictionary tables in the database.
@return error code or DB_SUCCESS */
UNIV_INTERN
......
This diff is collapsed.
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file dict/dict0load.c
Loads to the memory cache database object definitions
from dictionary tables
......@@ -40,7 +41,7 @@ Created 4/24/1996 Heikki Tuuri
#include "srv0start.h"
#include "srv0srv.h"
/********************************************************************
/****************************************************************//**
Compare the name of an index column.
@return TRUE if the i'th column of index is 'name'. */
static
......@@ -59,7 +60,7 @@ name_of_col_is(
return(strcmp(name, dict_table_get_col_name(table, tmp)) == 0);
}
/************************************************************************
/********************************************************************//**
Finds the first table name in the given database.
@return own: table name, NULL if does not exist; the caller must free
the memory in the string! */
......@@ -142,7 +143,7 @@ dict_get_first_table_name_in_db(
goto loop;
}
/************************************************************************
/********************************************************************//**
Prints to the standard output information on all tables found in the data
dictionary system table. */
UNIV_INTERN
......@@ -235,7 +236,7 @@ dict_print(void)
goto loop;
}
/************************************************************************
/********************************************************************//**
Determine the flags of a table described in SYS_TABLES.
@return compressed page size in kilobytes; or 0 if the tablespace is
uncompressed, ULINT_UNDEFINED on error */
......@@ -297,7 +298,7 @@ dict_sys_tables_get_flags(
return(flags);
}
/************************************************************************
/********************************************************************//**
In a crash recovery we already have all the tablespace objects created.
This function compares the space id information in the InnoDB data dictionary
to what we already read with fil_load_single_table_tablespaces().
......@@ -419,7 +420,7 @@ dict_check_tablespaces_and_store_max_id(
goto loop;
}
/************************************************************************
/********************************************************************//**
Loads definitions for table columns. */
static
void
......@@ -525,7 +526,7 @@ dict_load_columns(
mtr_commit(&mtr);
}
/************************************************************************
/********************************************************************//**
Loads definitions for index fields. */
static
void
......@@ -626,7 +627,7 @@ dict_load_fields(
mtr_commit(&mtr);
}
/************************************************************************
/********************************************************************//**
Loads definitions for table indexes. Adds them to the data dictionary
cache.
@return DB_SUCCESS if ok, DB_CORRUPTION if corruption of dictionary
......@@ -799,7 +800,7 @@ dict_load_indexes(
return(error);
}
/************************************************************************
/********************************************************************//**
Loads a table definition and also all its index definitions, and also
the cluster definition if the table is a member in a cluster. Also loads
all foreign key constraints where the foreign key is in the table or where
......@@ -992,7 +993,7 @@ dict_load_table(
return(table);
}
/***************************************************************************
/***********************************************************************//**
Loads a table object based on the table id.
@return table; NULL if table does not exist */
UNIV_INTERN
......@@ -1083,7 +1084,7 @@ dict_load_table_on_id(
return(table);
}
/************************************************************************
/********************************************************************//**
This function is called when the database is booted. Loads system table
index definitions except for the clustered index which is added to the
dictionary cache at booting before calling this function. */
......@@ -1104,7 +1105,7 @@ dict_load_sys_table(
mem_heap_free(heap);
}
/************************************************************************
/********************************************************************//**
Loads foreign key constraint col names (also for the referenced table). */
static
void
......@@ -1176,7 +1177,7 @@ dict_load_foreign_cols(
mtr_commit(&mtr);
}
/***************************************************************************
/***********************************************************************//**
Loads a foreign key constraint to the dictionary cache.
@return DB_SUCCESS or error code */
static
......@@ -1301,7 +1302,7 @@ dict_load_foreign(
return(dict_foreign_add_to_cache(foreign, check_charsets));
}
/***************************************************************************
/***********************************************************************//**
Loads foreign key constraints where the table is either the foreign key
holder or where the table is referenced by a foreign key. Adds these
constraints to the data dictionary. Note that we know that the dictionary
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/**********************************************************************
/******************************************************************//**
@file dict/dict0mem.c
Data dictionary memory object creation
Created 1/8/1996 Heikki Tuuri
......@@ -39,7 +40,7 @@ Created 1/8/1996 Heikki Tuuri
#define DICT_HEAP_SIZE 100 /* initial memory heap size when
creating a table or index object */
/**************************************************************************
/**********************************************************************//**
Creates a table memory object.
@return own: table object */
UNIV_INTERN
......@@ -90,7 +91,7 @@ dict_mem_table_create(
return(table);
}
/********************************************************************
/****************************************************************//**
Free a table memory object. */
UNIV_INTERN
void
......@@ -106,7 +107,7 @@ dict_mem_table_free(
mem_heap_free(table->heap);
}
/********************************************************************
/****************************************************************//**
Append 'name' to 'col_names' (@see dict_table_t::col_names).
@return new column names array */
static
......@@ -154,7 +155,7 @@ dict_add_col_name(
return(res);
}
/**************************************************************************
/**********************************************************************//**
Adds a column definition to a table. */
UNIV_INTERN
void
......@@ -211,7 +212,7 @@ dict_mem_table_add_col(
#endif /* !UNIV_HOTBACKUP */
}
/**************************************************************************
/**********************************************************************//**
Creates an index memory object.
@return own: index object */
UNIV_INTERN
......@@ -254,7 +255,7 @@ dict_mem_index_create(
return(index);
}
/**************************************************************************
/**********************************************************************//**
Creates and initializes a foreign constraint memory object.
@return own: foreign constraint struct */
UNIV_INTERN
......@@ -274,7 +275,7 @@ dict_mem_foreign_create(void)
return(foreign);
}
/**************************************************************************
/**********************************************************************//**
Adds a field definition to an index. NOTE: does not take a copy
of the column name if the field is a column. The memory occupied
by the column name may be released only after publishing the index. */
......@@ -301,7 +302,7 @@ dict_mem_index_add_field(
field->prefix_len = (unsigned int) prefix_len;
}
/**************************************************************************
/**********************************************************************//**
Frees an index memory object. */
UNIV_INTERN
void
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file dyn/dyn0dyn.c
The dynamically allocated array
Created 2/5/1996 Heikki Tuuri
......@@ -27,7 +28,7 @@ Created 2/5/1996 Heikki Tuuri
#include "dyn0dyn.ic"
#endif
/****************************************************************
/************************************************************//**
Adds a new block to a dyn array.
@return created block */
UNIV_INTERN
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file eval/eval0eval.c
SQL evaluator: evaluates simple data structures, like expressions, in
a query graph
......@@ -40,7 +41,7 @@ the function below */
static byte eval_dummy;
/*********************************************************************
/*****************************************************************//**
Allocate a buffer from global dynamic memory for a value of a que_node.
NOTE that this memory must be explicitly freed when the query graph is
freed. If the node already has an allocated buffer, that buffer is freed
......@@ -83,7 +84,7 @@ eval_node_alloc_val_buf(
return(data);
}
/*********************************************************************
/*****************************************************************//**
Free the buffer from global dynamic memory for a value of a que_node,
if it has been allocated in the above function. The freeing for pushed
column values is done in sel_col_prefetch_buf_free. */
......@@ -110,7 +111,7 @@ eval_node_free_val_buf(
}
}
/*********************************************************************
/*****************************************************************//**
Evaluates a comparison node.
@return the result of the comparison */
UNIV_INTERN
......@@ -169,7 +170,7 @@ eval_cmp(
return(val);
}
/*********************************************************************
/*****************************************************************//**
Evaluates a logical operation node. */
UNIV_INLINE
void
......@@ -210,7 +211,7 @@ eval_logical(
eval_node_set_ibool_val(logical_node, val);
}
/*********************************************************************
/*****************************************************************//**
Evaluates an arithmetic operation node. */
UNIV_INLINE
void
......@@ -254,7 +255,7 @@ eval_arith(
eval_node_set_int_val(arith_node, val);
}
/*********************************************************************
/*****************************************************************//**
Evaluates an aggregate operation node. */
UNIV_INLINE
void
......@@ -288,7 +289,7 @@ eval_aggregate(
eval_node_set_int_val(node, val);
}
/*********************************************************************
/*****************************************************************//**
Evaluates a predefined function node where the function is not relevant
in benchmarks. */
static
......@@ -375,7 +376,7 @@ eval_predefined_2(
}
}
/*********************************************************************
/*****************************************************************//**
Evaluates a notfound-function node. */
UNIV_INLINE
void
......@@ -417,7 +418,7 @@ eval_notfound(
eval_node_set_ibool_val(func_node, ibool_val);
}
/*********************************************************************
/*****************************************************************//**
Evaluates a substr-function node. */
UNIV_INLINE
void
......@@ -450,7 +451,7 @@ eval_substr(
dfield_set_data(dfield, str1 + len1, len2);
}
/*********************************************************************
/*****************************************************************//**
Evaluates a replstr-procedure node. */
static
void
......@@ -490,7 +491,7 @@ eval_replstr(
ut_memcpy(str1 + len1, str2, len2);
}
/*********************************************************************
/*****************************************************************//**
Evaluates an instr-function node. */
static
void
......@@ -562,7 +563,7 @@ eval_instr(
eval_node_set_int_val(func_node, int_val);
}
/*********************************************************************
/*****************************************************************//**
Evaluates a predefined function node. */
UNIV_INLINE
void
......@@ -600,7 +601,7 @@ eval_binary_to_number(
eval_node_copy_and_alloc_val(func_node, str2, 4);
}
/*********************************************************************
/*****************************************************************//**
Evaluates a predefined function node. */
static
void
......@@ -642,7 +643,7 @@ eval_concat(
}
}
/*********************************************************************
/*****************************************************************//**
Evaluates a predefined function node. If the first argument is an integer,
this function looks at the second argument which is the integer length in
bytes, and converts the integer to a VARCHAR.
......@@ -690,7 +691,7 @@ eval_to_binary(
dfield_set_data(dfield, str1 + (4 - len1), len1);
}
/*********************************************************************
/*****************************************************************//**
Evaluates a predefined function node. */
UNIV_INLINE
void
......@@ -782,7 +783,7 @@ eval_predefined(
eval_node_set_int_val(func_node, int_val);
}
/*********************************************************************
/*****************************************************************//**
Evaluates a function node. */
UNIV_INTERN
void
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file eval/eval0proc.c
Executes SQL stored procedures and their control structures
Created 1/20/1998 Heikki Tuuri
......@@ -28,7 +29,7 @@ Created 1/20/1998 Heikki Tuuri
#include "eval0proc.ic"
#endif
/**************************************************************************
/**********************************************************************//**
Performs an execution step of an if-statement node.
@return query thread to run next or NULL */
UNIV_INTERN
......@@ -104,7 +105,7 @@ if_step(
return(thr);
}
/**************************************************************************
/**********************************************************************//**
Performs an execution step of a while-statement node.
@return query thread to run next or NULL */
UNIV_INTERN
......@@ -140,7 +141,7 @@ while_step(
return(thr);
}
/**************************************************************************
/**********************************************************************//**
Performs an execution step of an assignment statement node.
@return query thread to run next or NULL */
UNIV_INTERN
......@@ -167,7 +168,7 @@ assign_step(
return(thr);
}
/**************************************************************************
/**********************************************************************//**
Performs an execution step of a for-loop node.
@return query thread to run next or NULL */
UNIV_INTERN
......@@ -229,7 +230,7 @@ for_step(
return(thr);
}
/**************************************************************************
/**********************************************************************//**
Performs an execution step of an exit statement node.
@return query thread to run next or NULL */
UNIV_INTERN
......@@ -261,7 +262,7 @@ exit_step(
return(thr);
}
/**************************************************************************
/**********************************************************************//**
Performs an execution step of a return-statement node.
@return query thread to run next or NULL */
UNIV_INTERN
......
This diff is collapsed.
This diff is collapsed.
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/**********************************************************************
/******************************************************************//**
@file fut/fut0fut.c
File-based utilities
Created 12/13/1995 Heikki Tuuri
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/**********************************************************************
/******************************************************************//**
@file fut/fut0lst.c
File-based list utilities
Created 11/28/1995 Heikki Tuuri
......@@ -31,7 +32,7 @@ Created 11/28/1995 Heikki Tuuri
#include "buf0buf.h"
#include "page0page.h"
/************************************************************************
/********************************************************************//**
Adds a node to an empty list. */
static
void
......@@ -67,7 +68,7 @@ flst_add_to_empty(
mlog_write_ulint(base + FLST_LEN, len + 1, MLOG_4BYTES, mtr);
}
/************************************************************************
/********************************************************************//**
Adds a node as the last node in a list. */
UNIV_INTERN
void
......@@ -110,7 +111,7 @@ flst_add_last(
}
}
/************************************************************************
/********************************************************************//**
Adds a node as the first node in a list. */
UNIV_INTERN
void
......@@ -153,7 +154,7 @@ flst_add_first(
}
}
/************************************************************************
/********************************************************************//**
Inserts a node after another in a list. */
UNIV_INTERN
void
......@@ -208,7 +209,7 @@ flst_insert_after(
mlog_write_ulint(base + FLST_LEN, len + 1, MLOG_4BYTES, mtr);
}
/************************************************************************
/********************************************************************//**
Inserts a node before another in a list. */
UNIV_INTERN
void
......@@ -262,7 +263,7 @@ flst_insert_before(
mlog_write_ulint(base + FLST_LEN, len + 1, MLOG_4BYTES, mtr);
}
/************************************************************************
/********************************************************************//**
Removes a node. */
UNIV_INTERN
void
......@@ -337,7 +338,7 @@ flst_remove(
mlog_write_ulint(base + FLST_LEN, len - 1, MLOG_4BYTES, mtr);
}
/************************************************************************
/********************************************************************//**
Cuts off the tail of the list, including the node given. The number of
nodes which will be removed must be provided by the caller, as this function
does not measure the length of the tail. */
......@@ -394,7 +395,7 @@ flst_cut_end(
mlog_write_ulint(base + FLST_LEN, len - n_nodes, MLOG_4BYTES, mtr);
}
/************************************************************************
/********************************************************************//**
Cuts off the tail of the list, not including the given node. The number of
nodes which will be removed must be provided by the caller, as this function
does not measure the length of the tail. */
......@@ -435,7 +436,7 @@ flst_truncate_end(
mlog_write_ulint(base + FLST_LEN, len - n_nodes, MLOG_4BYTES, mtr);
}
/************************************************************************
/********************************************************************//**
Validates a file-based list.
@return TRUE if ok */
UNIV_INTERN
......@@ -502,7 +503,7 @@ flst_validate(
return(TRUE);
}
/************************************************************************
/********************************************************************//**
Prints info of a file-based list. */
UNIV_INTERN
void
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/************************************************************************
/********************************************************************//**
@file ha/ha0ha.c
The hash table with external chains
Created 8/22/1994 Heikki Tuuri
......@@ -35,7 +36,7 @@ Created 8/22/1994 Heikki Tuuri
#endif /* UNIV_SYNC_DEBUG */
#include "page0page.h"
/*****************************************************************
/*************************************************************//**
Creates a hash table with >= n array cells. The actual number of cells is
chosen to be a prime number slightly bigger than n.
@return own: created table */
......@@ -88,7 +89,7 @@ ha_create_func(
return(table);
}
/*****************************************************************
/*************************************************************//**
Empties a hash table and frees the memory heaps. */
UNIV_INTERN
void
......@@ -120,7 +121,7 @@ ha_clear(
}
}
/*****************************************************************
/*************************************************************//**
Inserts an entry into a hash table. If an entry with the same fold number
is found, its node is updated to point to the new data, and no new node
is inserted.
......@@ -226,7 +227,7 @@ ha_insert_for_fold_func(
return(TRUE);
}
/***************************************************************
/***********************************************************//**
Deletes a hash node. */
UNIV_INTERN
void
......@@ -248,7 +249,7 @@ ha_delete_hash_node(
HASH_DELETE_AND_COMPACT(ha_node_t, next, table, del_node);
}
/*****************************************************************
/*************************************************************//**
Deletes an entry from a hash table. */
UNIV_INTERN
void
......@@ -270,7 +271,7 @@ ha_delete(
ha_delete_hash_node(table, node);
}
/*************************************************************
/*********************************************************//**
Looks for an element when we know the pointer to the data, and updates
the pointer to data, if found. */
UNIV_INTERN
......@@ -311,7 +312,7 @@ ha_search_and_update_if_found_func(
}
#ifndef UNIV_HOTBACKUP
/*********************************************************************
/*****************************************************************//**
Removes from the chain determined by fold all nodes whose data pointer
points to the page given. */
UNIV_INTERN
......@@ -357,7 +358,7 @@ ha_remove_all_nodes_to_page(
#endif
}
/*****************************************************************
/*************************************************************//**
Validates a given range of the cells in hash table.
@return TRUE if ok */
UNIV_INTERN
......@@ -402,7 +403,7 @@ ha_validate(
return(ok);
}
/*****************************************************************
/*************************************************************//**
Prints info of a hash table. */
UNIV_INTERN
void
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file ha/ha0storage.c
Hash storage.
Provides a data structure that stores chunks of data in
its own storage, avoiding duplicates.
......@@ -34,7 +35,7 @@ Created September 22, 2007 Vasil Dimov
#include "ha0storage.ic"
#endif
/***********************************************************************
/*******************************************************************//**
Retrieves a data from a storage. If it is present, a pointer to the
stored copy of data is returned, otherwise NULL is returned. */
static
......@@ -73,7 +74,7 @@ ha_storage_get(
return(node->data);
}
/***********************************************************************
/*******************************************************************//**
Copies data into the storage and returns a pointer to the copy. If the
same data chunk is already present, then pointer to it is returned.
Data chunks are considered to be equal if len1 == len2 and
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file ha/hash0hash.c
The simple hash table utility
Created 5/20/1997 Heikki Tuuri
......@@ -30,7 +31,7 @@ Created 5/20/1997 Heikki Tuuri
#include "mem0mem.h"
#ifndef UNIV_HOTBACKUP
/****************************************************************
/************************************************************//**
Reserves the mutex for a fold value in a hash table. */
UNIV_INTERN
void
......@@ -42,7 +43,7 @@ hash_mutex_enter(
mutex_enter(hash_get_mutex(table, fold));
}
/****************************************************************
/************************************************************//**
Releases the mutex for a fold value in a hash table. */
UNIV_INTERN
void
......@@ -54,7 +55,7 @@ hash_mutex_exit(
mutex_exit(hash_get_mutex(table, fold));
}
/****************************************************************
/************************************************************//**
Reserves all the mutexes of a hash table, in an ascending order. */
UNIV_INTERN
void
......@@ -70,7 +71,7 @@ hash_mutex_enter_all(
}
}
/****************************************************************
/************************************************************//**
Releases all the mutexes of a hash table. */
UNIV_INTERN
void
......@@ -87,7 +88,7 @@ hash_mutex_exit_all(
}
#endif /* !UNIV_HOTBACKUP */
/*****************************************************************
/*************************************************************//**
Creates a hash table with >= n array cells. The actual number of cells is
chosen to be a prime number slightly bigger than n.
@return own: created table */
......@@ -126,7 +127,7 @@ hash_create(
return(table);
}
/*****************************************************************
/*************************************************************//**
Frees a hash table. */
UNIV_INTERN
void
......@@ -143,7 +144,7 @@ hash_table_free(
}
#ifndef UNIV_HOTBACKUP
/*****************************************************************
/*************************************************************//**
Creates a mutex array to protect a hash table. */
UNIV_INTERN
void
......
This diff is collapsed.
......@@ -252,7 +252,8 @@ void thd_mark_transaction_to_rollback(MYSQL_THD thd, bool all);
}
typedef struct trx_struct trx_t;
/************************************************************************
/********************************************************************//**
@file handler/ha_innodb.h
Converts an InnoDB error code to a MySQL error code and also tells to MySQL
about a possible transaction rollback inside InnoDB caused by a lock wait
timeout or a deadlock.
......@@ -265,7 +266,7 @@ convert_error_code_to_mysql(
ulint flags, /*!< in: InnoDB table flags, or 0 */
MYSQL_THD thd); /*!< in: user thread handle or NULL */
/*************************************************************************
/*********************************************************************//**
Allocates an InnoDB transaction for a MySQL handler object.
@return InnoDB transaction handle */
extern "C"
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file handler/handler0alter.cc
Smart ALTER TABLE
*******************************************************/
......@@ -36,7 +37,7 @@ extern "C" {
#include "ha_innodb.h"
#include "handler0vars.h"
/*****************************************************************
/*************************************************************//**
Copies an InnoDB column to a MySQL field. This function is
adapted from row_sel_field_store_in_mysql_format(). */
static
......@@ -122,7 +123,7 @@ innobase_col_to_mysql(
}
}
/*****************************************************************
/*************************************************************//**
Copies an InnoDB record to table->record[0]. */
extern "C" UNIV_INTERN
void
......@@ -172,7 +173,7 @@ innobase_rec_to_mysql(
}
}
/*****************************************************************
/*************************************************************//**
Resets table->record[0]. */
extern "C" UNIV_INTERN
void
......@@ -188,7 +189,7 @@ innobase_rec_reset(
}
}
/**********************************************************************
/******************************************************************//**
Removes the filename encoding of a database and table name. */
static
void
......@@ -222,7 +223,7 @@ innobase_convert_tablename(
}
}
/***********************************************************************
/*******************************************************************//**
This function checks that index keys are sensible.
@return 0 or error number */
static
......@@ -322,7 +323,7 @@ innobase_check_index_keys(
return(0);
}
/***********************************************************************
/*******************************************************************//**
Create index field definition for key part */
static
void
......@@ -364,7 +365,7 @@ innobase_create_index_field_def(
DBUG_VOID_RETURN;
}
/***********************************************************************
/*******************************************************************//**
Create index definition for key */
static
void
......@@ -418,7 +419,7 @@ innobase_create_index_def(
DBUG_VOID_RETURN;
}
/***********************************************************************
/*******************************************************************//**
Copy index field definition */
static
void
......@@ -437,7 +438,7 @@ innobase_copy_index_field_def(
DBUG_VOID_RETURN;
}
/***********************************************************************
/*******************************************************************//**
Copy index definition for the index */
static
void
......@@ -475,7 +476,7 @@ innobase_copy_index_def(
DBUG_VOID_RETURN;
}
/***********************************************************************
/*******************************************************************//**
Create an index table where indexes are ordered as follows:
IF a new primary key is defined for the table THEN
......@@ -582,7 +583,7 @@ innobase_create_key_def(
DBUG_RETURN(indexdefs);
}
/***********************************************************************
/*******************************************************************//**
Create a temporary tablename using query id, thread id, and id
@return temporary tablename */
static
......@@ -607,7 +608,7 @@ innobase_create_temporary_tablename(
return(name);
}
/***********************************************************************
/*******************************************************************//**
Create indexes.
@return 0 or error number */
UNIV_INTERN
......@@ -911,7 +912,7 @@ ha_innobase::add_index(
DBUG_RETURN(error);
}
/***********************************************************************
/*******************************************************************//**
Prepare to drop some indexes of a table.
@return 0 or error number */
UNIV_INTERN
......@@ -1112,7 +1113,7 @@ ha_innobase::prepare_drop_index(
DBUG_RETURN(err);
}
/***********************************************************************
/*******************************************************************//**
Drop the indexes that were passed to a successful prepare_drop_index().
@return 0 or error number */
UNIV_INTERN
......
......@@ -16,12 +16,13 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/***********************************************************************
/*******************************************************************//**
@file handler/handler0vars.h
This file contains accessor functions for dynamic plugin on Windows.
***********************************************************************/
#if defined __WIN__ && defined MYSQL_DYNAMIC_PLUGIN
/***********************************************************************
/*******************************************************************//**
This is a list of externals that can not be resolved by delay loading.
They have to be resolved indirectly via their addresses in the .map file.
All of them are external variables. */
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file handler/i_s.cc
InnoDB INFORMATION SCHEMA tables interface to MySQL.
Created July 18, 2007 Vasil Dimov
......@@ -111,7 +112,7 @@ bool schema_table_store_record(THD *thd, TABLE *table);
void localtime_to_TIME(MYSQL_TIME *to, struct tm *from);
bool check_global_access(THD *thd, ulong want_access);
/***********************************************************************
/*******************************************************************//**
Common function to fill any of the dynamic tables:
INFORMATION_SCHEMA.innodb_trx
INFORMATION_SCHEMA.innodb_locks
......@@ -125,7 +126,7 @@ trx_i_s_common_fill_table(
TABLE_LIST* tables, /*!< in/out: tables to fill */
COND* cond); /*!< in: condition (not used) */
/***********************************************************************
/*******************************************************************//**
Unbind a dynamic INFORMATION_SCHEMA table.
@return 0 on success */
static
......@@ -134,7 +135,7 @@ i_s_common_deinit(
/*==============*/
void* p); /*!< in/out: table schema object */
/***********************************************************************
/*******************************************************************//**
Auxiliary function to store time_t value in MYSQL_TYPE_DATETIME
field.
@return 0 on success */
......@@ -162,7 +163,7 @@ field_store_time_t(
return(field->store_time(&my_time, MYSQL_TIMESTAMP_DATETIME));
}
/***********************************************************************
/*******************************************************************//**
Auxiliary function to store char* value in MYSQL_TYPE_STRING field.
@return 0 on success */
static
......@@ -189,7 +190,7 @@ field_store_string(
return(ret);
}
/***********************************************************************
/*******************************************************************//**
Auxiliary function to store ulint value in MYSQL_TYPE_LONGLONG field.
If the value is ULINT_UNDEFINED then the field it set to NULL.
@return 0 on success */
......@@ -293,7 +294,7 @@ static ST_FIELD_INFO innodb_trx_fields_info[] =
END_OF_ST_FIELD_INFO
};
/***********************************************************************
/*******************************************************************//**
Read data from cache buffer and fill the INFORMATION_SCHEMA.innodb_trx
table with it.
@return 0 on success */
......@@ -378,7 +379,7 @@ fill_innodb_trx_from_cache(
DBUG_RETURN(0);
}
/***********************************************************************
/*******************************************************************//**
Bind the dynamic table INFORMATION_SCHEMA.innodb_trx
@return 0 on success */
static
......@@ -550,7 +551,7 @@ static ST_FIELD_INFO innodb_locks_fields_info[] =
END_OF_ST_FIELD_INFO
};
/***********************************************************************
/*******************************************************************//**
Read data from cache buffer and fill the INFORMATION_SCHEMA.innodb_locks
table with it.
@return 0 on success */
......@@ -658,7 +659,7 @@ fill_innodb_locks_from_cache(
DBUG_RETURN(0);
}
/***********************************************************************
/*******************************************************************//**
Bind the dynamic table INFORMATION_SCHEMA.innodb_locks
@return 0 on success */
static
......@@ -770,7 +771,7 @@ static ST_FIELD_INFO innodb_lock_waits_fields_info[] =
END_OF_ST_FIELD_INFO
};
/***********************************************************************
/*******************************************************************//**
Read data from cache buffer and fill the
INFORMATION_SCHEMA.innodb_lock_waits table with it.
@return 0 on success */
......@@ -841,7 +842,7 @@ fill_innodb_lock_waits_from_cache(
DBUG_RETURN(0);
}
/***********************************************************************
/*******************************************************************//**
Bind the dynamic table INFORMATION_SCHEMA.innodb_lock_waits
@return 0 on success */
static
......@@ -911,7 +912,7 @@ UNIV_INTERN struct st_mysql_plugin i_s_innodb_lock_waits =
STRUCT_FLD(__reserved1, NULL)
};
/***********************************************************************
/*******************************************************************//**
Common function to fill any of the dynamic tables:
INFORMATION_SCHEMA.innodb_trx
INFORMATION_SCHEMA.innodb_locks
......@@ -1072,7 +1073,7 @@ static ST_FIELD_INFO i_s_cmp_fields_info[] =
};
/***********************************************************************
/*******************************************************************//**
Fill the dynamic table information_schema.innodb_cmp or
innodb_cmp_reset.
@return 0 on success, 1 on failure */
......@@ -1130,7 +1131,7 @@ i_s_cmp_fill_low(
DBUG_RETURN(status);
}
/***********************************************************************
/*******************************************************************//**
Fill the dynamic table information_schema.innodb_cmp.
@return 0 on success, 1 on failure */
static
......@@ -1144,7 +1145,7 @@ i_s_cmp_fill(
return(i_s_cmp_fill_low(thd, tables, cond, FALSE));
}
/***********************************************************************
/*******************************************************************//**
Fill the dynamic table information_schema.innodb_cmp_reset.
@return 0 on success, 1 on failure */
static
......@@ -1158,7 +1159,7 @@ i_s_cmp_reset_fill(
return(i_s_cmp_fill_low(thd, tables, cond, TRUE));
}
/***********************************************************************
/*******************************************************************//**
Bind the dynamic table information_schema.innodb_cmp.
@return 0 on success */
static
......@@ -1176,7 +1177,7 @@ i_s_cmp_init(
DBUG_RETURN(0);
}
/***********************************************************************
/*******************************************************************//**
Bind the dynamic table information_schema.innodb_cmp_reset.
@return 0 on success */
static
......@@ -1340,7 +1341,7 @@ static ST_FIELD_INFO i_s_cmpmem_fields_info[] =
END_OF_ST_FIELD_INFO
};
/***********************************************************************
/*******************************************************************//**
Fill the dynamic table information_schema.innodb_cmpmem or
innodb_cmpmem_reset.
@return 0 on success, 1 on failure */
......@@ -1396,7 +1397,7 @@ i_s_cmpmem_fill_low(
DBUG_RETURN(status);
}
/***********************************************************************
/*******************************************************************//**
Fill the dynamic table information_schema.innodb_cmpmem.
@return 0 on success, 1 on failure */
static
......@@ -1410,7 +1411,7 @@ i_s_cmpmem_fill(
return(i_s_cmpmem_fill_low(thd, tables, cond, FALSE));
}
/***********************************************************************
/*******************************************************************//**
Fill the dynamic table information_schema.innodb_cmpmem_reset.
@return 0 on success, 1 on failure */
static
......@@ -1424,7 +1425,7 @@ i_s_cmpmem_reset_fill(
return(i_s_cmpmem_fill_low(thd, tables, cond, TRUE));
}
/***********************************************************************
/*******************************************************************//**
Bind the dynamic table information_schema.innodb_cmpmem.
@return 0 on success */
static
......@@ -1442,7 +1443,7 @@ i_s_cmpmem_init(
DBUG_RETURN(0);
}
/***********************************************************************
/*******************************************************************//**
Bind the dynamic table information_schema.innodb_cmpmem_reset.
@return 0 on success */
static
......@@ -1559,7 +1560,7 @@ UNIV_INTERN struct st_mysql_plugin i_s_innodb_cmpmem_reset =
STRUCT_FLD(__reserved1, NULL)
};
/***********************************************************************
/*******************************************************************//**
Unbind a dynamic INFORMATION_SCHEMA table.
@return 0 on success */
static
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file handler/i_s.h
InnoDB INFORMATION SCHEMA tables interface to MySQL.
Created July 18, 2007 Vasil Dimov
......
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
/**************************************************//**
@file handler/mysql_addons.cc
This file contains functions that need to be added to
MySQL code but have not been added yet.
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
......@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/************************************************************************
/********************************************************************//**
@file include/btr0types.h
The index tree general types
Created 2/17/1996 Heikki Tuuri
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment