← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/structs.h

  • Committer: Monty Taylor
  • Date: 2008-07-05 18:10:38 UTC
  • mto: This revision was merged to the branch mainline in revision 63.
  • Revision ID: monty@inaugust.com-20080705181038-0ih0nnamu5qrut0y
Fixed prototypes. Cleaned define a little bit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/structs.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
 
1
/* Copyright (C) 2000-2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
20
16
 
21
17
/* The old structures from unireg */
22
18
 
23
 
#include <mysys/iocache.h>
24
 
 
25
 
class Table;
 
19
struct st_table;
26
20
class Field;
27
21
 
28
22
typedef struct st_date_time_format {
29
 
  unsigned char positions[8];
 
23
  uchar positions[8];
30
24
  char  time_separator;                 /* Separator between hour and minute */
31
 
  uint32_t flag;                                /* For future */
 
25
  uint flag;                            /* For future */
32
26
  LEX_STRING format;
33
27
} DATE_TIME_FORMAT;
34
28
 
35
29
 
36
30
typedef struct st_keyfile_info {        /* used with ha_info() */
37
 
  unsigned char ref[MAX_REFLENGTH];             /* Pointer to current row */
38
 
  unsigned char dupp_ref[MAX_REFLENGTH];        /* Pointer to dupp row */
39
 
  uint32_t ref_length;                  /* Length of ref (1-8) */
40
 
  uint32_t block_size;                  /* index block size */
 
31
  uchar ref[MAX_REFLENGTH];             /* Pointer to current row */
 
32
  uchar dupp_ref[MAX_REFLENGTH];        /* Pointer to dupp row */
 
33
  uint ref_length;                      /* Length of ref (1-8) */
 
34
  uint block_size;                      /* index block size */
41
35
  File filenr;                          /* (uniq) filenr for table */
42
36
  ha_rows records;                      /* Records i datafilen */
43
37
  ha_rows deleted;                      /* Deleted records */
44
 
  uint64_t data_file_length;            /* Length off data file */
45
 
  uint64_t max_data_file_length;        /* Length off data file */
46
 
  uint64_t index_file_length;
47
 
  uint64_t max_index_file_length;
48
 
  uint64_t delete_length;               /* Free bytes */
49
 
  uint64_t auto_increment_value;
 
38
  ulonglong data_file_length;           /* Length off data file */
 
39
  ulonglong max_data_file_length;       /* Length off data file */
 
40
  ulonglong index_file_length;
 
41
  ulonglong max_index_file_length;
 
42
  ulonglong delete_length;              /* Free bytes */
 
43
  ulonglong auto_increment_value;
50
44
  int errkey,sortkey;                   /* Last errorkey and sorted by */
51
45
  time_t create_time;                   /* When table was created */
52
46
  time_t check_time;
60
54
  uint  offset;                         /* offset in record (from 0) */
61
55
  uint  null_offset;                    /* Offset to null_bit in record */
62
56
  /* Length of key part in bytes, excluding NULL flag and length bytes */
63
 
  uint16_t length;
 
57
  uint16 length;
64
58
  /*
65
59
    Number of bytes required to store the keypart value. This may be
66
60
    different from the "length" field as it also counts
69
63
       actual value is stored from offset+1].
70
64
     - possible HA_KEY_BLOB_LENGTH bytes needed to store actual value length.
71
65
  */
72
 
  uint16_t store_length;
73
 
  uint16_t key_type;
74
 
  uint16_t fieldnr;                     /* Fieldnum in UNIREG (1,2,3,...) */
75
 
  uint16_t key_part_flag;                       /* 0 or HA_REVERSE_SORT */
76
 
  uint8_t type;
77
 
  uint8_t null_bit;                     /* Position to null_bit */
 
66
  uint16 store_length;
 
67
  uint16 key_type;
 
68
  uint16 fieldnr;                       /* Fieldnum in UNIREG (1,2,3,...) */
 
69
  uint16 key_part_flag;                 /* 0 or HA_REVERSE_SORT */
 
70
  uint8 type;
 
71
  uint8 null_bit;                       /* Position to null_bit */
78
72
} KEY_PART_INFO ;
79
73
 
80
74
 
82
76
  uint  key_length;                     /* Tot length of key */
83
77
  ulong flags;                          /* dupp key and pack flags */
84
78
  uint  key_parts;                      /* How many key_parts */
85
 
  uint32_t  extra_length;
 
79
  uint  extra_length;
86
80
  uint  usable_key_parts;               /* Should normally be = key_parts */
87
 
  uint32_t  block_size;
 
81
  uint  block_size;
88
82
  enum  ha_key_alg algorithm;
89
83
  KEY_PART_INFO *key_part;
90
84
  char  *name;                          /* Name of key */
94
88
    For temporary heap tables this member is NULL.
95
89
  */
96
90
  ulong *rec_per_key;
97
 
  Table *table;
 
91
  struct st_table *table;
98
92
  LEX_STRING comment;
99
93
} KEY;
100
94
 
116
110
struct st_join_table;
117
111
 
118
112
typedef struct st_read_record {                 /* Parameter to read_record */
119
 
  Table *table;                 /* Head-form */
 
113
  struct st_table *table;                       /* Head-form */
120
114
  handler *file;
121
 
  Table **forms;                        /* head and ref forms */
 
115
  struct st_table **forms;                      /* head and ref forms */
122
116
  int (*read_record)(struct st_read_record *);
123
117
  THD *thd;
124
118
  SQL_SELECT *select;
125
 
  uint32_t cache_records;
126
 
  uint32_t ref_length,struct_length,reclength,rec_cache_size,error_offset;
127
 
  uint32_t index;
128
 
  unsigned char *ref_pos;                               /* pointer to form->refpos */
129
 
  unsigned char *record;
130
 
  unsigned char *rec_buf;                /* to read field values  after filesort */
131
 
  unsigned char *cache,*cache_pos,*cache_end,*read_positions;
 
119
  uint cache_records;
 
120
  uint ref_length,struct_length,reclength,rec_cache_size,error_offset;
 
121
  uint index;
 
122
  uchar *ref_pos;                               /* pointer to form->refpos */
 
123
  uchar *record;
 
124
  uchar *rec_buf;                /* to read field values  after filesort */
 
125
  uchar *cache,*cache_pos,*cache_end,*read_positions;
132
126
  IO_CACHE *io_cache;
133
127
  bool print_error, ignore_not_found_rows;
134
128
  struct st_join_table *do_insideout_scan;
135
129
} READ_RECORD;
136
130
 
137
131
 
 
132
/*
 
133
  Originally MySQL used MYSQL_TIME structure inside server only, but since
 
134
  4.1 it's exported to user in the new client API. Define aliases for
 
135
  new names to keep existing code simple.
 
136
*/
 
137
 
 
138
typedef enum enum_mysql_timestamp_type timestamp_type;
 
139
 
 
140
 
138
141
typedef struct {
139
142
  ulong year,month,day,hour;
140
 
  uint64_t minute,second,second_part;
 
143
  ulonglong minute,second,second_part;
141
144
  bool neg;
142
145
} INTERVAL;
143
146
 
166
169
*/
167
170
typedef struct user_resources {
168
171
  /* Maximum number of queries/statements per hour. */
169
 
  uint32_t questions;
 
172
  uint questions;
170
173
  /*
171
174
     Maximum number of updating statements per hour (which statements are
172
175
     updating is defined by sql_command_flags array).
173
176
  */
174
 
  uint32_t updates;
 
177
  uint updates;
175
178
  /* Maximum number of connections established per hour. */
176
 
  uint32_t conn_per_hour;
 
179
  uint conn_per_hour;
177
180
  /* Maximum number of concurrent connections. */
178
 
  uint32_t user_conn;
 
181
  uint user_conn;
179
182
  /*
180
183
     Values of this enum and specified_limits member are used by the
181
184
     parser to store which user limits were specified in GRANT statement.
182
185
  */
183
186
  enum {QUERIES_PER_HOUR= 1, UPDATES_PER_HOUR= 2, CONNECTIONS_PER_HOUR= 4,
184
187
        USER_CONNECTIONS= 8};
185
 
  uint32_t specified_limits;
 
188
  uint specified_limits;
186
189
} USER_RESOURCES;
187
190
 
188
191
 
204
207
     The moment of time when per hour counters were reset last time
205
208
     (i.e. start of "hour" for conn_per_hour, updates, questions counters).
206
209
  */
207
 
  uint64_t reset_utime;
 
210
  ulonglong reset_utime;
208
211
  /* Total length of the key. */
209
 
  uint32_t len;
 
212
  uint len;
210
213
  /* Current amount of concurrent connections for this account. */
211
 
  uint32_t connections;
 
214
  uint connections;
212
215
  /*
213
216
     Current number of connections per hour, number of updating statements
214
217
     per hour and total number of statements per hour for this account.
215
218
  */
216
 
  uint32_t conn_per_hour, updates, questions;
 
219
  uint conn_per_hour, updates, questions;
217
220
  /* Maximum amount of resources which account is allowed to consume. */
218
221
  USER_RESOURCES user_resources;
219
222
} USER_CONN;
251
254
*/
252
255
class Discrete_interval {
253
256
private:
254
 
  uint64_t interval_min;
255
 
  uint64_t interval_values;
256
 
  uint64_t  interval_max;    // excluded bound. Redundant.
 
257
  ulonglong interval_min;
 
258
  ulonglong interval_values;
 
259
  ulonglong  interval_max;    // excluded bound. Redundant.
257
260
public:
258
261
  Discrete_interval *next;    // used when linked into Discrete_intervals_list
259
 
  void replace(uint64_t start, uint64_t val, uint64_t incr)
 
262
  void replace(ulonglong start, ulonglong val, ulonglong incr)
260
263
  {
261
264
    interval_min=    start;
262
265
    interval_values= val;
263
 
    interval_max=    (val == UINT64_MAX) ? val : start + val * incr;
 
266
    interval_max=    (val == ULONGLONG_MAX) ? val : start + val * incr;
264
267
  }
265
 
  Discrete_interval(uint64_t start, uint64_t val, uint64_t incr) :
266
 
    interval_min(start), interval_values(val),
267
 
    interval_max((val == UINT64_MAX) ? val : start + val * incr),
268
 
    next(NULL)
269
 
  {};
270
 
  Discrete_interval() :
271
 
    interval_min(0), interval_values(0),
272
 
    interval_max(0), next(NULL)
273
 
  {};
274
 
  uint64_t minimum() const { return interval_min;    };
275
 
  uint64_t values()  const { return interval_values; };
276
 
  uint64_t maximum() const { return interval_max;    };
 
268
  Discrete_interval(ulonglong start, ulonglong val, ulonglong incr) :
 
269
    next(NULL) { replace(start, val, incr); };
 
270
  Discrete_interval() : next(NULL) { replace(0, 0, 0); };
 
271
  ulonglong minimum() const { return interval_min;    };
 
272
  ulonglong values()  const { return interval_values; };
 
273
  ulonglong maximum() const { return interval_max;    };
277
274
  /*
278
275
    If appending [3,5] to [1,2], we merge both in [1,5] (they should have the
279
276
    same increment for that, user of the class has to ensure that). That is
280
277
    just a space optimization. Returns 0 if merge succeeded.
281
278
  */
282
 
  bool merge_if_contiguous(uint64_t start, uint64_t val, uint64_t incr)
 
279
  bool merge_if_contiguous(ulonglong start, ulonglong val, ulonglong incr)
283
280
  {
284
281
    if (interval_max == start)
285
282
    {
286
 
      if (val == UINT64_MAX)
 
283
      if (val == ULONGLONG_MAX)
287
284
      {
288
285
        interval_values=   interval_max= val;
289
286
      }
310
307
    "head" to "tail" then to NULL).
311
308
  */
312
309
  Discrete_interval        *current;
313
 
  uint32_t                  elements; // number of elements
 
310
  uint                  elements; // number of elements
314
311
 
315
312
  /* helper function for copy construct and assignment operator */
316
313
  void copy_(const Discrete_intervals_list& from)
322
319
    }
323
320
  }
324
321
public:
325
 
  Discrete_intervals_list() :
326
 
    head(NULL), tail(NULL),
327
 
    current(NULL), elements(0) {};
328
 
  Discrete_intervals_list(const Discrete_intervals_list& from) :
329
 
    head(NULL), tail(NULL),
330
 
    current(NULL), elements(0)
 
322
  Discrete_intervals_list() : head(NULL), current(NULL), elements(0) {};
 
323
  Discrete_intervals_list(const Discrete_intervals_list& from)
331
324
  {
332
325
    copy_(from);
333
326
  }
334
 
  Discrete_intervals_list& operator=(const Discrete_intervals_list& from)
 
327
  void operator=(const Discrete_intervals_list& from)
335
328
  {
336
329
    empty();
337
330
    copy_(from);
338
 
    return *this;
339
331
  }
340
332
  void empty_no_free()
341
333
  {
361
353
    return tmp;
362
354
  }
363
355
  ~Discrete_intervals_list() { empty(); };
364
 
  bool append(uint64_t start, uint64_t val, uint64_t incr);
 
356
  bool append(ulonglong start, ulonglong val, ulonglong incr);
365
357
  bool append(Discrete_interval *interval);
366
 
  uint64_t minimum()     const { return (head ? head->minimum() : 0); };
367
 
  uint64_t maximum()     const { return (head ? tail->maximum() : 0); };
368
 
  uint32_t      nb_elements() const { return elements; }
 
358
  ulonglong minimum()     const { return (head ? head->minimum() : 0); };
 
359
  ulonglong maximum()     const { return (head ? tail->maximum() : 0); };
 
360
  uint      nb_elements() const { return elements; }
369
361
};