← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/structs.h

pandora-build v0.71. Added check for avahi.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/structs.h
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
 
 
 
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
 */
16
20
 
17
21
/* The old structures from unireg */
18
22
 
19
 
struct st_table;
 
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
class Table;
20
31
class Field;
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
 
 
 
32
typedef struct st_io_cache IO_CACHE;
29
33
 
30
34
typedef struct st_keyfile_info {        /* used with ha_info() */
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
  unsigned char ref[MAX_REFLENGTH];             /* Pointer to current row */
 
36
  unsigned char dupp_ref[MAX_REFLENGTH];        /* Pointer to dupp row */
 
37
  uint32_t ref_length;                  /* Length of ref (1-8) */
 
38
  uint32_t block_size;                  /* index block size */
35
39
  File filenr;                          /* (uniq) filenr for table */
36
40
  ha_rows records;                      /* Records i datafilen */
37
41
  ha_rows deleted;                      /* Deleted records */
45
49
  time_t create_time;                   /* When table was created */
46
50
  time_t check_time;
47
51
  time_t update_time;
48
 
  ulong mean_rec_length;                /* physical reclength */
 
52
  uint64_t mean_rec_length;             /* physical reclength */
49
53
} KEYFILE_INFO;
50
54
 
51
55
 
74
78
 
75
79
typedef struct st_key {
76
80
  uint  key_length;                     /* Tot length of key */
 
81
  enum  ha_key_alg algorithm;
77
82
  ulong flags;                          /* dupp key and pack flags */
78
83
  uint  key_parts;                      /* How many key_parts */
79
 
  uint  extra_length;
 
84
  uint32_t  extra_length;
80
85
  uint  usable_key_parts;               /* Should normally be = key_parts */
81
 
  uint  block_size;
82
 
  enum  ha_key_alg algorithm;
 
86
  uint32_t  block_size;
83
87
  KEY_PART_INFO *key_part;
84
88
  char  *name;                          /* Name of key */
85
89
  /*
88
92
    For temporary heap tables this member is NULL.
89
93
  */
90
94
  ulong *rec_per_key;
91
 
  struct st_table *table;
 
95
  Table *table;
92
96
  LEX_STRING comment;
93
97
} KEY;
94
98
 
95
99
 
96
 
struct st_join_table;
 
100
class JoinTable;
97
101
 
98
 
typedef struct st_reginfo {             /* Extra info about reg */
99
 
  struct st_join_table *join_tab;       /* Used by SELECT() */
 
102
struct RegInfo {                /* Extra info about reg */
 
103
  JoinTable *join_tab;  /* Used by SELECT() */
100
104
  enum thr_lock_type lock_type;         /* How database is used */
101
105
  bool not_exists_optimize;
102
106
  bool impossible_range;
103
 
} REGINFO;
104
 
 
 
107
  RegInfo()
 
108
    : join_tab(NULL), lock_type(TL_UNLOCK),
 
109
      not_exists_optimize(false), impossible_range(false) {}
 
110
  void reset()
 
111
  {
 
112
    join_tab= NULL;
 
113
    lock_type= TL_UNLOCK;
 
114
    not_exists_optimize= false;
 
115
    impossible_range= false;
 
116
  }
 
117
};
105
118
 
106
119
struct st_read_record;                          /* For referense later */
107
120
class SQL_SELECT;
108
 
class THD;
109
 
class handler;
110
 
struct st_join_table;
 
121
class Session;
 
122
class Cursor;
111
123
 
112
124
typedef struct st_read_record {                 /* Parameter to read_record */
113
 
  struct st_table *table;                       /* Head-form */
114
 
  handler *file;
115
 
  struct st_table **forms;                      /* head and ref forms */
 
125
  Table *table;                 /* Head-form */
 
126
  Cursor *cursor;
 
127
  Table **forms;                        /* head and ref forms */
116
128
  int (*read_record)(struct st_read_record *);
117
 
  THD *thd;
 
129
  Session *session;
118
130
  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;
 
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;
126
138
  IO_CACHE *io_cache;
127
139
  bool print_error, ignore_not_found_rows;
128
 
  struct st_join_table *do_insideout_scan;
 
140
  JoinTable *do_insideout_scan;
129
141
} READ_RECORD;
130
142
 
131
 
 
132
 
/*
133
 
  Originally MySQL used DRIZZLE_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_drizzle_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
143
extern const char *show_comp_option_name[];
158
144
 
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
 
145
typedef int *(*update_var)(Session *, struct st_mysql_show_var *);
235
146
 
236
147
        /* Bits in form->status */
237
148
#define STATUS_NO_RECORD        (1+2)   /* Record isn't usably */
243
154
#define STATUS_NULL_ROW         32      /* table->null_row is set */
244
155
#define STATUS_DELETED          64
245
156
 
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
 
};
 
157
#endif /* DRIZZLED_STRUCTS_H */