← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_share.h

  • Committer: Brian Aker
  • Date: 2009-04-29 01:45:36 UTC
  • mfrom: (1000.1.6 merge)
  • Revision ID: brian@gaz-20090429014536-pwu5m8ug6n8fvh68
Merge refactoring (mainly around TABLE_SHARE... one step forward...)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_share.h
24
24
  This class is shared between different table objects. There is one
25
25
  instance of table share per one table in the database.
26
26
*/
27
 
class TABLE_SHARE
 
27
class TableShare
28
28
{
29
29
public:
30
 
  TABLE_SHARE() {}                    /* Remove gcc warning */
 
30
  TableShare() 
 
31
  {
 
32
    init();
 
33
  }                    /* Remove gcc warning */
31
34
 
32
35
  /** Category of this table. */
33
36
  enum_table_category table_category;
40
43
  TYPELIB *intervals;                   /* pointer to interval info */
41
44
  pthread_mutex_t mutex;                /* For locking the share  */
42
45
  pthread_cond_t cond;                  /* To signal that share is ready */
43
 
  TABLE_SHARE *next,            /* Link to unused shares */
 
46
  TableShare *next,             /* Link to unused shares */
44
47
    **prev;
45
48
 
46
49
  /* The following is copied to each Table on OPEN */
90
93
  StorageEngine *storage_engine;                        /* storage engine plugin */
91
94
  inline StorageEngine *db_type() const /* table_type for handler */
92
95
  {
93
 
    // assert(storage_engine);
94
96
    return storage_engine;
95
97
  }
96
98
  enum row_type row_type;               /* How rows are stored */
131
133
  bool crashed;
132
134
  bool name_lock, replace_with_name_lock;
133
135
  bool waiting_on_cond;                 /* Protection against free */
134
 
  uint32_t table_map_id;                   /* for row-based replication */
135
 
  uint64_t table_map_version;
136
 
 
137
 
  /*
138
 
    Cache for row-based replication table share checks that does not
139
 
    need to be repeated. Possible values are: -1 when cache value is
140
 
    not calculated yet, 0 when table *shall not* be replicated, 1 when
141
 
    table *may* be replicated.
142
 
  */
143
 
  int cached_row_logging_check;
144
136
 
145
137
  /*
146
138
    Set share's table cache key and update its db and table name appropriately.
154
146
    NOTES
155
147
      Since 'key_buff' buffer will be referenced from share it should has same
156
148
      life-time as share itself.
157
 
      This method automatically ensures that TABLE_SHARE::table_name/db have
 
149
      This method automatically ensures that TableShare::table_name/db have
158
150
      appropriate values by using table cache key as their source.
159
151
  */
160
152
 
199
191
    return (table_category == TABLE_CATEGORY_USER);
200
192
  }
201
193
 
202
 
  inline uint32_t get_table_def_version()
203
 
  {
204
 
    return table_map_id;
205
 
  }
 
194
 
 
195
  /*
 
196
    Initialize share for temporary tables
 
197
 
 
198
    SYNOPSIS
 
199
    init()
 
200
    share       Share to fill
 
201
    key         Table_cache_key, as generated from create_table_def_key.
 
202
    must start with db name.
 
203
    key_length  Length of key
 
204
    table_name  Table name
 
205
    path        Path to file (possible in lower case) without .frm
 
206
 
 
207
    NOTES
 
208
    This is different from alloc_table_share() because temporary tables
 
209
    don't have to be shared between threads or put into the table def
 
210
    cache, so we can do some things notable simpler and faster
 
211
 
 
212
    If table is not put in session->temporary_tables (happens only when
 
213
    one uses OPEN TEMPORARY) then one can specify 'db' as key and
 
214
    use key_length= 0 as neither table_cache_key or key_length will be used).
 
215
  */
 
216
 
 
217
  void init()
 
218
  {
 
219
    init("", 0, "", "");
 
220
  }
 
221
 
 
222
  void init(const char *new_table_name,
 
223
            const char *new_path)
 
224
  {
 
225
    init("", 0, new_table_name, new_path);
 
226
  }
 
227
 
 
228
  void init(const char *key,
 
229
            uint32_t key_length, const char *new_table_name,
 
230
            const char *new_path)
 
231
  {
 
232
    memset(this, 0, sizeof(TableShare));
 
233
    init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
234
    table_category=         TABLE_CATEGORY_TEMPORARY;
 
235
    tmp_table=              INTERNAL_TMP_TABLE;
 
236
    db.str=                 (char*) key;
 
237
    db.length=           strlen(key);
 
238
    table_cache_key.str=    (char*) key;
 
239
    table_cache_key.length= key_length;
 
240
    table_name.str=         (char*) new_table_name;
 
241
    table_name.length=      strlen(new_table_name);
 
242
    path.str=               (char*) new_path;
 
243
    normalized_path.str=    (char*) new_path;
 
244
    path.length= normalized_path.length= strlen(new_path);
 
245
 
 
246
    return;
 
247
  }
 
248
 
 
249
  /*
 
250
    Free table share and memory used by it
 
251
 
 
252
    SYNOPSIS
 
253
    free_table_share()
 
254
    share               Table share
 
255
 
 
256
    NOTES
 
257
    share->mutex must be locked when we come here if it's not a temp table
 
258
  */
 
259
 
 
260
  void free_table_share()
 
261
  {
 
262
    MEM_ROOT new_mem_root;
 
263
    assert(ref_count == 0);
 
264
 
 
265
    /*
 
266
      If someone is waiting for this to be deleted, inform it about this.
 
267
      Don't do a delete until we know that no one is refering to this anymore.
 
268
    */
 
269
    if (tmp_table == NO_TMP_TABLE)
 
270
    {
 
271
      /* share->mutex is locked in release_table_share() */
 
272
      while (waiting_on_cond)
 
273
      {
 
274
        pthread_cond_broadcast(&cond);
 
275
        pthread_cond_wait(&cond, &mutex);
 
276
      }
 
277
      /* No thread refers to this anymore */
 
278
      pthread_mutex_unlock(&mutex);
 
279
      pthread_mutex_destroy(&mutex);
 
280
      pthread_cond_destroy(&cond);
 
281
    }
 
282
    hash_free(&name_hash);
 
283
 
 
284
    storage_engine= NULL;
 
285
 
 
286
    /* We must copy mem_root from share because share is allocated through it */
 
287
    memcpy(&new_mem_root, &mem_root, sizeof(new_mem_root));
 
288
    free_root(&new_mem_root, MYF(0));                 // Free's share
 
289
    return;
 
290
  }
 
291
 
206
292
 
207
293
};