The world's most popular open source database

MySQL 5.1: Tup_fixsize_page Struct Reference

Tup_fixsize_page Struct Reference

#include <tuppage.hpp>

Collaboration diagram for Tup_fixsize_page:


Public Member Functions
	STATIC_CONST (FREE_RECORD=~(Uint32) 0)
	STATIC_CONST (DATA_WORDS=File_formats::NDB_PAGE_SIZE_WORDS-32)
Uint32 *	get_ptr (Uint32 page_idx, Uint32 rec_size)
Uint32	alloc_record ()
Uint32	alloc_record (Uint32 page_idx)
Uint32	free_record (Uint32 page_idx)
Public Attributes
File_formats::Page_header	m_page_header
Uint32	m_restart_seq
Uint32	page_state
Uint32	next_page
Uint32	prev_page
Uint32	first_cluster_page
Uint32	last_cluster_page
Uint32	next_cluster_page
Uint32	prev_cluster_page
Uint32	frag_page_id
Uint32	physical_page_id
Uint32	free_space
Uint32	next_free_index
Uint32	list_index
Uint32	uncommitted_used_space
Uint32	m_page_no
Uint32	m_file_no
Uint32	m_table_id
Uint32	m_fragment_id
Uint32	m_extent_no
Uint32	m_extent_info_ptr
Uint32	unused_ph [9]
Uint32	m_data [DATA_WORDS]

Detailed Description

Definition at line 59 of file tuppage.hpp.

Member Function Documentation

Uint32 Tup_fixsize_page::alloc_record ( Uint32 page_idx )

Definition at line 67 of file tuppage.cpp.

References assert, free_space, likely, m_data, and next_free_index.

00068 {
00069   assert(page_idx + 1 < DATA_WORDS);
00070   if (likely(free_space && m_data[page_idx + 1] == FREE_RECORD))
00071   {
00072     Uint32 prev = m_data[page_idx] >> 16;
00073     Uint32 next = m_data[page_idx] & 0xFFFF;
00074     
00075     assert(prev != 0xFFFF || (next_free_index == page_idx));
00076     if (prev == 0xFFFF)
00077     {
00078       next_free_index = next;
00079     }
00080     else
00081     {
00082       Uint32 prevP = m_data[prev];
00083       m_data[prev] = (prevP & 0xFFFF0000) | next;
00084     }
00085 
00086     if (next != 0xFFFF)
00087     {
00088       Uint32 nextP = m_data[next];
00089       m_data[next] = (prev << 16) | (nextP & 0xFFFF);
00090     }
00091     free_space --;
00092     m_data[page_idx + 1] = 0;
00093     return page_idx;
00094   }
00095   return ~0;
00096 }

Uint32 Tup_fixsize_page::alloc_record ( )

Alloc record from page return page_idx

Definition at line 36 of file tuppage.cpp.

References assert, free_space, m_data, and next_free_index.

Referenced by Dbtup::alloc_tuple_from_page().

00037 {
00038   assert(free_space);
00039   Uint32 page_idx = next_free_index;
00040   assert(page_idx + 1 < DATA_WORDS);
00041 
00042   Uint32 prev = m_data[page_idx] >> 16;
00043   Uint32 next = m_data[page_idx] & 0xFFFF;
00044 
00045   assert(prev == 0xFFFF);
00046   assert(m_data[page_idx + 1] == FREE_RECORD);
00047   
00048   m_data[page_idx + 1] = 0;
00049   if (next != 0xFFFF)
00050   {
00051     assert(free_space > 1);
00052     Uint32 nextP = m_data[next];
00053     assert((nextP >> 16) == page_idx);
00054     m_data[next] = 0xFFFF0000 | (nextP & 0xFFFF);
00055   }
00056   else
00057   {
00058     assert(free_space == 1);
00059   }
00060   
00061   next_free_index = next;
00062   free_space--;
00063   return page_idx;
00064 }

Here is the caller graph for this function:

Uint32 Tup_fixsize_page::free_record ( Uint32 page_idx )

Definition at line 99 of file tuppage.cpp.

References assert, free_space, m_data, and next_free_index.

Referenced by Dbtup::free_fix_rec().

00100 {
00101   Uint32 next = next_free_index;
00102   
00103   assert(page_idx + 1 < DATA_WORDS);
00104   assert(m_data[page_idx + 1] != FREE_RECORD);
00105 
00106   if (next == 0xFFFF)
00107   {
00108     assert(free_space == 0);
00109   }
00110   else
00111   {
00112     assert(free_space);
00113     assert(next + 1 < DATA_WORDS);
00114     Uint32 nextP = m_data[next];
00115     assert((nextP >> 16) == 0xFFFF);
00116     m_data[next] = (page_idx << 16) | (nextP & 0xFFFF);
00117     assert(m_data[next + 1] == FREE_RECORD);
00118   }
00119 
00120   next_free_index = page_idx;
00121   m_data[page_idx] = 0xFFFF0000 | next;
00122   m_data[page_idx + 1] = FREE_RECORD;
00123   
00124   return ++free_space;
00125 }

Here is the caller graph for this function:

Uint32* Tup_fixsize_page::get_ptr	(	Uint32	page_idx,
		Uint32	rec_size
	)			`[inline]`

Definition at line 89 of file tuppage.hpp.

References assert, and Tup_page::m_data.

00089                                                    {
00090     assert(page_idx + rec_size <= DATA_WORDS);
00091     return m_data + page_idx;
00092   }

Tup_fixsize_page::STATIC_CONST ( DATA_WORDS = File_formats::NDB_PAGE_SIZE_WORDS-32 )