← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/heap/heap_priv.h

  • Committer: Brian Aker
  • Date: 2010-01-22 00:53:13 UTC
  • Revision ID: brian@gaz-20100122005313-jmizcbcdi1lt4tcx
Revert db patch.

Show diffs side-by-side

added added

removed removed

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