← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/structs.h

fix variables_c test, remove have_community checks, no longer valid

Show diffs side-by-side

added added

removed removed

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