← 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-10-10 02:00:34 UTC
  • mfrom: (1830.1.5 trunk-drizzle)
  • Revision ID: brian@tangent.org-20101010020034-d67x3d09fssxq1v6
Merge rollup of utf8 and table encapsulation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/identifier/table.h
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
4
 *  Copyright (C) 2010 Brian Aker
5
 
 *  Copyright (C) 2009 Sun Microsystems, Inc.
 
5
 *  Copyright (C) 2009 Sun Microsystems
6
6
 *
7
7
 *  This program is free software; you can redistribute it and/or modify
8
8
 *  it under the terms of the GNU General Public License as published by
37
37
#include "drizzled/definitions.h"
38
38
#include "drizzled/message/table.pb.h"
39
39
 
 
40
#include "drizzled/identifier.h"
 
41
 
40
42
#include <string.h>
41
43
 
42
44
#include <assert.h>
48
50
 
49
51
#include <boost/functional/hash.hpp>
50
52
 
51
 
#include "drizzled/visibility.h"
52
 
 
53
53
namespace drizzled {
 
54
 
54
55
class Table;
55
56
 
56
 
namespace identifier {
57
 
 
58
 
class DRIZZLED_API Table : public Schema
 
57
class TableIdentifier : public SchemaIdentifier
59
58
{
60
59
public:
61
60
  typedef message::Table::TableType Type;
62
 
  typedef std::vector <Table> vector;
63
 
  typedef const Table& const_reference;
64
 
  typedef Table& reference;
65
 
 
66
 
  class Key
67
 
  {
68
 
    std::vector<char> key_buffer;
69
 
    size_t hash_value;
70
 
 
71
 
  public:
72
 
 
73
 
    Key() :
74
 
      hash_value(0)
75
 
    {
76
 
    }
77
 
 
78
 
    const char *vector() const
79
 
    {
80
 
      return &key_buffer[0];
81
 
    }
82
 
 
83
 
    std::vector<char> &vectorPtr()
84
 
    {
85
 
      return key_buffer;
86
 
    }
87
 
 
88
 
    void set(size_t resize_arg, const std::string &a, const std::string &b);
89
 
 
90
 
    friend bool operator==(const Key &left, const Key &right)
91
 
    {
92
 
      if (left.hash_value == right.hash_value and left.key_buffer.size() == right.key_buffer.size())
93
 
      {
94
 
        if (memcmp(&left.key_buffer[0], &right.key_buffer[0], left.key_buffer.size()) == 0)
95
 
          return true;
96
 
      }
97
 
 
98
 
      return false;
99
 
    }
100
 
 
101
 
    friend bool operator<(const Key &left, const Key &right)
102
 
    {
103
 
      return left.key_buffer < right.key_buffer;
104
 
    }
105
 
 
106
 
    size_t size() const
107
 
    {
108
 
      return key_buffer.size();
109
 
    }
110
 
 
111
 
    size_t getHashValue() const
112
 
    {
113
 
      return hash_value;
114
 
    }
115
 
  };
116
 
 
 
61
  typedef std::vector<char> Key;
117
62
private:
118
63
 
119
64
  Type type;
120
65
  std::string path;
121
 
  std::string key_path;
122
66
  std::string table_name;
 
67
  std::string sql_path;
123
68
  Key key;
124
69
  size_t hash_value;
125
70
 
131
76
  }
132
77
 
133
78
public:
134
 
 
135
 
  Table(const drizzled::Table &table);
 
79
  TableIdentifier(const Table &table);
136
80
                   
137
 
  Table(const identifier::Schema &schema,
138
 
        const std::string &table_name_arg,
139
 
        Type tmp_arg= message::Table::STANDARD) :
140
 
    Schema(schema),
141
 
    type(tmp_arg),
142
 
    table_name(table_name_arg)
143
 
  { 
144
 
    init();
145
 
  }
146
 
 
147
 
  Table( const std::string &db_arg,
148
 
                   const std::string &table_name_arg,
149
 
                   Type tmp_arg= message::Table::STANDARD) :
150
 
    Schema(db_arg),
151
 
    type(tmp_arg),
152
 
    table_name(table_name_arg)
153
 
  { 
154
 
    init();
155
 
  }
156
 
 
157
 
  Table( const std::string &schema_name_arg,
 
81
  TableIdentifier( const SchemaIdentifier &schema,
 
82
                   const std::string &table_name_arg,
 
83
                   Type tmp_arg= message::Table::STANDARD) :
 
84
    SchemaIdentifier(schema),
 
85
    type(tmp_arg),
 
86
    table_name(table_name_arg)
 
87
  { 
 
88
    init();
 
89
  }
 
90
 
 
91
  TableIdentifier( const std::string &db_arg,
 
92
                   const std::string &table_name_arg,
 
93
                   Type tmp_arg= message::Table::STANDARD) :
 
94
    SchemaIdentifier(db_arg),
 
95
    type(tmp_arg),
 
96
    table_name(table_name_arg)
 
97
  { 
 
98
    init();
 
99
  }
 
100
 
 
101
  TableIdentifier( const std::string &schema_name_arg,
158
102
                   const std::string &table_name_arg,
159
103
                   const std::string &path_arg ) :
160
 
    Schema(schema_name_arg),
 
104
    SchemaIdentifier(schema_name_arg),
161
105
    type(message::Table::TEMPORARY),
162
106
    path(path_arg),
163
107
    table_name(table_name_arg)
165
109
    init();
166
110
  }
167
111
 
168
 
  using Schema::compare;
 
112
  using SchemaIdentifier::compare;
169
113
 
170
114
  bool isTmp() const
171
115
  {
172
116
    if (type == message::Table::TEMPORARY || type == message::Table::INTERNAL)
173
117
      return true;
174
 
 
175
118
    return false;
176
119
  }
177
120
 
201
144
    return type;
202
145
  }
203
146
 
204
 
  virtual void getSQLPath(std::string &sql_path) const;
 
147
  const std::string &getSQLPath();
205
148
 
206
 
  virtual const std::string &getPath() const;
207
 
  const std::string &getKeyPath() const;
 
149
  const std::string &getPath() const;
208
150
 
209
151
  void setPath(const std::string &new_path)
210
152
  {
218
160
 
219
161
  void copyToTableMessage(message::Table &message) const;
220
162
 
221
 
  friend bool operator<(Table::const_reference left, Table::const_reference right)
 
163
  friend bool operator<(const TableIdentifier &left, const TableIdentifier &right)
222
164
  {
223
165
    if (left.getKey() < right.getKey())
224
166
    {
228
170
    return false;
229
171
  }
230
172
 
231
 
  friend bool operator==(Table::const_reference left, Table::const_reference right)
 
173
  friend std::ostream& operator<<(std::ostream& output, const TableIdentifier &identifier)
232
174
  {
233
 
    if (left.getHashValue() == right.getHashValue())
234
 
    {
235
 
      if (left.getKey() == right.getKey())
236
 
        return true;
 
175
    const char *type_str;
 
176
 
 
177
    output << "TableIdentifier:(";
 
178
    output <<  identifier.getSchemaName();
 
179
    output << ", ";
 
180
    output << identifier.getTableName();
 
181
    output << ", ";
 
182
 
 
183
    switch (identifier.type) {
 
184
    case message::Table::STANDARD:
 
185
      type_str= "standard";
 
186
      break;
 
187
    case message::Table::INTERNAL:
 
188
      type_str= "internal";
 
189
      break;
 
190
    case message::Table::TEMPORARY:
 
191
      type_str= "temporary";
 
192
      break;
 
193
    case message::Table::FUNCTION:
 
194
      type_str= "function";
 
195
      break;
237
196
    }
238
197
 
 
198
    output << type_str;
 
199
    output << ", ";
 
200
    output << identifier.path;
 
201
    output << ", ";
 
202
    output << identifier.getHashValue();
 
203
    output << ")";
 
204
 
 
205
    return output;  // for multiple << operators.
 
206
  }
 
207
 
 
208
  friend bool operator==(TableIdentifier &left, TableIdentifier &right)
 
209
  {
 
210
    if (left.getKey() == right.getKey())
 
211
      return true;
 
212
 
239
213
    return false;
240
214
  }
241
215
 
242
216
  static uint32_t filename_to_tablename(const char *from, char *to, uint32_t to_length);
243
 
  static size_t build_table_filename(std::string &path, const std::string &db, const std::string &table_name, bool is_tmp);
 
217
  static size_t build_table_filename(std::string &buff, const char *db, const char *table_name, bool is_tmp);
244
218
  static size_t build_tmptable_filename(std::string &buffer);
245
219
  static size_t build_tmptable_filename(std::vector<char> &buffer);
246
220
 
247
 
public:
248
 
  bool isValid() const;
 
221
  /*
 
222
    Create a table cache key
 
223
 
 
224
    SYNOPSIS
 
225
    createKey()
 
226
    key                 Create key here (must be of size MAX_DBKEY_LENGTH)
 
227
    table_list          Table definition
 
228
 
 
229
    IMPLEMENTATION
 
230
    The table cache_key is created from:
 
231
    db_name + \0
 
232
    table_name + \0
 
233
 
 
234
    if the table is a tmp table, we add the following to make each tmp table
 
235
    unique on the slave:
 
236
 
 
237
    4 bytes for master thread id
 
238
    4 bytes pseudo thread id
 
239
 
 
240
    RETURN
 
241
    Length of key
 
242
  */
 
243
  static uint32_t createKey(char *key, const char *db_arg, const char *table_name_arg)
 
244
  {
 
245
    uint32_t key_length;
 
246
    char *key_pos= key;
 
247
 
 
248
    key_pos= strcpy(key_pos, db_arg) + strlen(db_arg);
 
249
    key_pos= strcpy(key_pos+1, table_name_arg) +
 
250
      strlen(table_name_arg);
 
251
    key_length= (uint32_t)(key_pos-key)+1;
 
252
 
 
253
    return key_length;
 
254
  }
 
255
 
 
256
  static uint32_t createKey(char *key, const TableIdentifier &identifier)
 
257
  {
 
258
    uint32_t key_length;
 
259
    char *key_pos= key;
 
260
 
 
261
    key_pos= strcpy(key_pos, identifier.getSchemaName().c_str()) + identifier.getSchemaName().length();
 
262
    key_pos= strcpy(key_pos + 1, identifier.getTableName().c_str()) + identifier.getTableName().length();
 
263
    key_length= (uint32_t)(key_pos-key)+1;
 
264
 
 
265
    return key_length;
 
266
  }
249
267
 
250
268
  size_t getHashValue() const
251
269
  {
258
276
  }
259
277
};
260
278
 
261
 
std::ostream& operator<<(std::ostream& output, Table::const_reference identifier);
262
 
std::size_t hash_value(Table const& b);
263
 
std::size_t hash_value(Table::Key const& b);
264
 
 
265
 
} /* namespace identifier */
 
279
std::size_t hash_value(TableIdentifier const& b);
 
280
 
 
281
typedef std::vector <TableIdentifier> TableIdentifiers;
 
282
 
266
283
} /* namespace drizzled */
267
284
 
268
285
#endif /* DRIZZLED_IDENTIFIER_TABLE_H */