← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/identifier/table.h

  • Committer: lbieber
  • Date: 2010-10-02 19:48:35 UTC
  • mfrom: (1730.6.19 drizzle-make-lcov)
  • Revision ID: lbieber@orisndriz08-20101002194835-q5zd9qc4lvx1xnfo
Merge Hartmut - clean up lex, now require flex to build, also "make lcov" improvements

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
 
    return false;
176
 
  }
177
 
 
178
 
  static bool isView(message::Table::TableType arg) // Not a SQL view, but a view for I_S
179
 
  {
180
 
    switch (arg)
181
 
    {
182
 
    default:
183
 
    case message::Table::STANDARD:
184
 
    case message::Table::TEMPORARY:
185
 
    case message::Table::INTERNAL:
186
 
      break;
187
 
    case message::Table::FUNCTION:
188
 
      return true;
189
 
    }
190
 
 
191
118
    return false;
192
119
  }
193
120
 
194
121
  bool isView() const // Not a SQL view, but a view for I_S
195
122
  {
196
 
    return isView(type);
 
123
    if (type == message::Table::FUNCTION)
 
124
      return true;
 
125
    return false;
197
126
  }
198
127
 
199
128
  Type getType() const
201
130
    return type;
202
131
  }
203
132
 
204
 
  virtual void getSQLPath(std::string &sql_path) const;
 
133
  const std::string &getSQLPath();
205
134
 
206
 
  virtual const std::string &getPath() const;
207
 
  const std::string &getKeyPath() const;
 
135
  const std::string &getPath() const;
208
136
 
209
137
  void setPath(const std::string &new_path)
210
138
  {
218
146
 
219
147
  void copyToTableMessage(message::Table &message) const;
220
148
 
221
 
  friend bool operator<(Table::const_reference left, Table::const_reference right)
 
149
  friend bool operator<(const TableIdentifier &left, const TableIdentifier &right)
222
150
  {
223
151
    if (left.getKey() < right.getKey())
224
152
    {
228
156
    return false;
229
157
  }
230
158
 
231
 
  friend bool operator==(Table::const_reference left, Table::const_reference right)
 
159
  friend std::ostream& operator<<(std::ostream& output, const TableIdentifier &identifier)
232
160
  {
233
 
    if (left.getHashValue() == right.getHashValue())
234
 
    {
235
 
      if (left.getKey() == right.getKey())
236
 
        return true;
 
161
    const char *type_str;
 
162
 
 
163
    output << "TableIdentifier:(";
 
164
    output <<  identifier.getSchemaName();
 
165
    output << ", ";
 
166
    output << identifier.getTableName();
 
167
    output << ", ";
 
168
 
 
169
    switch (identifier.type) {
 
170
    case message::Table::STANDARD:
 
171
      type_str= "standard";
 
172
      break;
 
173
    case message::Table::INTERNAL:
 
174
      type_str= "internal";
 
175
      break;
 
176
    case message::Table::TEMPORARY:
 
177
      type_str= "temporary";
 
178
      break;
 
179
    case message::Table::FUNCTION:
 
180
      type_str= "function";
 
181
      break;
237
182
    }
238
183
 
 
184
    output << type_str;
 
185
    output << ", ";
 
186
    output << identifier.path;
 
187
    output << ", ";
 
188
    output << identifier.getHashValue();
 
189
    output << ")";
 
190
 
 
191
    return output;  // for multiple << operators.
 
192
  }
 
193
 
 
194
  friend bool operator==(TableIdentifier &left, TableIdentifier &right)
 
195
  {
 
196
    if (left.getKey() == right.getKey())
 
197
      return true;
 
198
 
239
199
    return false;
240
200
  }
241
201
 
242
202
  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);
 
203
  static size_t build_table_filename(std::string &buff, const char *db, const char *table_name, bool is_tmp);
244
204
  static size_t build_tmptable_filename(std::string &buffer);
245
205
  static size_t build_tmptable_filename(std::vector<char> &buffer);
246
206
 
247
 
public:
248
 
  bool isValid() const;
 
207
  /*
 
208
    Create a table cache key
 
209
 
 
210
    SYNOPSIS
 
211
    createKey()
 
212
    key                 Create key here (must be of size MAX_DBKEY_LENGTH)
 
213
    table_list          Table definition
 
214
 
 
215
    IMPLEMENTATION
 
216
    The table cache_key is created from:
 
217
    db_name + \0
 
218
    table_name + \0
 
219
 
 
220
    if the table is a tmp table, we add the following to make each tmp table
 
221
    unique on the slave:
 
222
 
 
223
    4 bytes for master thread id
 
224
    4 bytes pseudo thread id
 
225
 
 
226
    RETURN
 
227
    Length of key
 
228
  */
 
229
  static uint32_t createKey(char *key, const char *db_arg, const char *table_name_arg)
 
230
  {
 
231
    uint32_t key_length;
 
232
    char *key_pos= key;
 
233
 
 
234
    key_pos= strcpy(key_pos, db_arg) + strlen(db_arg);
 
235
    key_pos= strcpy(key_pos+1, table_name_arg) +
 
236
      strlen(table_name_arg);
 
237
    key_length= (uint32_t)(key_pos-key)+1;
 
238
 
 
239
    return key_length;
 
240
  }
 
241
 
 
242
  static uint32_t createKey(char *key, const TableIdentifier &identifier)
 
243
  {
 
244
    uint32_t key_length;
 
245
    char *key_pos= key;
 
246
 
 
247
    key_pos= strcpy(key_pos, identifier.getSchemaName().c_str()) + identifier.getSchemaName().length();
 
248
    key_pos= strcpy(key_pos + 1, identifier.getTableName().c_str()) + identifier.getTableName().length();
 
249
    key_length= (uint32_t)(key_pos-key)+1;
 
250
 
 
251
    return key_length;
 
252
  }
249
253
 
250
254
  size_t getHashValue() const
251
255
  {
258
262
  }
259
263
};
260
264
 
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 */
 
265
std::size_t hash_value(TableIdentifier const& b);
 
266
 
 
267
typedef std::vector <TableIdentifier> TableIdentifiers;
 
268
 
266
269
} /* namespace drizzled */
267
270
 
268
271
#endif /* DRIZZLED_IDENTIFIER_TABLE_H */