← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_identifier.h

  • Committer: Brian Aker
  • Date: 2010-03-31 19:14:14 UTC
  • Revision ID: brian@gaz-20100331191414-9yv44mmpvf0tb7l1
Updated to use show schemas specific table.

Show diffs side-by-side

added added

removed removed

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