← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/records.h

  • Committer: Brian Aker
  • Date: 2010-05-18 15:49:50 UTC
  • Revision ID: brian@gaz-20100518154950-qhctxu6lvvnyxy9i
Simplify out Open_tables_state() backup/restore (no longer needed).

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/records.h
23
23
namespace drizzled
24
24
{
25
25
 
26
 
struct ReadRecord {                     /* Parameter to read_record */
27
 
  Table *table;                 /* Head-form */
28
 
  Cursor *cursor;
29
 
  Table **forms;                        /* head and ref forms */
30
 
  int (*read_record)(ReadRecord *);
31
 
  Session *session;
32
 
  optimizer::SqlSelect *select;
33
 
  uint32_t cache_records;
34
 
  uint32_t ref_length;
35
 
  uint32_t struct_length;
36
 
  uint32_t reclength;
37
 
  uint32_t rec_cache_size;
38
 
  uint32_t error_offset;
39
 
  uint32_t index;
40
 
  unsigned char *ref_pos;                               /* pointer to form->refpos */
41
 
  unsigned char *record;
42
 
  unsigned char *rec_buf;                /* to read field values  after filesort */
43
 
private:
44
 
  unsigned char *cache;
45
 
public:
46
 
  unsigned char *getCache()
47
 
  {
48
 
    return cache;
49
 
  }
50
 
  unsigned char *cache_pos;
51
 
  unsigned char *cache_end;
52
 
  unsigned char *read_positions;
53
 
  internal::IO_CACHE *io_cache;
54
 
  bool print_error;
55
 
  bool ignore_not_found_rows;
56
 
  JoinTable *do_insideout_scan;
57
 
  ReadRecord() :
58
 
    table(NULL),
59
 
    cursor(NULL),
60
 
    forms(0),
61
 
    read_record(0),
62
 
    session(0),
63
 
    select(0),
64
 
    cache_records(0),
65
 
    ref_length(0),
66
 
    struct_length(0),
67
 
    reclength(0),
68
 
    rec_cache_size(0),
69
 
    error_offset(0),
70
 
    index(0),
71
 
    ref_pos(0),
72
 
    record(0),
73
 
    rec_buf(0),
74
 
    cache(0),
75
 
    cache_pos(0),
76
 
    cache_end(0),
77
 
    read_positions(0),
78
 
    io_cache(0),
79
 
    print_error(0),
80
 
    ignore_not_found_rows(0),
81
 
    do_insideout_scan(0)
82
 
  {
83
 
  }
84
 
 
85
 
  void init()
86
 
  {
87
 
    table= NULL;
88
 
    cursor= NULL;
89
 
    forms= 0;
90
 
    read_record= 0;
91
 
    session= 0;
92
 
    select= 0;
93
 
    cache_records= 0;
94
 
    ref_length= 0;
95
 
    struct_length= 0;
96
 
    reclength= 0;
97
 
    rec_cache_size= 0;
98
 
    error_offset= 0;
99
 
    index= 0;
100
 
    ref_pos= 0;
101
 
    record= 0;
102
 
    rec_buf= 0;
103
 
    cache= 0;
104
 
    cache_pos= 0;
105
 
    cache_end= 0;
106
 
    read_positions= 0;
107
 
    io_cache= 0;
108
 
    print_error= 0;
109
 
    ignore_not_found_rows= 0;
110
 
    do_insideout_scan= 0;
111
 
  }
112
 
 
113
 
  virtual ~ReadRecord()
114
 
  { }
 
26
/**
 
27
  Initialize ReadRecord structure to perform full index scan (in forward
 
28
  direction) using read_record.read_record() interface.
 
29
 
 
30
    This function has been added at late stage and is used only by
 
31
    UPDATE/DELETE. Other statements perform index scans using
 
32
    join_read_first/next functions.
 
33
 
 
34
  @param info         ReadRecord structure to initialize.
 
35
  @param session          Thread handle
 
36
  @param table        Table to be accessed
 
37
  @param print_error  If true, call table->print_error() if an error
 
38
                      occurs (except for end-of-records error)
 
39
  @param idx          index to scan
 
40
*/
 
41
void init_read_record_idx(ReadRecord *info, 
 
42
                          Session *session, 
 
43
                          Table *table,
 
44
                          bool print_error, 
 
45
                          uint32_t idx);
115
46
 
116
47
/*
117
48
  init_read_record is used to scan by using a number of different methods.
181
112
    This is the most basic access method of a table using rnd_init,
182
113
    rnd_next and rnd_end. No indexes are used.
183
114
*/
 
115
 
 
116
struct ReadRecord {                     /* Parameter to read_record */
 
117
  Table *table;                 /* Head-form */
 
118
  Cursor *cursor;
 
119
  Table **forms;                        /* head and ref forms */
 
120
  int (*read_record)(ReadRecord *);
 
121
  Session *session;
 
122
  optimizer::SqlSelect *select;
 
123
  uint32_t cache_records;
 
124
  uint32_t ref_length,struct_length,reclength,rec_cache_size,error_offset;
 
125
  uint32_t index;
 
126
  unsigned char *ref_pos;                               /* pointer to form->refpos */
 
127
  unsigned char *record;
 
128
  unsigned char *rec_buf;                /* to read field values  after filesort */
 
129
  unsigned char *cache,*cache_pos,*cache_end,*read_positions;
 
130
  internal::IO_CACHE *io_cache;
 
131
  bool print_error, ignore_not_found_rows;
 
132
  JoinTable *do_insideout_scan;
 
133
 
184
134
  void init_read_record(Session *session, 
185
135
                        Table *reg_form,
186
136
                        optimizer::SqlSelect *select,
188
138
                        bool print_errors);
189
139
 
190
140
  void end_read_record();
191
 
 
192
 
 
193
 
/**
194
 
  Initialize ReadRecord structure to perform full index scan (in forward
195
 
  direction) using read_record.read_record() interface.
196
 
 
197
 
    This function has been added at late stage and is used only by
198
 
    UPDATE/DELETE. Other statements perform index scans using
199
 
    join_read_first/next functions.
200
 
 
201
 
  @param info         ReadRecord structure to initialize.
202
 
  @param session          Thread handle
203
 
  @param table        Table to be accessed
204
 
  @param print_error  If true, call table->print_error() if an error
205
 
                      occurs (except for end-of-records error)
206
 
  @param idx          index to scan
207
 
                    */
208
 
  void init_read_record_idx(Session *session, 
209
 
                            Table *table,
210
 
                            bool print_error, 
211
 
                            uint32_t idx);
212
 
 
213
 
  void init_reard_record_sequential();
214
 
 
215
 
  bool init_rr_cache();
216
141
};
217
142
 
218
143
} /* namespace drizzled */