← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/structs.h

  • Committer: Jay Pipes
  • Date: 2008-09-09 20:10:57 UTC
  • mto: (383.2.4 fix-failing-tests)
  • mto: This revision was merged to the branch mainline in revision 386.
  • Revision ID: jay@mysql.com-20080909201057-3qkgcxqaps2s58y9
Re-enabled a number of passing tests from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/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 <mysys/definitions.h>
28
 
#include <drizzled/lex_string.h>
29
 
 
30
19
class Table;
31
20
class Field;
32
 
typedef struct st_io_cache IO_CACHE;
33
21
 
34
22
typedef struct st_date_time_format {
35
 
  unsigned char positions[8];
 
23
  uchar positions[8];
36
24
  char  time_separator;                 /* Separator between hour and minute */
37
 
  uint32_t flag;                                /* For future */
 
25
  uint flag;                            /* For future */
38
26
  LEX_STRING format;
39
27
} DATE_TIME_FORMAT;
40
28
 
41
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 */
 
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 */
47
35
  File filenr;                          /* (uniq) filenr for table */
48
36
  ha_rows records;                      /* Records i datafilen */
49
37
  ha_rows deleted;                      /* Deleted records */
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
 
88
76
  uint  key_length;                     /* Tot length of key */
89
77
  ulong flags;                          /* dupp key and pack flags */
90
78
  uint  key_parts;                      /* How many key_parts */
91
 
  uint32_t  extra_length;
 
79
  uint  extra_length;
92
80
  uint  usable_key_parts;               /* Should normally be = key_parts */
93
 
  uint32_t  block_size;
 
81
  uint  block_size;
94
82
  enum  ha_key_alg algorithm;
95
83
  KEY_PART_INFO *key_part;
96
84
  char  *name;                          /* Name of key */
117
105
 
118
106
struct st_read_record;                          /* For referense later */
119
107
class SQL_SELECT;
120
 
class Session;
 
108
class THD;
121
109
class handler;
122
110
struct st_join_table;
123
111
 
126
114
  handler *file;
127
115
  Table **forms;                        /* head and ref forms */
128
116
  int (*read_record)(struct st_read_record *);
129
 
  Session *session;
 
117
  THD *thd;
130
118
  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;
 
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;
138
126
  IO_CACHE *io_cache;
139
127
  bool print_error, ignore_not_found_rows;
140
128
  struct st_join_table *do_insideout_scan;
141
129
} READ_RECORD;
142
130
 
143
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
 
144
141
typedef struct {
145
 
  uint32_t year;
146
 
  uint32_t month;
147
 
  uint32_t day;
148
 
  uint32_t hour;
 
142
  ulong year,month,day,hour;
149
143
  uint64_t minute,second,second_part;
150
144
  bool neg;
151
145
} INTERVAL;
158
152
  const char *time_format;
159
153
} KNOWN_DATE_TIME_FORMAT;
160
154
 
 
155
enum SHOW_COMP_OPTION { SHOW_OPTION_YES, SHOW_OPTION_NO, SHOW_OPTION_DISABLED};
161
156
 
162
157
extern const char *show_comp_option_name[];
163
158
 
164
 
typedef int *(*update_var)(Session *, struct st_mysql_show_var *);
 
159
typedef int *(*update_var)(THD *, struct st_mysql_show_var *);
165
160
 
166
161
typedef struct  st_lex_user {
167
162
  LEX_STRING user, host, password;
174
169
*/
175
170
typedef struct user_resources {
176
171
  /* Maximum number of queries/statements per hour. */
177
 
  uint32_t questions;
 
172
  uint questions;
178
173
  /*
179
174
     Maximum number of updating statements per hour (which statements are
180
175
     updating is defined by sql_command_flags array).
181
176
  */
182
 
  uint32_t updates;
 
177
  uint updates;
183
178
  /* Maximum number of connections established per hour. */
184
 
  uint32_t conn_per_hour;
 
179
  uint conn_per_hour;
185
180
  /* Maximum number of concurrent connections. */
186
 
  uint32_t user_conn;
 
181
  uint user_conn;
187
182
  /*
188
183
     Values of this enum and specified_limits member are used by the
189
184
     parser to store which user limits were specified in GRANT statement.
190
185
  */
191
186
  enum {QUERIES_PER_HOUR= 1, UPDATES_PER_HOUR= 2, CONNECTIONS_PER_HOUR= 4,
192
187
        USER_CONNECTIONS= 8};
193
 
  uint32_t specified_limits;
 
188
  uint specified_limits;
194
189
} USER_RESOURCES;
195
190
 
196
191
 
214
209
  */
215
210
  uint64_t reset_utime;
216
211
  /* Total length of the key. */
217
 
  uint32_t len;
 
212
  uint len;
218
213
  /* Current amount of concurrent connections for this account. */
219
 
  uint32_t connections;
 
214
  uint connections;
220
215
  /*
221
216
     Current number of connections per hour, number of updating statements
222
217
     per hour and total number of statements per hour for this account.
223
218
  */
224
 
  uint32_t conn_per_hour, updates, questions;
 
219
  uint conn_per_hour, updates, questions;
225
220
  /* Maximum amount of resources which account is allowed to consume. */
226
221
  USER_RESOURCES user_resources;
227
222
} USER_CONN;
253
248
  { auto_inc_interval_min + k * increment,
254
249
    0 <= k <= (auto_inc_interval_values-1) }
255
250
  Where "increment" is maintained separately by the user of this class (and is
256
 
  currently only session->variables.auto_increment_increment).
 
251
  currently only thd->variables.auto_increment_increment).
257
252
  It mustn't derive from Sql_alloc, because SET INSERT_ID needs to
258
253
  allocate memory which must stay allocated for use by the next statement.
259
254
*/
271
266
    interval_max=    (val == UINT64_MAX) ? val : start + val * incr;
272
267
  }
273
268
  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
 
  {};
 
269
    next(NULL) { replace(start, val, incr); };
 
270
  Discrete_interval() : next(NULL) { replace(0, 0, 0); };
282
271
  uint64_t minimum() const { return interval_min;    };
283
272
  uint64_t values()  const { return interval_values; };
284
273
  uint64_t maximum() const { return interval_max;    };
318
307
    "head" to "tail" then to NULL).
319
308
  */
320
309
  Discrete_interval        *current;
321
 
  uint32_t                  elements; // number of elements
 
310
  uint                  elements; // number of elements
322
311
 
323
312
  /* helper function for copy construct and assignment operator */
324
313
  void copy_(const Discrete_intervals_list& from)
330
319
    }
331
320
  }
332
321
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)
 
322
  Discrete_intervals_list() : head(NULL), current(NULL), elements(0) {};
 
323
  Discrete_intervals_list(const Discrete_intervals_list& from)
339
324
  {
340
325
    copy_(from);
341
326
  }
342
 
  Discrete_intervals_list& operator=(const Discrete_intervals_list& from)
 
327
  void operator=(const Discrete_intervals_list& from)
343
328
  {
344
329
    empty();
345
330
    copy_(from);
346
 
    return *this;
347
331
  }
348
332
  void empty_no_free()
349
333
  {
373
357
  bool append(Discrete_interval *interval);
374
358
  uint64_t minimum()     const { return (head ? head->minimum() : 0); };
375
359
  uint64_t maximum()     const { return (head ? tail->maximum() : 0); };
376
 
  uint32_t      nb_elements() const { return elements; }
 
360
  uint      nb_elements() const { return elements; }
377
361
};
378
 
 
379
 
#endif /* DRIZZLED_STRUCTS_H */