← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_base.cc

  • Committer: Eric Day
  • Date: 2009-10-31 21:53:33 UTC
  • mfrom: (1200 staging)
  • mto: This revision was merged to the branch mainline in revision 1202.
  • Revision ID: eday@oddments.org-20091031215333-j94bjoanwmi68p6f
Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_base.cc
16
16
 
17
17
/* Basic functions needed by many modules */
18
18
#include <drizzled/server_includes.h>
19
 
#include <drizzled/field/timestamp.h>
20
 
#include <drizzled/field/null.h>
21
19
#include <assert.h>
22
20
 
23
21
#include <signal.h>
46
44
#include <drizzled/lock.h>
47
45
#include <drizzled/plugin/listen.h>
48
46
#include <mysys/cached_directory.h>
 
47
#include <drizzled/field/timestamp.h>
 
48
#include <drizzled/field/null.h>
 
49
#include "drizzled/memory/multi_malloc.h"
49
50
 
50
51
using namespace std;
51
52
using namespace drizzled;
111
112
 
112
113
  SYNOPSIS
113
114
  close_handle_and_leave_table_as_lock()
114
 
  table         Table handler
 
115
  table         Table Cursor
115
116
 
116
117
  NOTES
117
118
  By leaving the table in the table cache, it disallows any other thread
464
465
 
465
466
  safe_mutex_assert_owner(&LOCK_open);
466
467
  assert(table->key_read == 0);
467
 
  assert(!table->file || table->file->inited == handler::NONE);
 
468
  assert(!table->file || table->file->inited == Cursor::NONE);
468
469
 
469
470
  open_tables= table->next;
470
471
 
811
812
    close_temporary_table(table, true, true);
812
813
  else
813
814
  {
814
 
    plugin::StorageEngine *table_type= table->s->db_type();
815
815
    pthread_mutex_lock(&LOCK_open); /* Close and drop a table (AUX routine) */
816
816
    /*
817
817
      unlink_open_table() also tells threads waiting for refresh or close
818
818
      that something has happened.
819
819
    */
820
820
    unlink_open_table(table);
821
 
    quick_rm_table(table_type, db_name, table_name, false);
 
821
    quick_rm_table(*this, db_name, table_name, false);
822
822
    pthread_mutex_unlock(&LOCK_open);
823
823
  }
824
824
}
829
829
 
830
830
  SYNOPSIS
831
831
  wait_for_condition()
832
 
  session       Thread handler
 
832
  session       Thread Cursor
833
833
  mutex mutex that is currently hold that is associated with condition
834
834
  Will be unlocked on return
835
835
  cond  Condition to wait for
979
979
 
980
980
  /*
981
981
    Create a table entry with the right key and with an old refresh version
982
 
    Note that we must use my_multi_malloc() here as this is freed by the
 
982
    Note that we must use multi_malloc() here as this is freed by the
983
983
    table cache
984
984
  */
985
 
  if (!my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
986
 
                       &table, sizeof(*table),
987
 
                       &share, sizeof(*share),
988
 
                       &key_buff, key_length,
989
 
                       NULL))
 
985
  if (! memory::multi_malloc(true,
 
986
                             &table, sizeof(*table),
 
987
                             &share, sizeof(*share),
 
988
                             &key_buff, key_length,
 
989
                             NULL))
990
990
    return NULL;
991
991
 
992
992
  table->s= share;
1320
1320
                                   table_list->db, table_list->table_name,
1321
1321
                                   false);
1322
1322
 
1323
 
      if (plugin::StorageEngine::getTableProto(path, NULL) != EEXIST)
 
1323
      if (plugin::StorageEngine::getTableDefinition(*this, path, table_list->db, table_list->table_name, false) != EEXIST)
1324
1324
      {
1325
1325
        /*
1326
1326
          Table to be created, so we need to create placeholder in table-cache.
1437
1437
 
1438
1438
#ifdef EXTRA_DEBUG
1439
1439
  if (table->db_stat)
1440
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Table %s had a open data handler in reopen_table"),
 
1440
    errmsg_printf(ERRMSG_LVL_ERROR, _("Table %s had a open data Cursor in reopen_table"),
1441
1441
                  table->alias);
1442
1442
#endif
1443
1443
  table_list.db=         table->s->db.str;
2084
2084
 
2085
2085
  SYNOPSIS
2086
2086
  open_tables()
2087
 
  session - thread handler
 
2087
  session - thread Cursor
2088
2088
  start - list of tables in/out
2089
2089
  counter - number of opened tables will be return using this parameter
2090
2090
  flags   - bitmap of flags to modify how the tables will be open:
2216
2216
 
2217
2217
  SYNOPSIS
2218
2218
  openTableLock()
2219
 
  session                       Thread handler
 
2219
  session                       Thread Cursor
2220
2220
  table_list            Table to open is first table in this list
2221
2221
  lock_type             Lock to use for open
2222
2222
  lock_flags          Flags passed to mysql_lock_table
2267
2267
 
2268
2268
  SYNOPSIS
2269
2269
  lock_tables()
2270
 
  session                       Thread handler
 
2270
  session                       Thread Cursor
2271
2271
  tables                Tables to lock
2272
2272
  count         Number of opened tables
2273
2273
  need_reopen         Out parameter which if true indicates that some
2376
2376
  /*
2377
2377
    First open the share, and then open the table from the share we just opened.
2378
2378
  */
2379
 
  if (open_table_def(this, share) ||
 
2379
  if (open_table_def(*this, share) ||
2380
2380
      open_table_from_share(this, share, table_name_arg,
2381
2381
                            (open_mode == OTM_ALTER) ? 0 :
2382
2382
                            (uint32_t) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
2475
2475
 
2476
2476
  SYNOPSIS
2477
2477
  find_field_in_natural_join()
2478
 
  session                        [in]  thread handler
 
2478
  session                        [in]  thread Cursor
2479
2479
  table_ref            [in]  table reference to search
2480
2480
  name           [in]  name of field
2481
2481
  length                 [in]  length of name
2544
2544
 
2545
2545
  SYNOPSIS
2546
2546
  find_field_in_table()
2547
 
  session                               thread handler
 
2547
  session                               thread Cursor
2548
2548
  table                 table where to search for the field
2549
2549
  name                  name of field
2550
2550
  length                        length of name
2616
2616
 
2617
2617
  SYNOPSIS
2618
2618
  find_field_in_table_ref()
2619
 
  session                          [in]  thread handler
 
2619
  session                          [in]  thread Cursor
2620
2620
  table_list               [in]  table reference to search
2621
2621
  name             [in]  name of field
2622
2622
  length                   [in]  field length of name
2747
2747
    if (session->mark_used_columns != MARK_COLUMNS_NONE)
2748
2748
    {
2749
2749
      /*
2750
 
        Get rw_set correct for this field so that the handler
 
2750
        Get rw_set correct for this field so that the Cursor
2751
2751
        knows that this field is involved in the query and gets
2752
2752
        retrieved/updated
2753
2753
      */
3987
3987
 
3988
3988
  SYNOPSIS
3989
3989
  setup_tables()
3990
 
  session                 Thread handler
 
3990
  session                 Thread Cursor
3991
3991
  context       name resolution contest to setup table list there
3992
3992
  from_clause   Top-level list of table references in the FROM clause
3993
3993
  tables          Table list (select_lex->table_list)
4064
4064
 
4065
4065
  SYNOPSIS
4066
4066
  setup_tables_and_check_view_access()
4067
 
  session                 Thread handler
 
4067
  session                 Thread Cursor
4068
4068
  context       name resolution contest to setup table list there
4069
4069
  from_clause   Top-level list of table references in the FROM clause
4070
4070
  tables          Table list (select_lex->table_list)
4107
4107
 
4108
4108
  SYNOPSIS
4109
4109
  insert_fields()
4110
 
  session                       Thread handler
 
4110
  session                       Thread Cursor
4111
4111
  context             Context for name resolution
4112
4112
  db_name               Database name in case of 'database_name.table_name.*'
4113
4113
  table_name            Table name in case of 'table_name.*'
4259
4259
 
4260
4260
  SYNOPSIS
4261
4261
  setup_conds()
4262
 
  session     thread handler
 
4262
  session     thread Cursor
4263
4263
  tables  list of tables for name resolving (select_lex->table_list)
4264
4264
  leaves  list of leaves of join table tree (select_lex->leaf_tables)
4265
4265
  conds   WHERE clause
4354
4354
 
4355
4355
  SYNOPSIS
4356
4356
  fill_record()
4357
 
  session           thread handler
 
4357
  session           thread Cursor
4358
4358
  fields        Item_fields list to be filled
4359
4359
  values        values to fill with
4360
4360
  ignore_errors true if we should ignore errors
4450
4450
 
4451
4451
  SYNOPSIS
4452
4452
  fill_record()
4453
 
  session           thread handler
 
4453
  session           thread Cursor
4454
4454
  ptr           pointer on pointer to record
4455
4455
  values        list of fields
4456
4456
  ignore_errors true if we should ignore errors
4567
4567
                                      "%s%c%s", drizzle_tmpdir, FN_LIBCHAR,
4568
4568
                                      entry->filename.c_str());
4569
4569
 
4570
 
      if (ext_len && !memcmp(".dfe", ext, ext_len))
 
4570
      if (ext_len && !memcmp(drizzled::plugin::DEFAULT_DEFINITION_FILE_EXT.c_str(), ext, ext_len))
4571
4571
      {
4572
4572
        TableShare share;
4573
4573
        /* We should cut file extention before deleting of table */
4574
4574
        memcpy(filePathCopy, filePath, filePath_len - ext_len);
4575
4575
        filePathCopy[filePath_len - ext_len]= 0;
4576
4576
        share.init(NULL, filePathCopy);
4577
 
        if (!open_table_def(session, &share))
 
4577
        if (!open_table_def(*session, &share))
4578
4578
        {
4579
 
          share.db_type()->doDeleteTable(session, filePathCopy);
 
4579
          share.db_type()->doDropTable(*session, filePathCopy);
4580
4580
        }
4581
4581
        share.free_table_share();
4582
4582
      }