← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/structs.h

  • Committer: Brian Aker
  • Date: 2008-07-20 05:41:52 UTC
  • Revision ID: brian@tangent.org-20080720054152-5laf6plsb0o7h6ss
Documentation cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/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
 
#ifndef DRIZZLED_STRUCTS_H
24
 
#define DRIZZLED_STRUCTS_H
25
 
 
26
 
#include "drizzled/base.h"
27
 
#include "drizzled/definitions.h"
28
 
#include "drizzled/lex_string.h"
29
 
#include "drizzled/thr_lock.h"
30
 
 
31
 
namespace drizzled
32
 
{
33
 
 
34
 
namespace internal
35
 
{
36
 
typedef struct st_io_cache IO_CACHE;
37
 
}
38
 
 
39
 
class Table;
 
19
struct st_table;
40
20
class Field;
41
21
 
 
22
typedef struct st_date_time_format {
 
23
  uchar positions[8];
 
24
  char  time_separator;                 /* Separator between hour and minute */
 
25
  uint flag;                            /* For future */
 
26
  LEX_STRING format;
 
27
} DATE_TIME_FORMAT;
 
28
 
 
29
 
42
30
typedef struct st_keyfile_info {        /* used with ha_info() */
43
 
  unsigned char ref[MAX_REFLENGTH];             /* Pointer to current row */
44
 
  unsigned char dupp_ref[MAX_REFLENGTH];        /* Pointer to dupp row */
45
 
  uint32_t ref_length;                  /* Length of ref (1-8) */
46
 
  uint32_t block_size;                  /* index block size */
47
 
  int filenr;                           /* (uniq) filenr for table */
 
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 */
 
35
  File filenr;                          /* (uniq) filenr for table */
48
36
  ha_rows records;                      /* Records i datafilen */
49
37
  ha_rows deleted;                      /* Deleted records */
50
38
  uint64_t data_file_length;            /* Length off data file */
57
45
  time_t create_time;                   /* When table was created */
58
46
  time_t check_time;
59
47
  time_t update_time;
60
 
  uint64_t mean_rec_length;             /* physical reclength */
 
48
  ulong mean_rec_length;                /* physical reclength */
61
49
} KEYFILE_INFO;
62
50
 
63
51
 
64
52
typedef struct st_key_part_info {       /* Info about a key part */
65
53
  Field *field;
66
 
  unsigned int  offset;                         /* offset in record (from 0) */
67
 
  unsigned int  null_offset;                    /* Offset to null_bit in record */
 
54
  uint  offset;                         /* offset in record (from 0) */
 
55
  uint  null_offset;                    /* Offset to null_bit in record */
68
56
  /* Length of key part in bytes, excluding NULL flag and length bytes */
69
 
  uint16_t length;
 
57
  uint16 length;
70
58
  /*
71
59
    Number of bytes required to store the keypart value. This may be
72
60
    different from the "length" field as it also counts
75
63
       actual value is stored from offset+1].
76
64
     - possible HA_KEY_BLOB_LENGTH bytes needed to store actual value length.
77
65
  */
78
 
  uint16_t store_length;
79
 
  uint16_t key_type;
80
 
  uint16_t fieldnr;                     /* Fieldnum in UNIREG (1,2,3,...) */
81
 
  uint16_t key_part_flag;                       /* 0 or HA_REVERSE_SORT */
82
 
  uint8_t type;
83
 
  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 */
84
72
} KEY_PART_INFO ;
85
73
 
86
74
 
87
75
typedef struct st_key {
88
 
  unsigned int  key_length;             /* Tot length of key */
 
76
  uint  key_length;                     /* Tot length of key */
 
77
  ulong flags;                          /* dupp key and pack flags */
 
78
  uint  key_parts;                      /* How many key_parts */
 
79
  uint  extra_length;
 
80
  uint  usable_key_parts;               /* Should normally be = key_parts */
 
81
  uint  block_size;
89
82
  enum  ha_key_alg algorithm;
90
 
  unsigned long flags;                  /* dupp key and pack flags */
91
 
  unsigned int key_parts;               /* How many key_parts */
92
 
  uint32_t  extra_length;
93
 
  unsigned int usable_key_parts;        /* Should normally be = key_parts */
94
 
  uint32_t  block_size;
95
83
  KEY_PART_INFO *key_part;
96
84
  char  *name;                          /* Name of key */
97
85
  /*
100
88
    For temporary heap tables this member is NULL.
101
89
  */
102
90
  ulong *rec_per_key;
103
 
  Table *table;
 
91
  struct st_table *table;
104
92
  LEX_STRING comment;
105
93
} KEY;
106
94
 
107
95
 
108
 
class JoinTable;
 
96
struct st_join_table;
109
97
 
110
 
struct RegInfo {                /* Extra info about reg */
111
 
  JoinTable *join_tab;  /* Used by SELECT() */
 
98
typedef struct st_reginfo {             /* Extra info about reg */
 
99
  struct st_join_table *join_tab;       /* Used by SELECT() */
112
100
  enum thr_lock_type lock_type;         /* How database is used */
113
101
  bool not_exists_optimize;
114
102
  bool impossible_range;
115
 
  RegInfo()
116
 
    : join_tab(NULL), lock_type(TL_UNLOCK),
117
 
      not_exists_optimize(false), impossible_range(false) {}
118
 
  void reset()
119
 
  {
120
 
    join_tab= NULL;
121
 
    lock_type= TL_UNLOCK;
122
 
    not_exists_optimize= false;
123
 
    impossible_range= false;
124
 
  }
125
 
};
 
103
} REGINFO;
 
104
 
126
105
 
127
106
struct st_read_record;                          /* For referense later */
128
 
class Session;
129
 
class Cursor;
130
 
namespace optimizer { class SqlSelect; }
 
107
class SQL_SELECT;
 
108
class THD;
 
109
class handler;
 
110
struct st_join_table;
131
111
 
132
112
typedef struct st_read_record {                 /* Parameter to read_record */
133
 
  Table *table;                 /* Head-form */
134
 
  Cursor *cursor;
135
 
  Table **forms;                        /* head and ref forms */
 
113
  struct st_table *table;                       /* Head-form */
 
114
  handler *file;
 
115
  struct st_table **forms;                      /* head and ref forms */
136
116
  int (*read_record)(struct st_read_record *);
137
 
  Session *session;
138
 
  optimizer::SqlSelect *select;
139
 
  uint32_t cache_records;
140
 
  uint32_t ref_length,struct_length,reclength,rec_cache_size,error_offset;
141
 
  uint32_t index;
142
 
  unsigned char *ref_pos;                               /* pointer to form->refpos */
143
 
  unsigned char *record;
144
 
  unsigned char *rec_buf;                /* to read field values  after filesort */
145
 
  unsigned char *cache,*cache_pos,*cache_end,*read_positions;
146
 
  internal::IO_CACHE *io_cache;
 
117
  THD *thd;
 
118
  SQL_SELECT *select;
 
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;
 
126
  IO_CACHE *io_cache;
147
127
  bool print_error, ignore_not_found_rows;
148
 
  JoinTable *do_insideout_scan;
 
128
  struct st_join_table *do_insideout_scan;
149
129
} READ_RECORD;
150
130
 
151
 
typedef int *(*update_var)(Session *, struct drizzle_show_var *);
152
 
 
153
 
} /* namespace drizzled */
 
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
 
 
141
typedef struct {
 
142
  ulong year,month,day,hour;
 
143
  uint64_t minute,second,second_part;
 
144
  bool neg;
 
145
} INTERVAL;
 
146
 
 
147
 
 
148
typedef struct st_known_date_time_format {
 
149
  const char *format_name;
 
150
  const char *date_format;
 
151
  const char *datetime_format;
 
152
  const char *time_format;
 
153
} KNOWN_DATE_TIME_FORMAT;
 
154
 
 
155
enum SHOW_COMP_OPTION { SHOW_OPTION_YES, SHOW_OPTION_NO, SHOW_OPTION_DISABLED};
 
156
 
 
157
extern const char *show_comp_option_name[];
 
158
 
 
159
typedef int *(*update_var)(THD *, struct st_mysql_show_var *);
 
160
 
 
161
typedef struct  st_lex_user {
 
162
  LEX_STRING user, host, password;
 
163
} LEX_USER;
 
164
 
 
165
/*
 
166
  This structure specifies the maximum amount of resources which
 
167
  can be consumed by each account. Zero value of a member means
 
168
  there is no limit.
 
169
*/
 
170
typedef struct user_resources {
 
171
  /* Maximum number of queries/statements per hour. */
 
172
  uint questions;
 
173
  /*
 
174
     Maximum number of updating statements per hour (which statements are
 
175
     updating is defined by sql_command_flags array).
 
176
  */
 
177
  uint updates;
 
178
  /* Maximum number of connections established per hour. */
 
179
  uint conn_per_hour;
 
180
  /* Maximum number of concurrent connections. */
 
181
  uint user_conn;
 
182
  /*
 
183
     Values of this enum and specified_limits member are used by the
 
184
     parser to store which user limits were specified in GRANT statement.
 
185
  */
 
186
  enum {QUERIES_PER_HOUR= 1, UPDATES_PER_HOUR= 2, CONNECTIONS_PER_HOUR= 4,
 
187
        USER_CONNECTIONS= 8};
 
188
  uint specified_limits;
 
189
} USER_RESOURCES;
 
190
 
 
191
 
 
192
/*
 
193
  This structure is used for counting resources consumed and for checking
 
194
  them against specified user limits.
 
195
*/
 
196
typedef struct  user_conn {
 
197
  /*
 
198
     Pointer to user+host key (pair separated by '\0') defining the entity
 
199
     for which resources are counted (By default it is user account thus
 
200
     priv_user/priv_host pair is used. If --old-style-user-limits option
 
201
     is enabled, resources are counted for each user+host separately).
 
202
  */
 
203
  char *user;
 
204
  /* Pointer to host part of the key. */
 
205
  char *host;
 
206
  /**
 
207
     The moment of time when per hour counters were reset last time
 
208
     (i.e. start of "hour" for conn_per_hour, updates, questions counters).
 
209
  */
 
210
  uint64_t reset_utime;
 
211
  /* Total length of the key. */
 
212
  uint len;
 
213
  /* Current amount of concurrent connections for this account. */
 
214
  uint connections;
 
215
  /*
 
216
     Current number of connections per hour, number of updating statements
 
217
     per hour and total number of statements per hour for this account.
 
218
  */
 
219
  uint conn_per_hour, updates, questions;
 
220
  /* Maximum amount of resources which account is allowed to consume. */
 
221
  USER_RESOURCES user_resources;
 
222
} USER_CONN;
 
223
 
 
224
        /* Bits in form->update */
 
225
#define REG_MAKE_DUPP           1       /* Make a copy of record when read */
 
226
#define REG_NEW_RECORD          2       /* Write a new record if not found */
 
227
#define REG_UPDATE              4       /* Uppdate record */
 
228
#define REG_DELETE              8       /* Delete found record */
 
229
#define REG_PROG                16      /* User is updating database */
 
230
#define REG_CLEAR_AFTER_WRITE   32
 
231
#define REG_MAY_BE_UPDATED      64
 
232
#define REG_AUTO_UPDATE         64      /* Used in D-forms for scroll-tables */
 
233
#define REG_OVERWRITE           128
 
234
#define REG_SKIP_DUP            256
154
235
 
155
236
        /* Bits in form->status */
156
237
#define STATUS_NO_RECORD        (1+2)   /* Record isn't usably */
162
243
#define STATUS_NULL_ROW         32      /* table->null_row is set */
163
244
#define STATUS_DELETED          64
164
245
 
165
 
#endif /* DRIZZLED_STRUCTS_H */
 
246
/*
 
247
  Such interval is "discrete": it is the set of
 
248
  { auto_inc_interval_min + k * increment,
 
249
    0 <= k <= (auto_inc_interval_values-1) }
 
250
  Where "increment" is maintained separately by the user of this class (and is
 
251
  currently only thd->variables.auto_increment_increment).
 
252
  It mustn't derive from Sql_alloc, because SET INSERT_ID needs to
 
253
  allocate memory which must stay allocated for use by the next statement.
 
254
*/
 
255
class Discrete_interval {
 
256
private:
 
257
  uint64_t interval_min;
 
258
  uint64_t interval_values;
 
259
  uint64_t  interval_max;    // excluded bound. Redundant.
 
260
public:
 
261
  Discrete_interval *next;    // used when linked into Discrete_intervals_list
 
262
  void replace(uint64_t start, uint64_t val, uint64_t incr)
 
263
  {
 
264
    interval_min=    start;
 
265
    interval_values= val;
 
266
    interval_max=    (val == UINT64_MAX) ? val : start + val * incr;
 
267
  }
 
268
  Discrete_interval(uint64_t start, uint64_t val, uint64_t incr) :
 
269
    next(NULL) { replace(start, val, incr); };
 
270
  Discrete_interval() : next(NULL) { replace(0, 0, 0); };
 
271
  uint64_t minimum() const { return interval_min;    };
 
272
  uint64_t values()  const { return interval_values; };
 
273
  uint64_t maximum() const { return interval_max;    };
 
274
  /*
 
275
    If appending [3,5] to [1,2], we merge both in [1,5] (they should have the
 
276
    same increment for that, user of the class has to ensure that). That is
 
277
    just a space optimization. Returns 0 if merge succeeded.
 
278
  */
 
279
  bool merge_if_contiguous(uint64_t start, uint64_t val, uint64_t incr)
 
280
  {
 
281
    if (interval_max == start)
 
282
    {
 
283
      if (val == UINT64_MAX)
 
284
      {
 
285
        interval_values=   interval_max= val;
 
286
      }
 
287
      else
 
288
      {
 
289
        interval_values+=  val;
 
290
        interval_max=      start + val * incr;
 
291
      }
 
292
      return 0;
 
293
    }
 
294
    return 1;
 
295
  };
 
296
};
 
297
 
 
298
/* List of Discrete_interval objects */
 
299
class Discrete_intervals_list {
 
300
private:
 
301
  Discrete_interval        *head;
 
302
  Discrete_interval        *tail;
 
303
  /*
 
304
    When many intervals are provided at the beginning of the execution of a
 
305
    statement (in a replication slave or SET INSERT_ID), "current" points to
 
306
    the interval being consumed by the thread now (so "current" goes from
 
307
    "head" to "tail" then to NULL).
 
308
  */
 
309
  Discrete_interval        *current;
 
310
  uint                  elements; // number of elements
 
311
 
 
312
  /* helper function for copy construct and assignment operator */
 
313
  void copy_(const Discrete_intervals_list& from)
 
314
  {
 
315
    for (Discrete_interval *i= from.head; i; i= i->next)
 
316
    {
 
317
      Discrete_interval j= *i;
 
318
      append(&j);
 
319
    }
 
320
  }
 
321
public:
 
322
  Discrete_intervals_list() : head(NULL), current(NULL), elements(0) {};
 
323
  Discrete_intervals_list(const Discrete_intervals_list& from)
 
324
  {
 
325
    copy_(from);
 
326
  }
 
327
  void operator=(const Discrete_intervals_list& from)
 
328
  {
 
329
    empty();
 
330
    copy_(from);
 
331
  }
 
332
  void empty_no_free()
 
333
  {
 
334
    head= current= NULL;
 
335
    elements= 0;
 
336
  }
 
337
  void empty()
 
338
  {
 
339
    for (Discrete_interval *i= head; i;)
 
340
    {
 
341
      Discrete_interval *next= i->next;
 
342
      delete i;
 
343
      i= next;
 
344
    }
 
345
    empty_no_free();
 
346
  }
 
347
 
 
348
  const Discrete_interval* get_next()
 
349
  {
 
350
    Discrete_interval *tmp= current;
 
351
    if (current != NULL)
 
352
      current= current->next;
 
353
    return tmp;
 
354
  }
 
355
  ~Discrete_intervals_list() { empty(); };
 
356
  bool append(uint64_t start, uint64_t val, uint64_t incr);
 
357
  bool append(Discrete_interval *interval);
 
358
  uint64_t minimum()     const { return (head ? head->minimum() : 0); };
 
359
  uint64_t maximum()     const { return (head ? tail->maximum() : 0); };
 
360
  uint      nb_elements() const { return elements; }
 
361
};