← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/heap/heapdef.h

  • Committer: Monty Taylor
  • Date: 2008-10-10 23:04:21 UTC
  • mto: (509.1.1 codestyle)
  • mto: This revision was merged to the branch mainline in revision 511.
  • Revision ID: monty@inaugust.com-20081010230421-zohe1eppxievpw8d
Removed O_NOFOLLOW

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/heap/heapdef.h
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/* This file is included in all heap-files */
17
 
#ifndef PLUGIN_MEMORY_HEAP_PRIV_H
18
 
#define PLUGIN_MEMORY_HEAP_PRIV_H
19
 
 
20
 
#include "config.h"
21
 
#include <drizzled/base.h>
22
 
 
23
 
#include "drizzled/internal/my_sys.h"
24
 
#include "drizzled/charset_info.h"
25
 
#include "drizzled/internal/my_pthread.h"
 
17
#ifndef HEAPDEF_H
 
18
#define HEAPDEF_H
 
19
 
 
20
#include <drizzled/base.h>              /* This includes global */
 
21
 
 
22
#ifdef __cplusplus
 
23
extern "C" {
 
24
#endif
 
25
 
 
26
#include <mysys/my_pthread.h>
26
27
#include "heap.h"                       /* Structs & some defines */
27
 
#include "drizzled/tree.h"
28
 
#include <list>
29
 
 
30
 
#include <boost/thread/mutex.hpp>
 
28
#include <mysys/my_tree.h>
31
29
 
32
30
/*
33
31
  When allocating keys /rows in the internal block structure, do it
37
35
  as possible and keep memory consumption down.
38
36
*/
39
37
 
 
38
#define HP_MIN_RECORDS_IN_BLOCK 16
 
39
#define HP_MAX_RECORDS_IN_BLOCK 8192
 
40
 
40
41
#define CHUNK_STATUS_DELETED 0    /* this chunk has been deleted and can be reused */
41
42
#define CHUNK_STATUS_ACTIVE  1    /* this chunk represents the first part of a live record */
42
43
#define CHUNK_STATUS_LINKED  2    /* this chunk is a continuation from another chunk (part of chunkset) */
43
44
 
44
45
        /* Some extern variables */
45
46
 
46
 
extern std::list<HP_SHARE *> heap_share_list;
47
 
extern std::list<HP_INFO *> heap_open_list;
 
47
extern LIST *heap_open_list,*heap_share_list;
48
48
 
49
49
#define test_active(info) \
50
50
if (!(info->update & HA_STATE_AKTIV))\
51
 
{ errno=HA_ERR_NO_ACTIVE_RECORD; return(-1); }
 
51
{ my_errno=HA_ERR_NO_ACTIVE_RECORD; return(-1); }
52
52
#define hp_find_hash(A,B) ((HASH_INFO*) hp_find_block((A),(B)))
53
53
 
54
54
        /* Find pos for record and update it in info->current_ptr */
55
 
#define hp_find_record(info,pos) (info)->current_ptr= hp_find_block(&(info)->getShare()->recordspace.block,pos)
 
55
#define hp_find_record(info,pos) (info)->current_ptr= hp_find_block(&(info)->s->recordspace.block,pos)
56
56
 
57
57
#define get_chunk_status(info,ptr) (ptr[(info)->offset_status])
58
58
 
64
64
  unsigned char *ptr_to_rec;
65
65
} HASH_INFO;
66
66
 
 
67
typedef struct {
 
68
  HA_KEYSEG *keyseg;
 
69
  uint32_t key_length;
 
70
  uint32_t search_flag;
 
71
} heap_rb_param;
 
72
      
67
73
        /* Prototypes for intern functions */
68
74
 
69
75
extern HP_SHARE *hp_find_named_heap(const char *name);
72
78
extern int hp_get_new_block(HP_BLOCK *info, size_t* alloc_length);
73
79
extern void hp_free(HP_SHARE *info);
74
80
extern unsigned char *hp_free_level(HP_BLOCK *block,uint32_t level,HP_PTRS *pos,
75
 
                                    unsigned char *last_pos);
 
81
                           unsigned char *last_pos);
76
82
extern int hp_write_key(HP_INFO *info, HP_KEYDEF *keyinfo,
77
83
                        const unsigned char *record, unsigned char *recpos);
 
84
extern int hp_rb_write_key(HP_INFO *info, HP_KEYDEF *keyinfo, 
 
85
                           const unsigned char *record, unsigned char *recpos);
 
86
extern int hp_rb_delete_key(HP_INFO *info,HP_KEYDEF *keyinfo,
 
87
                            const unsigned char *record,unsigned char *recpos,int flag);
78
88
extern int hp_delete_key(HP_INFO *info,HP_KEYDEF *keyinfo,
79
89
                         const unsigned char *record,unsigned char *recpos,int flag);
80
90
extern HASH_INFO *_heap_find_hash(HP_BLOCK *block,uint32_t pos);
82
92
                       uint32_t nextflag);
83
93
extern unsigned char *hp_search_next(HP_INFO *info, HP_KEYDEF *keyinfo,
84
94
                            const unsigned char *key, HASH_INFO *pos);
 
95
extern uint32_t hp_hashnr(HP_KEYDEF *keyinfo,const unsigned char *key);
85
96
extern uint32_t hp_rec_hashnr(HP_KEYDEF *keyinfo,const unsigned char *rec);
86
97
extern uint32_t hp_mask(uint32_t hashnr,uint32_t buffmax,uint32_t maxlength);
87
98
extern void hp_movelink(HASH_INFO *pos,HASH_INFO *next_link,
89
100
extern int hp_rec_key_cmp(HP_KEYDEF *keydef,const unsigned char *rec1,
90
101
                          const unsigned char *rec2,
91
102
                          bool diff_if_only_endspace_difference);
 
103
extern int hp_key_cmp(HP_KEYDEF *keydef,const unsigned char *rec,
 
104
                      const unsigned char *key);
92
105
extern void hp_make_key(HP_KEYDEF *keydef,unsigned char *key,const unsigned char *rec);
 
106
extern uint32_t hp_rb_make_key(HP_KEYDEF *keydef, unsigned char *key,
 
107
                           const unsigned char *rec, unsigned char *recpos);
 
108
extern uint32_t hp_rb_key_length(HP_KEYDEF *keydef, const unsigned char *key);
 
109
extern uint32_t hp_rb_null_key_length(HP_KEYDEF *keydef, const unsigned char *key);
 
110
extern uint32_t hp_rb_var_key_length(HP_KEYDEF *keydef, const unsigned char *key);
93
111
extern bool hp_if_null_in_key(HP_KEYDEF *keyinfo, const unsigned char *record);
94
 
extern int hp_close(HP_INFO *info);
 
112
extern int hp_close(register HP_INFO *info);
95
113
extern void hp_clear(HP_SHARE *info);
 
114
extern void hp_clear_keys(HP_SHARE *info);
 
115
extern uint32_t hp_rb_pack_key(HP_KEYDEF *keydef, unsigned char *key, const unsigned char *old,
 
116
                           key_part_map keypart_map);
96
117
 
97
118
   /* Chunkset management (alloc/free/encode/decode) functions */
98
 
 
 
119
 
99
120
extern unsigned char *hp_allocate_chunkset(HP_DATASPACE *info, uint32_t chunk_count);
 
121
extern int hp_reallocate_chunkset(HP_DATASPACE *info, uint32_t chunk_count, unsigned char* pos);
100
122
extern void hp_free_chunks(HP_DATASPACE *info, unsigned char *pos);
101
123
extern void hp_clear_dataspace(HP_DATASPACE *info);
102
 
 
 
124
 
103
125
extern uint32_t hp_get_encoded_data_length(HP_SHARE *info, const unsigned char *record, uint32_t *chunk_count);
104
126
extern void hp_copy_record_data_to_chunkset(HP_SHARE *info, const unsigned char *record, unsigned char *pos);
105
127
extern void hp_extract_record(HP_SHARE *info, unsigned char *record, const unsigned char *pos);
106
 
extern bool hp_compare_record_data_to_chunkset(HP_SHARE *info, const unsigned char *record, unsigned char *pos);
107
 
 
108
 
extern boost::mutex THR_LOCK_heap;
109
 
 
110
 
#endif /* PLUGIN_MEMORY_HEAP_PRIV_H */
 
128
extern uint32_t hp_process_record_data_to_chunkset(HP_SHARE *info, const unsigned char *record, unsigned char *pos, uint32_t is_compare);
 
129
 
 
130
 
 
131
 
 
132
extern pthread_mutex_t THR_LOCK_heap;
 
133
 
 
134
#ifdef __cplusplus
 
135
}
 
136
#endif
 
137
 
 
138
#endif /* HEAPDEF_H */