← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/identifier/table.h

  • Committer: Brian Aker
  • Date: 2010-11-08 18:54:26 UTC
  • mto: (1921.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 1916.
  • Revision ID: brian@tangent.org-20101108185426-fymkf2xnelupf11x
Rename lock methods to be style + well make sense.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/identifier/table.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) 2010 Brian Aker
4
5
 *  Copyright (C) 2009 Sun Microsystems
5
6
 *
6
7
 *  This program is free software; you can redistribute it and/or modify
29
30
  This will replace Table_ident.
30
31
  */
31
32
 
32
 
#ifndef DRIZZLED_TABLE_IDENTIFIER_H
33
 
#define DRIZZLED_TABLE_IDENTIFIER_H
 
33
#ifndef DRIZZLED_IDENTIFIER_TABLE_H
 
34
#define DRIZZLED_IDENTIFIER_TABLE_H
34
35
 
35
36
#include <drizzled/enum.h>
36
37
#include "drizzled/definitions.h"
37
38
#include "drizzled/message/table.pb.h"
38
39
 
39
 
#include "drizzled/schema_identifier.h"
 
40
#include "drizzled/identifier.h"
40
41
 
41
42
#include <string.h>
42
43
 
47
48
#include <algorithm>
48
49
#include <functional>
49
50
 
 
51
#include <boost/functional/hash.hpp>
 
52
 
50
53
namespace drizzled {
51
54
 
52
55
class Table;
53
56
 
54
 
uint32_t filename_to_tablename(const char *from, char *to, uint32_t to_length);
55
 
size_t build_table_filename(std::string &buff, const char *db, const char *table_name, bool is_tmp);
56
 
 
57
57
class TableIdentifier : public SchemaIdentifier
58
58
{
59
59
public:
60
60
  typedef message::Table::TableType Type;
 
61
 
 
62
  class Key
 
63
  {
 
64
    std::vector<char> key_buffer;
 
65
    size_t hash_value;
 
66
 
 
67
  public:
 
68
 
 
69
    Key() :
 
70
      hash_value(0)
 
71
    {
 
72
    }
 
73
 
 
74
    const char *vector() const
 
75
    {
 
76
      return &key_buffer[0];
 
77
    }
 
78
 
 
79
    std::vector<char> &vectorPtr()
 
80
    {
 
81
      return key_buffer;
 
82
    }
 
83
 
 
84
    void set(size_t resize_arg, const std::string &a, const std::string &b);
 
85
 
 
86
    friend bool operator==(const Key &left, const Key &right)
 
87
    {
 
88
      if (left.hash_value == right.hash_value and left.key_buffer.size() == right.key_buffer.size())
 
89
      {
 
90
        if (memcmp(&left.key_buffer[0], &right.key_buffer[0], left.key_buffer.size()) == 0)
 
91
          return true;
 
92
      }
 
93
 
 
94
      return false;
 
95
    }
 
96
 
 
97
    friend bool operator<(const Key &left, const Key &right)
 
98
    {
 
99
      return left.key_buffer < right.key_buffer;
 
100
    }
 
101
 
 
102
    size_t size() const
 
103
    {
 
104
      return key_buffer.size();
 
105
    }
 
106
 
 
107
    size_t getHashValue() const
 
108
    {
 
109
      return hash_value;
 
110
    }
 
111
  };
 
112
 
61
113
private:
62
114
 
63
115
  Type type;
64
116
  std::string path;
65
117
  std::string table_name;
66
 
  std::string lower_table_name;
67
118
  std::string sql_path;
 
119
  Key key;
 
120
  size_t hash_value;
68
121
 
69
122
  void init();
70
123
 
 
124
  size_t getKeySize() const
 
125
  {
 
126
    return getSchemaName().size() + getTableName().size() + 2;
 
127
  }
 
128
 
71
129
public:
72
130
  TableIdentifier(const Table &table);
73
131
                   
103
161
  }
104
162
 
105
163
  using SchemaIdentifier::compare;
106
 
  bool compare(std::string schema_arg, std::string table_arg);
107
164
 
108
165
  bool isTmp() const
109
166
  {
112
169
    return false;
113
170
  }
114
171
 
 
172
  static bool isView(message::Table::TableType arg) // Not a SQL view, but a view for I_S
 
173
  {
 
174
    switch (arg)
 
175
    {
 
176
    default:
 
177
    case message::Table::STANDARD:
 
178
    case message::Table::TEMPORARY:
 
179
    case message::Table::INTERNAL:
 
180
      break;
 
181
    case message::Table::FUNCTION:
 
182
      return true;
 
183
    }
 
184
 
 
185
    return false;
 
186
  }
 
187
 
 
188
  bool isView() const // Not a SQL view, but a view for I_S
 
189
  {
 
190
    return isView(type);
 
191
  }
 
192
 
115
193
  Type getType() const
116
194
  {
117
195
    return type;
119
197
 
120
198
  const std::string &getSQLPath();
121
199
 
122
 
  const std::string &getPath();
 
200
  const std::string &getPath() const;
123
201
 
124
202
  void setPath(const std::string &new_path)
125
203
  {
131
209
    return table_name;
132
210
  }
133
211
 
134
 
  void copyToTableMessage(message::Table &message);
 
212
  void copyToTableMessage(message::Table &message) const;
135
213
 
136
 
  bool operator<(TableIdentifier &right)
 
214
  friend bool operator<(const TableIdentifier &left, const TableIdentifier &right)
137
215
  {
138
 
    int first= getLower().compare(right.getLower());
139
 
 
140
 
    if (first < 0)
 
216
    if (left.getKey() < right.getKey())
141
217
    {
142
218
      return true;
143
219
    }
144
 
    else if (first > 0)
145
 
    {
146
 
      return false;
147
 
    }
148
 
    else
149
 
    {
150
 
      int val= lower_table_name.compare(right.lower_table_name);
151
 
 
152
 
      if (val < 0)
153
 
      {
154
 
        return true;
155
 
      }
156
 
      else if (val > 0)
157
 
      {
158
 
        return false;
159
 
      }
160
 
      else
161
 
      {
162
 
        if (type < right.type)
163
 
        {
164
 
          return true;
165
 
        }
166
 
      }
167
 
    }
168
220
 
169
221
    return false;
170
222
  }
197
249
    output << type_str;
198
250
    output << ", ";
199
251
    output << identifier.path;
 
252
    output << ", ";
 
253
    output << identifier.getHashValue();
200
254
    output << ")";
201
255
 
202
256
    return output;  // for multiple << operators.
204
258
 
205
259
  friend bool operator==(TableIdentifier &left, TableIdentifier &right)
206
260
  {
207
 
    if (left.type == right.type)
 
261
    if (left.getHashValue() == right.getHashValue())
208
262
    {
209
 
      if (static_cast<SchemaIdentifier &>(left) == static_cast<SchemaIdentifier &>(right))
210
 
      {
211
 
        if (left.lower_table_name == right.lower_table_name)
212
 
        {
213
 
          return true;
214
 
        }
215
 
      }
 
263
      if (left.getKey() == right.getKey())
 
264
        return true;
216
265
    }
217
266
 
218
267
    return false;
219
268
  }
220
269
 
 
270
  static uint32_t filename_to_tablename(const char *from, char *to, uint32_t to_length);
 
271
  static size_t build_table_filename(std::string &path, const std::string &db, const std::string &table_name, bool is_tmp);
 
272
  static size_t build_tmptable_filename(std::string &buffer);
 
273
  static size_t build_tmptable_filename(std::vector<char> &buffer);
 
274
 
 
275
public:
 
276
 
 
277
  size_t getHashValue() const
 
278
  {
 
279
    return hash_value;
 
280
  }
 
281
 
 
282
  const Key &getKey() const
 
283
  {
 
284
    return key;
 
285
  }
221
286
};
222
287
 
223
 
typedef std::vector <TableIdentifier> TableIdentifierList;
224
 
typedef std::list <TableIdentifier> TableIdentifiers;
 
288
std::size_t hash_value(TableIdentifier const& b);
 
289
std::size_t hash_value(TableIdentifier::Key const& b);
 
290
 
 
291
typedef std::vector <TableIdentifier> TableIdentifiers;
225
292
 
226
293
} /* namespace drizzled */
227
294
 
228
 
#endif /* DRIZZLED_TABLE_IDENTIFIER_H */
 
295
#endif /* DRIZZLED_IDENTIFIER_TABLE_H */