← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/discrete_interval.h

  • Committer: Stewart Smith
  • Date: 2008-11-21 16:06:07 UTC
  • mto: This revision was merged to the branch mainline in revision 593.
  • Revision ID: stewart@flamingspork.com-20081121160607-n6gdlt013spuo54r
remove mysql_frm_type
and fix engines to return correct value from delete_table when table doesn't exist.
(it should be ENOENT).

Also fix up some tests that manipulated frm files by hand. These tests are no longer valid and will need to be rewritten in the not too distant future.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/discrete_interval.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; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
 
21
 
#ifndef DRIZZLED_DISCRETE_INTERVAL_H
22
 
#define DRIZZLED_DISCRETE_INTERVAL_H
23
 
 
24
 
#include <cstdlib>
25
 
 
26
 
#include "drizzled/definitions.h"
27
 
 
28
 
namespace drizzled
29
 
{
30
 
 
31
 
/*
32
 
  Such interval is "discrete": it is the set of
33
 
  { auto_inc_interval_min + k * increment,
34
 
    0 <= k <= (auto_inc_interval_values-1) }
35
 
  Where "increment" is maintained separately by the user of this class (and is
36
 
  currently only session->variables.auto_increment_increment).
37
 
  It mustn't derive from memory::SqlAlloc, because SET INSERT_ID needs to
38
 
  allocate memory which must stay allocated for use by the next statement.
39
 
*/
40
 
class Discrete_interval {
41
 
private:
42
 
  uint64_t interval_min;
43
 
  uint64_t interval_values;
44
 
  uint64_t  interval_max;    // excluded bound. Redundant.
45
 
public:
46
 
  Discrete_interval *next;    // used when linked into Discrete_intervals_list
47
 
  void replace(uint64_t start, uint64_t val, uint64_t incr)
48
 
  {
49
 
    interval_min=    start;
50
 
    interval_values= val;
51
 
    interval_max=    (val == UINT64_MAX) ? val : start + val * incr;
52
 
  }
53
 
  Discrete_interval(uint64_t start, uint64_t val, uint64_t incr) :
54
 
    interval_min(start), interval_values(val),
55
 
    interval_max((val == UINT64_MAX) ? val : start + val * incr),
56
 
    next(NULL)
57
 
  {};
58
 
  Discrete_interval() :
59
 
    interval_min(0), interval_values(0),
60
 
    interval_max(0), next(NULL)
61
 
  {};
62
 
  uint64_t minimum() const { return interval_min;    };
63
 
  uint64_t values()  const { return interval_values; };
64
 
  uint64_t maximum() const { return interval_max;    };
65
 
  /*
66
 
    If appending [3,5] to [1,2], we merge both in [1,5] (they should have the
67
 
    same increment for that, user of the class has to ensure that). That is
68
 
    just a space optimization. Returns 0 if merge succeeded.
69
 
  */
70
 
  bool merge_if_contiguous(uint64_t start, uint64_t val, uint64_t incr)
71
 
  {
72
 
    if (interval_max == start)
73
 
    {
74
 
      if (val == UINT64_MAX)
75
 
      {
76
 
        interval_values=   interval_max= val;
77
 
      }
78
 
      else
79
 
      {
80
 
        interval_values+=  val;
81
 
        interval_max=      start + val * incr;
82
 
      }
83
 
      return 0;
84
 
    }
85
 
    return 1;
86
 
  };
87
 
};
88
 
 
89
 
 
90
 
 
91
 
/* List of Discrete_interval objects */
92
 
class Discrete_intervals_list {
93
 
private:
94
 
  Discrete_interval        *head;
95
 
  Discrete_interval        *tail;
96
 
  /*
97
 
    When many intervals are provided at the beginning of the execution of a
98
 
    statement (in a replication slave or SET INSERT_ID), "current" points to
99
 
    the interval being consumed by the thread now (so "current" goes from
100
 
    "head" to "tail" then to NULL).
101
 
  */
102
 
  Discrete_interval        *current;
103
 
  uint32_t                  elements; // number of elements
104
 
 
105
 
  /* helper function for copy construct and assignment operator */
106
 
  void copy_(const Discrete_intervals_list& from)
107
 
  {
108
 
    for (Discrete_interval *i= from.head; i; i= i->next)
109
 
    {
110
 
      Discrete_interval j= *i;
111
 
      append(&j);
112
 
    }
113
 
  }
114
 
public:
115
 
  Discrete_intervals_list() :
116
 
    head(NULL), tail(NULL),
117
 
    current(NULL), elements(0) {};
118
 
  Discrete_intervals_list(const Discrete_intervals_list& from) :
119
 
    head(NULL), tail(NULL),
120
 
    current(NULL), elements(0)
121
 
  {
122
 
    copy_(from);
123
 
  }
124
 
  Discrete_intervals_list& operator=(const Discrete_intervals_list& from)
125
 
  {
126
 
    empty();
127
 
    copy_(from);
128
 
    return *this;
129
 
  }
130
 
  void empty_no_free()
131
 
  {
132
 
    head= current= NULL;
133
 
    elements= 0;
134
 
  }
135
 
  void empty()
136
 
  {
137
 
    for (Discrete_interval *i= head; i;)
138
 
    {
139
 
      Discrete_interval *next= i->next;
140
 
      delete i;
141
 
      i= next;
142
 
    }
143
 
    empty_no_free();
144
 
  }
145
 
 
146
 
  const Discrete_interval* get_next()
147
 
  {
148
 
    Discrete_interval *tmp= current;
149
 
    if (current != NULL)
150
 
      current= current->next;
151
 
    return tmp;
152
 
  }
153
 
  ~Discrete_intervals_list() { empty(); };
154
 
  uint64_t minimum()     const { return (head ? head->minimum() : 0); };
155
 
  uint64_t maximum()     const { return (head ? tail->maximum() : 0); };
156
 
  uint32_t      nb_elements() const { return elements; }
157
 
 
158
 
  bool append(uint64_t start, uint64_t val, uint64_t incr)
159
 
  {
160
 
    /* first, see if this can be merged with previous */
161
 
    if ((head == NULL) || tail->merge_if_contiguous(start, val, incr))
162
 
    {
163
 
      /* it cannot, so need to add a new interval */
164
 
      Discrete_interval *new_interval= new Discrete_interval(start, val, incr);
165
 
      return(append(new_interval));
166
 
    }
167
 
    return(0);
168
 
  }
169
 
 
170
 
  bool append(Discrete_interval *new_interval)
171
 
  {
172
 
    if (unlikely(new_interval == NULL))
173
 
      return(1);
174
 
    if (head == NULL)
175
 
      head= current= new_interval;
176
 
    else
177
 
      tail->next= new_interval;
178
 
    tail= new_interval;
179
 
    elements++;
180
 
    return(0);
181
 
  }
182
 
 
183
 
};
184
 
 
185
 
} /* namespace drizzled */
186
 
 
187
 
#endif /* DRIZZLED_DISCRETE_INTERVAL_H */