← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/cursor.cc

  • Committer: Brian Aker
  • Date: 2011-01-12 06:45:23 UTC
  • mto: (2073.1.4 catalogs)
  • mto: This revision was merged to the branch mainline in revision 2080.
  • Revision ID: brian@tangent.org-20110112064523-rqhptaqbph22qmj1
Remove custom error.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/cursor.cc
23
23
  Handler-calling-functions
24
24
*/
25
25
 
26
 
#include <config.h>
 
26
#include "config.h"
27
27
 
28
28
#include <fcntl.h>
29
29
 
30
 
#include <drizzled/error.h>
31
 
#include <drizzled/field/epoch.h>
32
 
#include <drizzled/gettext.h>
33
 
#include <drizzled/internal/my_sys.h>
34
 
#include <drizzled/item/empty_string.h>
35
 
#include <drizzled/item/int.h>
36
 
#include <drizzled/lock.h>
37
 
#include <drizzled/message/table.h>
38
 
#include <drizzled/my_hash.h>
39
 
#include <drizzled/optimizer/cost_vector.h>
40
 
#include <drizzled/plugin/client.h>
41
 
#include <drizzled/plugin/event_observer.h>
42
 
#include <drizzled/plugin/storage_engine.h>
43
 
#include <drizzled/probes.h>
44
 
#include <drizzled/session.h>
45
 
#include <drizzled/sql_base.h>
46
 
#include <drizzled/sql_parse.h>
47
 
#include <drizzled/transaction_services.h>
 
30
#include "drizzled/my_hash.h"
 
31
#include "drizzled/error.h"
 
32
#include "drizzled/gettext.h"
 
33
#include "drizzled/probes.h"
 
34
#include "drizzled/sql_parse.h"
 
35
#include "drizzled/optimizer/cost_vector.h"
 
36
#include "drizzled/session.h"
 
37
#include "drizzled/sql_base.h"
 
38
#include "drizzled/transaction_services.h"
 
39
#include "drizzled/lock.h"
 
40
#include "drizzled/item/int.h"
 
41
#include "drizzled/item/empty_string.h"
 
42
#include "drizzled/field/epoch.h"
 
43
#include "drizzled/message/table.pb.h"
 
44
#include "drizzled/plugin/client.h"
 
45
#include "drizzled/internal/my_sys.h"
 
46
#include "drizzled/plugin/event_observer.h"
48
47
 
49
48
using namespace std;
50
49
 
91
90
  if (!(new_handler->ref= (unsigned char*) mem_root->alloc_root(ALIGN_SIZE(ref_length)*2)))
92
91
    return NULL;
93
92
 
94
 
  identifier::Table identifier(getTable()->getShare()->getSchemaName(),
 
93
  TableIdentifier identifier(getTable()->getShare()->getSchemaName(),
95
94
                             getTable()->getShare()->getTableName(),
96
95
                             getTable()->getShare()->getType());
97
96
 
211
210
uint64_t Cursor::tableSize() { return stats.index_file_length + stats.data_file_length; }
212
211
uint64_t Cursor::rowSize() { return getTable()->getRecordLength() + getTable()->sizeFields(); }
213
212
 
214
 
int Cursor::doOpen(const identifier::Table &identifier, int mode, uint32_t test_if_locked)
 
213
int Cursor::doOpen(const TableIdentifier &identifier, int mode, uint32_t test_if_locked)
215
214
{
216
215
  return open(identifier.getPath().c_str(), mode, test_if_locked);
217
216
}
222
221
  Try O_RDONLY if cannot open as O_RDWR
223
222
  Don't wait for locks if not HA_OPEN_WAIT_IF_LOCKED is set
224
223
*/
225
 
int Cursor::ha_open(const identifier::Table &identifier,
 
224
int Cursor::ha_open(const TableIdentifier &identifier,
226
225
                    int mode,
227
226
                    int test_if_locked)
228
227
{
267
266
*/
268
267
int Cursor::read_first_row(unsigned char * buf, uint32_t primary_key)
269
268
{
270
 
  int error;
 
269
  register int error;
271
270
 
272
271
  ha_statistic_increment(&system_status_var::ha_read_first_count);
273
272
 
274
273
  /*
275
274
    If there is very few deleted rows in the table, find the first row by
276
275
    scanning the table.
277
 
    @todo remove the test for HA_READ_ORDER
 
276
    TODO remove the test for HA_READ_ORDER
278
277
  */
279
278
  if (stats.deleted < 10 || primary_key >= MAX_KEY ||
280
279
      !(getTable()->index_flags(primary_key) & HA_READ_ORDER))
711
710
     */
712
711
    Session *const session= getTable()->in_use;
713
712
    TransactionServices &transaction_services= TransactionServices::singleton();
714
 
    transaction_services.truncateTable(*session, *getTable());
 
713
    transaction_services.truncateTable(session, getTable());
715
714
  }
716
715
 
717
716
  return result;
1300
1299
 
1301
1300
  bool result= false;
1302
1301
 
1303
 
  switch (session->getLex()->sql_command)
 
1302
  switch (session->lex->sql_command)
1304
1303
  {
1305
1304
  case SQLCOM_CREATE_TABLE:
1306
1305
    /*
1312
1311
     * CREATE TABLE will commit the transaction containing
1313
1312
     * it).
1314
1313
     */
1315
 
    result= transaction_services.insertRecord(*session, *table);
 
1314
    result= transaction_services.insertRecord(session, table);
1316
1315
    break;
1317
1316
  case SQLCOM_REPLACE:
1318
1317
  case SQLCOM_REPLACE_SELECT:
1341
1340
       * as the row to delete (this is the conflicting row), so
1342
1341
       * we need to notify TransactionService to use that row.
1343
1342
       */
1344
 
      transaction_services.deleteRecord(*session, *table, true);
 
1343
      transaction_services.deleteRecord(session, table, true);
1345
1344
      /* 
1346
1345
       * We set the "current" statement message to NULL.  This triggers
1347
1346
       * the replication services component to generate a new statement
1348
1347
       * message for the inserted record which will come next.
1349
1348
       */
1350
 
      transaction_services.finalizeStatementMessage(*session->getStatementMessage(), *session);
 
1349
      transaction_services.finalizeStatementMessage(*session->getStatementMessage(), session);
1351
1350
    }
1352
1351
    else
1353
1352
    {
1354
1353
      if (before_record == NULL)
1355
 
        result= transaction_services.insertRecord(*session, *table);
 
1354
        result= transaction_services.insertRecord(session, table);
1356
1355
      else
1357
 
        transaction_services.updateRecord(*session, *table, before_record, after_record);
 
1356
        transaction_services.updateRecord(session, table, before_record, after_record);
1358
1357
    }
1359
1358
    break;
1360
1359
  case SQLCOM_INSERT:
1367
1366
     * an update.
1368
1367
     */
1369
1368
    if (before_record == NULL)
1370
 
      result= transaction_services.insertRecord(*session, *table);
 
1369
      result= transaction_services.insertRecord(session, table);
1371
1370
    else
1372
 
      transaction_services.updateRecord(*session, *table, before_record, after_record);
 
1371
      transaction_services.updateRecord(session, table, before_record, after_record);
1373
1372
    break;
1374
1373
 
1375
1374
  case SQLCOM_UPDATE:
1376
 
    transaction_services.updateRecord(*session, *table, before_record, after_record);
 
1375
    transaction_services.updateRecord(session, table, before_record, after_record);
1377
1376
    break;
1378
1377
 
1379
1378
  case SQLCOM_DELETE:
1380
 
    transaction_services.deleteRecord(*session, *table);
 
1379
    transaction_services.deleteRecord(session, table);
1381
1380
    break;
1382
1381
  default:
1383
1382
    break;