← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/identifier/table.cc

  • Committer: Mark Atwood
  • Date: 2011-08-01 05:22:14 UTC
  • mfrom: (1919.3.53 drizzle_pbms)
  • Revision ID: me@mark.atwood.name-20110801052214-3wdsx3xgld6b5v4f
merge lp:~barry-leslie/drizzle/drizzle_pbms

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/identifier/table.cc
133
133
static uint32_t get_counter()
134
134
{
135
135
  boost::mutex::scoped_lock lock(counter_mutex);
136
 
  return ++counter;
 
136
  uint32_t x;
 
137
  x= ++counter;
 
138
 
 
139
  return x;
137
140
}
138
141
 
139
142
#endif
140
143
 
141
 
std::string Table::build_tmptable_filename()
142
 
{
143
 
  ostringstream os;
144
 
  os << "/" << TMP_FILE_PREFIX << current_pid << pthread_self() << "-" << get_counter();
145
 
  return drizzle_tmpdir + boost::to_lower_copy(os.str());
146
 
}
 
144
size_t Table::build_tmptable_filename(std::string &buffer)
 
145
{
 
146
  ostringstream post_tmpdir_str;
 
147
 
 
148
  buffer.append(drizzle_tmpdir);
 
149
  size_t tmpdir_length= buffer.length();
 
150
 
 
151
  post_tmpdir_str << "/" << TMP_FILE_PREFIX << current_pid;
 
152
  post_tmpdir_str << pthread_self() << "-" << get_counter();
 
153
 
 
154
  buffer.append(post_tmpdir_str.str());
 
155
 
 
156
  transform(buffer.begin() + tmpdir_length, buffer.end(), buffer.begin() + tmpdir_length, ::tolower);
 
157
 
 
158
  return buffer.length();
 
159
}
 
160
 
 
161
size_t Table::build_tmptable_filename(std::vector<char> &buffer)
 
162
{
 
163
  ostringstream post_tmpdir_str;
 
164
 
 
165
  post_tmpdir_str << drizzle_tmpdir << "/" << TMP_FILE_PREFIX << current_pid;
 
166
  post_tmpdir_str << pthread_self() << "-" << get_counter();
 
167
 
 
168
  buffer.resize(post_tmpdir_str.str().length() + 1);
 
169
  memcpy(&buffer[0], post_tmpdir_str.str().c_str(), post_tmpdir_str.str().size());
 
170
  buffer[post_tmpdir_str.str().size()]= 0;
 
171
 
 
172
  return buffer.size();
 
173
}
 
174
 
147
175
 
148
176
/*
149
177
  Creates path to a cursor: drizzle_data_dir/db/table.ext
177
205
    path length on success, 0 on failure
178
206
*/
179
207
 
180
 
std::string Table::build_table_filename(const std::string &in_db, const std::string &in_table_name, bool is_tmp)
 
208
size_t Table::build_table_filename(std::string &in_path, const std::string &in_db, const std::string &in_table_name, bool is_tmp)
181
209
{
182
 
  string in_path= util::tablename_to_filename(in_db) + FN_LIBCHAR;
183
 
  return in_path + (is_tmp ? in_table_name : util::tablename_to_filename(in_table_name));
 
210
  if (util::tablename_to_filename(in_db, in_path))
 
211
  {
 
212
    errmsg_printf(error::ERROR, _("Schema name cannot be encoded and fit within filesystem name length restrictions."));
 
213
    return 0;
 
214
  }
 
215
 
 
216
  in_path.append(FN_ROOTDIR);
 
217
 
 
218
  if (is_tmp) // It a conversion tmp
 
219
  {
 
220
    in_path.append(in_table_name);
 
221
  }
 
222
  else if (util::tablename_to_filename(in_table_name, in_path))
 
223
  {
 
224
    errmsg_printf(error::ERROR, _("Table name cannot be encoded and fit within filesystem name length restrictions."));
 
225
    return 0;
 
226
  }
 
227
   
 
228
  return in_path.length();
184
229
}
185
230
 
186
231
Table::Table(const drizzled::Table &table) :
196
241
 
197
242
void Table::init()
198
243
{
199
 
  switch (type) 
200
 
  {
 
244
  switch (type) {
201
245
  case message::Table::FUNCTION:
202
246
  case message::Table::STANDARD:
203
 
    assert(path.empty());
204
 
    path= build_table_filename(getSchemaName(), table_name, false);
 
247
    assert(path.size() == 0);
 
248
    build_table_filename(path, getSchemaName(), table_name, false);
205
249
    break;
206
250
  case message::Table::INTERNAL:
207
 
    assert(path.empty());
208
 
    path= build_table_filename(getSchemaName(), table_name, true);
 
251
    assert(path.size() == 0);
 
252
    build_table_filename(path, getSchemaName(), table_name, true);
209
253
    break;
210
254
  case message::Table::TEMPORARY:
211
255
    if (path.empty())
212
 
      path= build_tmptable_filename();
 
256
    {
 
257
      build_tmptable_filename(path);
 
258
    }
213
259
    break;
214
260
  }
215
261
 
216
 
  if (type == message::Table::TEMPORARY)
217
 
  {
218
 
    size_t pos= path.find("tmp/#sql");
219
 
    if (pos != std::string::npos) 
220
 
      key_path= path.substr(pos);
 
262
  switch (type) {
 
263
  case message::Table::FUNCTION:
 
264
  case message::Table::STANDARD:
 
265
  case message::Table::INTERNAL:
 
266
    break;
 
267
  case message::Table::TEMPORARY:
 
268
    {
 
269
      size_t pos;
 
270
 
 
271
      pos= path.find("tmp/#sql");
 
272
      if (pos != std::string::npos) 
 
273
      {
 
274
        key_path= path.substr(pos);
 
275
      }
 
276
    }
 
277
    break;
221
278
  }
222
279
 
223
280
  hash_value= util::insensitive_hash()(path);
224
 
  key.set(getKeySize(), getSchemaName(), boost::to_lower_copy(std::string(getTableName())));
 
281
 
 
282
  std::string tb_name(getTableName());
 
283
  boost::to_lower(tb_name);
 
284
  key.set(getKeySize(), getSchemaName(), tb_name);
225
285
}
226
286
 
227
287