← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/structs.h

  • Committer: Brian Aker
  • Date: 2008-10-06 06:47:29 UTC
  • Revision ID: brian@tangent.org-20081006064729-2i9mhjkzyvow9xsm
Remove uint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/structs.h
20
20
 
21
21
/* The old structures from unireg */
22
22
 
23
 
#ifndef DRIZZLED_STRUCTS_H
24
 
#define DRIZZLED_STRUCTS_H
25
 
 
26
 
#include <drizzled/base.h>
27
 
#include <mysys/definitions.h>
28
 
#include <drizzled/lex_string.h>
29
 
 
30
23
class Table;
31
24
class Field;
32
 
typedef struct st_io_cache IO_CACHE;
 
25
 
 
26
typedef struct st_date_time_format {
 
27
  unsigned char positions[8];
 
28
  char  time_separator;                 /* Separator between hour and minute */
 
29
  uint32_t flag;                                /* For future */
 
30
  LEX_STRING format;
 
31
} DATE_TIME_FORMAT;
 
32
 
33
33
 
34
34
typedef struct st_keyfile_info {        /* used with ha_info() */
35
35
  unsigned char ref[MAX_REFLENGTH];             /* Pointer to current row */
49
49
  time_t create_time;                   /* When table was created */
50
50
  time_t check_time;
51
51
  time_t update_time;
52
 
  uint64_t mean_rec_length;             /* physical reclength */
 
52
  ulong mean_rec_length;                /* physical reclength */
53
53
} KEYFILE_INFO;
54
54
 
55
55
 
109
109
 
110
110
struct st_read_record;                          /* For referense later */
111
111
class SQL_SELECT;
112
 
class Session;
 
112
class THD;
113
113
class handler;
114
114
struct st_join_table;
115
115
 
118
118
  handler *file;
119
119
  Table **forms;                        /* head and ref forms */
120
120
  int (*read_record)(struct st_read_record *);
121
 
  Session *session;
 
121
  THD *thd;
122
122
  SQL_SELECT *select;
123
123
  uint32_t cache_records;
124
124
  uint32_t ref_length,struct_length,reclength,rec_cache_size,error_offset;
134
134
 
135
135
 
136
136
typedef struct {
137
 
  uint32_t year;
138
 
  uint32_t month;
139
 
  uint32_t day;
140
 
  uint32_t hour;
 
137
  ulong year,month,day,hour;
141
138
  uint64_t minute,second,second_part;
142
139
  bool neg;
143
140
} INTERVAL;
144
141
 
 
142
 
 
143
typedef struct st_known_date_time_format {
 
144
  const char *format_name;
 
145
  const char *date_format;
 
146
  const char *datetime_format;
 
147
  const char *time_format;
 
148
} KNOWN_DATE_TIME_FORMAT;
 
149
 
 
150
enum SHOW_COMP_OPTION { SHOW_OPTION_YES, SHOW_OPTION_NO, SHOW_OPTION_DISABLED};
 
151
 
145
152
extern const char *show_comp_option_name[];
146
153
 
147
 
typedef int *(*update_var)(Session *, struct st_mysql_show_var *);
 
154
typedef int *(*update_var)(THD *, struct st_mysql_show_var *);
148
155
 
149
156
typedef struct  st_lex_user {
150
157
  LEX_STRING user, host, password;
151
158
} LEX_USER;
152
159
 
 
160
/*
 
161
  This structure specifies the maximum amount of resources which
 
162
  can be consumed by each account. Zero value of a member means
 
163
  there is no limit.
 
164
*/
 
165
typedef struct user_resources {
 
166
  /* Maximum number of queries/statements per hour. */
 
167
  uint32_t questions;
 
168
  /*
 
169
     Maximum number of updating statements per hour (which statements are
 
170
     updating is defined by sql_command_flags array).
 
171
  */
 
172
  uint32_t updates;
 
173
  /* Maximum number of connections established per hour. */
 
174
  uint32_t conn_per_hour;
 
175
  /* Maximum number of concurrent connections. */
 
176
  uint32_t user_conn;
 
177
  /*
 
178
     Values of this enum and specified_limits member are used by the
 
179
     parser to store which user limits were specified in GRANT statement.
 
180
  */
 
181
  enum {QUERIES_PER_HOUR= 1, UPDATES_PER_HOUR= 2, CONNECTIONS_PER_HOUR= 4,
 
182
        USER_CONNECTIONS= 8};
 
183
  uint32_t specified_limits;
 
184
} USER_RESOURCES;
 
185
 
 
186
 
 
187
/*
 
188
  This structure is used for counting resources consumed and for checking
 
189
  them against specified user limits.
 
190
*/
 
191
typedef struct  user_conn {
 
192
  /*
 
193
     Pointer to user+host key (pair separated by '\0') defining the entity
 
194
     for which resources are counted (By default it is user account thus
 
195
     priv_user/priv_host pair is used. If --old-style-user-limits option
 
196
     is enabled, resources are counted for each user+host separately).
 
197
  */
 
198
  char *user;
 
199
  /* Pointer to host part of the key. */
 
200
  char *host;
 
201
  /**
 
202
     The moment of time when per hour counters were reset last time
 
203
     (i.e. start of "hour" for conn_per_hour, updates, questions counters).
 
204
  */
 
205
  uint64_t reset_utime;
 
206
  /* Total length of the key. */
 
207
  uint32_t len;
 
208
  /* Current amount of concurrent connections for this account. */
 
209
  uint32_t connections;
 
210
  /*
 
211
     Current number of connections per hour, number of updating statements
 
212
     per hour and total number of statements per hour for this account.
 
213
  */
 
214
  uint32_t conn_per_hour, updates, questions;
 
215
  /* Maximum amount of resources which account is allowed to consume. */
 
216
  USER_RESOURCES user_resources;
 
217
} USER_CONN;
 
218
 
153
219
        /* Bits in form->update */
154
220
#define REG_MAKE_DUPP           1       /* Make a copy of record when read */
155
221
#define REG_NEW_RECORD          2       /* Write a new record if not found */
172
238
#define STATUS_NULL_ROW         32      /* table->null_row is set */
173
239
#define STATUS_DELETED          64
174
240
 
175
 
#endif /* DRIZZLED_STRUCTS_H */
 
241
/*
 
242
  Such interval is "discrete": it is the set of
 
243
  { auto_inc_interval_min + k * increment,
 
244
    0 <= k <= (auto_inc_interval_values-1) }
 
245
  Where "increment" is maintained separately by the user of this class (and is
 
246
  currently only thd->variables.auto_increment_increment).
 
247
  It mustn't derive from Sql_alloc, because SET INSERT_ID needs to
 
248
  allocate memory which must stay allocated for use by the next statement.
 
249
*/
 
250
class Discrete_interval {
 
251
private:
 
252
  uint64_t interval_min;
 
253
  uint64_t interval_values;
 
254
  uint64_t  interval_max;    // excluded bound. Redundant.
 
255
public:
 
256
  Discrete_interval *next;    // used when linked into Discrete_intervals_list
 
257
  void replace(uint64_t start, uint64_t val, uint64_t incr)
 
258
  {
 
259
    interval_min=    start;
 
260
    interval_values= val;
 
261
    interval_max=    (val == UINT64_MAX) ? val : start + val * incr;
 
262
  }
 
263
  Discrete_interval(uint64_t start, uint64_t val, uint64_t incr) :
 
264
    next(NULL) { replace(start, val, incr); };
 
265
  Discrete_interval() : next(NULL) { replace(0, 0, 0); };
 
266
  uint64_t minimum() const { return interval_min;    };
 
267
  uint64_t values()  const { return interval_values; };
 
268
  uint64_t maximum() const { return interval_max;    };
 
269
  /*
 
270
    If appending [3,5] to [1,2], we merge both in [1,5] (they should have the
 
271
    same increment for that, user of the class has to ensure that). That is
 
272
    just a space optimization. Returns 0 if merge succeeded.
 
273
  */
 
274
  bool merge_if_contiguous(uint64_t start, uint64_t val, uint64_t incr)
 
275
  {
 
276
    if (interval_max == start)
 
277
    {
 
278
      if (val == UINT64_MAX)
 
279
      {
 
280
        interval_values=   interval_max= val;
 
281
      }
 
282
      else
 
283
      {
 
284
        interval_values+=  val;
 
285
        interval_max=      start + val * incr;
 
286
      }
 
287
      return 0;
 
288
    }
 
289
    return 1;
 
290
  };
 
291
};
 
292
 
 
293
/* List of Discrete_interval objects */
 
294
class Discrete_intervals_list {
 
295
private:
 
296
  Discrete_interval        *head;
 
297
  Discrete_interval        *tail;
 
298
  /*
 
299
    When many intervals are provided at the beginning of the execution of a
 
300
    statement (in a replication slave or SET INSERT_ID), "current" points to
 
301
    the interval being consumed by the thread now (so "current" goes from
 
302
    "head" to "tail" then to NULL).
 
303
  */
 
304
  Discrete_interval        *current;
 
305
  uint32_t                  elements; // number of elements
 
306
 
 
307
  /* helper function for copy construct and assignment operator */
 
308
  void copy_(const Discrete_intervals_list& from)
 
309
  {
 
310
    for (Discrete_interval *i= from.head; i; i= i->next)
 
311
    {
 
312
      Discrete_interval j= *i;
 
313
      append(&j);
 
314
    }
 
315
  }
 
316
public:
 
317
  Discrete_intervals_list() : head(NULL), current(NULL), elements(0) {};
 
318
  Discrete_intervals_list(const Discrete_intervals_list& from)
 
319
  {
 
320
    copy_(from);
 
321
  }
 
322
  void operator=(const Discrete_intervals_list& from)
 
323
  {
 
324
    empty();
 
325
    copy_(from);
 
326
  }
 
327
  void empty_no_free()
 
328
  {
 
329
    head= current= NULL;
 
330
    elements= 0;
 
331
  }
 
332
  void empty()
 
333
  {
 
334
    for (Discrete_interval *i= head; i;)
 
335
    {
 
336
      Discrete_interval *next= i->next;
 
337
      delete i;
 
338
      i= next;
 
339
    }
 
340
    empty_no_free();
 
341
  }
 
342
 
 
343
  const Discrete_interval* get_next()
 
344
  {
 
345
    Discrete_interval *tmp= current;
 
346
    if (current != NULL)
 
347
      current= current->next;
 
348
    return tmp;
 
349
  }
 
350
  ~Discrete_intervals_list() { empty(); };
 
351
  bool append(uint64_t start, uint64_t val, uint64_t incr);
 
352
  bool append(Discrete_interval *interval);
 
353
  uint64_t minimum()     const { return (head ? head->minimum() : 0); };
 
354
  uint64_t maximum()     const { return (head ? tail->maximum() : 0); };
 
355
  uint32_t      nb_elements() const { return elements; }
 
356
};