← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table/instance/base.h

  • Committer: Mark Atwood
  • Date: 2011-08-21 06:56:57 UTC
  • mfrom: (2385.3.34 rf)
  • Revision ID: me@mark.atwood.name-20110821065657-vk2at03z9u17mf1d
merge lp:~olafvdspek/drizzle/refactor7

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table/instance/base.h
39
39
#include <drizzled/lex_string.h>
40
40
#include <drizzled/key_map.h>
41
41
#include <drizzled/field.h>
 
42
#include <drizzled/util/find_ptr.h>
42
43
 
43
44
namespace drizzled {
44
45
 
147
148
 
148
149
private:
149
150
  /* hash of field names (contains pointers to elements of field array) */
150
 
  typedef boost::unordered_map < std::string, Field **, util::insensitive_hash, util::insensitive_equal_to> FieldMap;
151
 
  typedef std::pair< std::string, Field ** > FieldMapPair;
 
151
  typedef boost::unordered_map<std::string, Field**, util::insensitive_hash, util::insensitive_equal_to> FieldMap;
152
152
  FieldMap name_hash; /* hash of field names */
153
153
 
154
154
public:
159
159
 
160
160
  Field **getNamedField(const std::string &arg)
161
161
  {
162
 
    FieldMap::iterator iter= name_hash.find(arg);
163
 
 
164
 
    if (iter == name_hash.end())
165
 
        return 0;
166
 
 
167
 
    return iter->second;
 
162
    return find_ptr2(name_hash, arg);
168
163
  }
169
164
 
170
165
private:
180
175
    return mem_root;
181
176
  }
182
177
 
183
 
  std::vector<std::string> _keynames;
 
178
  typedef std::vector<std::string> keynames_t;
 
179
 
 
180
  keynames_t _keynames;
184
181
 
185
182
  void addKeyName(const std::string& arg)
186
183
  {
188
185
  }
189
186
 
190
187
public:
191
 
  bool doesKeyNameExist(const char *name_arg, uint32_t name_length, uint32_t &position) const
192
 
  {
193
 
    return doesKeyNameExist(std::string(name_arg, name_length), position);
194
 
  }
195
 
 
196
 
  bool doesKeyNameExist(const std::string& arg, uint32_t &position) const
197
 
  {
198
 
    std::vector<std::string>::const_iterator iter= std::find(_keynames.begin(), _keynames.end(), boost::to_upper_copy(arg));
199
 
 
200
 
    if (iter == _keynames.end())
201
 
    {
202
 
      position= UINT32_MAX; //historical, required for finding primary key from unique
203
 
      return false;
204
 
    }
205
 
 
206
 
    position= iter -  _keynames.begin();
207
 
    return true;
 
188
  uint32_t doesKeyNameExist(const std::string& arg) const
 
189
  {
 
190
    keynames_t::const_iterator it= find(_keynames.begin(), _keynames.end(), boost::to_upper_copy(arg));
 
191
    return it == _keynames.end() ? UINT32_MAX : it - _keynames.begin(); // historical, required for finding primary key from unique
208
192
  }
209
193
 
210
194
private:
248
232
private:
249
233
  identifier::Table::Key private_key_for_cache; // This will not exist in the final design.
250
234
  std::vector<char> private_normalized_path; // This will not exist in the final design.
251
 
  lex_string_t db;                        /* Pointer to db */
252
 
  lex_string_t table_name;                /* Table name (for open) */
253
 
  lex_string_t path;    /* Path to table (from datadir) */
254
 
  lex_string_t normalized_path;         /* unpack_filename(path) */
 
235
  str_ref db;                        /* Pointer to db */
 
236
  str_ref table_name;                /* Table name (for open) */
 
237
  str_ref path; /* Path to table (from datadir) */
 
238
  str_ref normalized_path;              /* unpack_filename(path) */
255
239
 
256
240
public:
257
241
 
258
242
  const char *getNormalizedPath() const
259
243
  {
260
 
    return normalized_path.str;
 
244
    return normalized_path.data();
261
245
  }
262
246
 
263
247
  const char *getPath() const
264
248
  {
265
 
    return path.str;
 
249
    return path.data();
266
250
  }
267
251
 
268
252
  const identifier::Table::Key& getCacheKey() const // This should never be called when we aren't looking at a cache.
276
260
    return private_key_for_cache.size();
277
261
  }
278
262
 
279
 
private:
280
 
  void setPath(char *str_arg, uint32_t size_arg)
281
 
  {
282
 
    path.str= str_arg;
283
 
    path.length= size_arg;
284
 
  }
285
 
 
286
 
  void setNormalizedPath(char *str_arg, uint32_t size_arg)
287
 
  {
288
 
    normalized_path.str= str_arg;
289
 
    normalized_path.length= size_arg;
290
 
  }
291
 
 
292
 
public:
293
263
  str_ref getTableNameRef() const
294
264
  {
295
265
    return table_name;
297
267
 
298
268
  const char *getTableName() const
299
269
  {
300
 
    return table_name.str;
 
270
    return table_name.data();
301
271
  }
302
272
 
303
273
  str_ref getSchemaNameRef() const
307
277
 
308
278
  const char *getSchemaName() const
309
279
  {
310
 
    return db.str;
 
280
    return db.data();
311
281
  }
312
282
 
313
283
  uint32_t   block_size;                   /* create information */