← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/cursor.h

  • Committer: Monty Taylor
  • Date: 2010-11-08 18:26:08 UTC
  • mto: This revision was merged to the branch mainline in revision 1931.
  • Revision ID: mordred@inaugust.com-20101108182608-lci86acl7r53sbi3
Replaced auto_ptr with scoped_ptr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/cursor.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
20
20
#ifndef DRIZZLED_CURSOR_H
21
21
#define DRIZZLED_CURSOR_H
22
22
 
23
 
#include <drizzled/atomics.h>
24
 
#include <drizzled/definitions.h>
 
23
#include <drizzled/xid.h>
25
24
#include <drizzled/discrete_interval.h>
26
 
#include <drizzled/error_t.h>
27
 
#include <drizzled/ha_statistics.h>
28
 
#include <drizzled/handler_structs.h>
29
25
#include <drizzled/identifier.h>
 
26
#include <drizzled/definitions.h>
30
27
#include <drizzled/key_map.h>
31
 
#include <drizzled/message/table.h>
 
28
 
 
29
/* Definitions for parameters to do with Cursor-routines */
 
30
 
 
31
#include <drizzled/thr_lock.h>
 
32
#include <drizzled/sql_string.h>
32
33
#include <drizzled/sql_list.h>
33
 
#include <drizzled/thr_lock.h>
34
 
#include <drizzled/xid.h>
 
34
#include <drizzled/plugin/storage_engine.h>
 
35
#include <drizzled/handler_structs.h>
 
36
#include <drizzled/ha_statistics.h>
 
37
#include <drizzled/atomics.h>
 
38
 
 
39
#include <drizzled/message/table.pb.h>
35
40
 
36
41
#include <bitset>
37
42
#include <algorithm>
38
43
 
39
 
#include <drizzled/visibility.h>
40
 
 
41
44
namespace drizzled
42
45
{
43
46
 
45
48
 
46
49
typedef std::bitset<HA_MAX_ALTER_FLAGS> HA_ALTER_FLAGS;
47
50
 
48
 
class AlterInfo;
49
 
class CreateField;
 
51
extern uint64_t refresh_version;  /* Increments on each reload */
 
52
 
 
53
class Table;
 
54
class TableList;
 
55
class TableShare;
 
56
class Select_Lex_Unit;
50
57
class ForeignKeyInfo;
 
58
struct Order;
 
59
 
51
60
class Item;
52
 
class Item_ident;
 
61
 
53
62
class LEX;
54
63
class Select_Lex;
55
 
class Select_Lex_Unit;
56
 
class String;
57
 
class Table;
58
 
class TableList;
59
 
class TableShare;
 
64
class AlterInfo;
60
65
class select_result;
 
66
class CreateField;
61
67
class sys_var_str;
62
 
struct Order;
 
68
class Item_ident;
63
69
 
64
70
typedef List<Item> List_item;
65
71
extern KEY_CREATE_INFO default_key_create_info;
69
75
 
70
76
typedef struct system_status_var system_status_var;
71
77
 
72
 
namespace optimizer { class CostVector; }
73
 
namespace plugin { class StorageEngine; }
 
78
namespace optimizer
 
79
{
 
80
  class CostVector;
 
81
}
74
82
 
75
83
/*
76
84
  bitmap with first N+1 bits set
135
143
  If a blob column has NULL value, then its length and blob data pointer
136
144
  must be set to 0.
137
145
*/
138
 
class DRIZZLED_API Cursor
 
146
class Cursor
139
147
{
140
 
  friend class SEAPITesterCursor;
141
148
  Table &table;               /* The current open table */
142
149
  plugin::StorageEngine &engine;      /* storage engine of this Cursor */
143
150
 
205
212
  }
206
213
 
207
214
  /**
208
 
    Used by SHOW TABLE STATUS to get the current auto_inc from the engine
209
 
  */
210
 
  uint64_t getAutoIncrement()
211
 
  {
212
 
    return stats.auto_increment_value;
213
 
  }
214
 
 
215
 
  /**
216
215
    insert id for the current row (*autogenerated*; if not
217
216
    autogenerated, it's 0).
218
217
    At first successful insertion, this variable is stored into
231
230
 
232
231
  /* ha_ methods: pubilc wrappers for private virtual API */
233
232
 
234
 
  int ha_open(const identifier::Table &identifier, int mode, int test_if_locked);
235
 
  int startIndexScan(uint32_t idx, bool sorted) __attribute__ ((warn_unused_result));
 
233
  int ha_open(const TableIdentifier &identifier, int mode, int test_if_locked);
 
234
  int startIndexScan(uint32_t idx, bool sorted);
236
235
  int endIndexScan();
237
 
  int startTableScan(bool scan) __attribute__ ((warn_unused_result));
 
236
  int startTableScan(bool scan);
238
237
  int endTableScan();
239
238
  int ha_reset();
240
239
 
248
247
    and doDeleteRecord() below.
249
248
  */
250
249
  int ha_external_lock(Session *session, int lock_type);
251
 
  int insertRecord(unsigned char * buf) __attribute__ ((warn_unused_result));
252
 
  int updateRecord(const unsigned char * old_data, unsigned char * new_data) __attribute__ ((warn_unused_result));
253
 
  int deleteRecord(const unsigned char * buf) __attribute__ ((warn_unused_result));
 
250
  int insertRecord(unsigned char * buf);
 
251
  int updateRecord(const unsigned char * old_data, unsigned char * new_data);
 
252
  int deleteRecord(const unsigned char * buf);
254
253
  void ha_release_auto_increment();
255
254
 
256
255
  /** to be actually called to get 'check()' functionality*/
272
271
 
273
272
  /* Estimates calculation */
274
273
  virtual double scan_time(void)
275
 
  { return static_cast<double>(stats.data_file_length) / IO_SIZE + 2; }
 
274
  { return uint64_t2double(stats.data_file_length) / IO_SIZE + 2; }
276
275
  virtual double read_time(uint32_t, uint32_t ranges, ha_rows rows)
277
 
  { return ranges + rows; }
 
276
  { return rows2double(ranges+rows); }
278
277
 
279
278
  virtual double index_only_read_time(uint32_t keynr, double records);
280
279
 
350
349
                                 const unsigned char * key,
351
350
                                 key_part_map keypart_map,
352
351
                                 enum ha_rkey_function find_flag);
353
 
  virtual int index_next(unsigned char *) __attribute__ ((warn_unused_result))
 
352
  virtual int index_next(unsigned char *)
354
353
   { return  HA_ERR_WRONG_COMMAND; }
355
354
  virtual int index_prev(unsigned char *)
356
355
   { return  HA_ERR_WRONG_COMMAND; }
524
523
  */
525
524
 
526
525
  virtual int open(const char *, int , uint32_t ) { assert(0); return -1; }
527
 
  virtual int doOpen(const identifier::Table &identifier, int mode, uint32_t test_if_locked);
 
526
  virtual int doOpen(const TableIdentifier &identifier, int mode, uint32_t test_if_locked);
528
527
  virtual int doStartIndexScan(uint32_t idx, bool)
529
528
  { active_index= idx; return 0; }
530
529
  virtual int doEndIndexScan() { active_index= MAX_KEY; return 0; }
535
534
    if rnd_init allocates the cursor, second call should position it
536
535
    to the start of the table, no need to deallocate and allocate it again
537
536
  */
538
 
  virtual int doStartTableScan(bool scan) __attribute__ ((warn_unused_result)) = 0;
 
537
  virtual int doStartTableScan(bool scan)= 0;
539
538
  virtual int doEndTableScan() { return 0; }
540
539
  virtual int doInsertRecord(unsigned char *)
541
540
  {
655
654
                   uint64_t setup_tables_done_option);
656
655
void free_underlaid_joins(Session *session, Select_Lex *select);
657
656
 
658
 
bool handle_derived(LEX *lex, bool (*processor)(Session *session,
 
657
bool mysql_handle_derived(LEX *lex, bool (*processor)(Session *session,
659
658
                                                      LEX *lex,
660
659
                                                      TableList *table));
661
 
bool derived_prepare(Session *session, LEX *lex, TableList *t);
662
 
bool derived_filling(Session *session, LEX *lex, TableList *t);
 
660
bool mysql_derived_prepare(Session *session, LEX *lex, TableList *t);
 
661
bool mysql_derived_filling(Session *session, LEX *lex, TableList *t);
663
662
int prepare_create_field(CreateField *sql_field,
664
663
                         uint32_t *blob_columns,
665
664
                         int *timestamps, int *timestamps_with_niladic);
666
665
 
667
 
bool create_table(Session *session,
668
 
                  const identifier::Table &identifier,
669
 
                  HA_CREATE_INFO *create_info,
670
 
                  message::Table &table_proto,
671
 
                  AlterInfo *alter_info,
672
 
                  bool tmp_table, uint32_t select_field_count,
673
 
                  bool is_if_not_exists);
674
 
 
675
 
bool create_table_no_lock(Session *session,
676
 
                          const identifier::Table &identifier,
677
 
                          HA_CREATE_INFO *create_info,
678
 
                          message::Table &table_proto,
679
 
                          AlterInfo *alter_info,
680
 
                          bool tmp_table, uint32_t select_field_count,
681
 
                          bool is_if_not_exists);
682
 
 
683
 
bool create_like_table(Session* session,
684
 
                       identifier::Table::const_reference destination_identifier,
685
 
                       identifier::Table::const_reference source_identifier,
686
 
                       message::Table &create_table_proto,
687
 
                       bool is_if_not_exists,
688
 
                       bool is_engine_set);
689
 
 
690
 
bool rename_table(Session &session,
 
666
bool mysql_create_table(Session *session,
 
667
                        TableIdentifier &identifier,
 
668
                        HA_CREATE_INFO *create_info,
 
669
                        message::Table &table_proto,
 
670
                        AlterInfo *alter_info,
 
671
                        bool tmp_table, uint32_t select_field_count,
 
672
                        bool is_if_not_exists);
 
673
 
 
674
bool mysql_create_table_no_lock(Session *session,
 
675
                                TableIdentifier &identifier,
 
676
                                HA_CREATE_INFO *create_info,
 
677
                                message::Table &table_proto,
 
678
                                AlterInfo *alter_info,
 
679
                                bool tmp_table, uint32_t select_field_count,
 
680
                                bool is_if_not_exists);
 
681
 
 
682
bool mysql_create_like_table(Session* session,
 
683
                             TableIdentifier &destination_identifier,
 
684
                             TableList* table, TableList* src_table,
 
685
                             message::Table &create_table_proto,
 
686
                             bool is_if_not_exists,
 
687
                             bool is_engine_set);
 
688
 
 
689
bool mysql_rename_table(Session &session,
691
690
                        plugin::StorageEngine *base,
692
 
                        const identifier::Table &old_identifier,
693
 
                        const identifier::Table &new_identifier);
 
691
                        TableIdentifier &old_identifier,
 
692
                        TableIdentifier &new_identifier);
694
693
 
695
 
bool prepare_update(Session *session, TableList *table_list,
 
694
bool mysql_prepare_update(Session *session, TableList *table_list,
696
695
                          Item **conds, uint32_t order_num, Order *order);
697
 
int update_query(Session *session,TableList *tables,List<Item> &fields,
 
696
int mysql_update(Session *session,TableList *tables,List<Item> &fields,
698
697
                 List<Item> &values,COND *conds,
699
698
                 uint32_t order_num, Order *order, ha_rows limit,
700
699
                 enum enum_duplicates handle_duplicates, bool ignore);
701
 
bool prepare_insert(Session *session, TableList *table_list, Table *table,
 
700
bool mysql_prepare_insert(Session *session, TableList *table_list, Table *table,
702
701
                          List<Item> &fields, List_item *values,
703
702
                          List<Item> &update_fields,
704
703
                          List<Item> &update_values, enum_duplicates duplic,
705
704
                          COND **where, bool select_insert,
706
705
                          bool check_fields, bool abort_on_warning);
707
 
bool insert_query(Session *session,TableList *table,List<Item> &fields,
 
706
bool mysql_insert(Session *session,TableList *table,List<Item> &fields,
708
707
                  List<List_item> &values, List<Item> &update_fields,
709
708
                  List<Item> &update_values, enum_duplicates flag,
710
709
                  bool ignore);
711
710
int check_that_all_fields_are_given_values(Session *session, Table *entry,
712
711
                                           TableList *table_list);
713
 
int prepare_delete(Session *session, TableList *table_list, Item **conds);
714
 
bool delete_query(Session *session, TableList *table_list, COND *conds,
 
712
int mysql_prepare_delete(Session *session, TableList *table_list, Item **conds);
 
713
bool mysql_delete(Session *session, TableList *table_list, COND *conds,
715
714
                  SQL_LIST *order, ha_rows rows, uint64_t options,
716
715
                  bool reset_auto_increment);
717
 
bool truncate(Session& session, TableList *table_list);
 
716
bool mysql_truncate(Session& session, TableList *table_list);
718
717
TableShare *get_table_share(Session *session, TableList *table_list, char *key,
719
718
                             uint32_t key_length, uint32_t db_flags, int *error);
720
719
TableShare *get_cached_table_share(const char *db, const char *table_name);
723
722
void close_handle_and_leave_table_as_lock(Table *table);
724
723
bool wait_for_tables(Session *session);
725
724
bool table_is_used(Table *table, bool wait_for_name_lock);
726
 
Table *drop_locked_tables(Session *session, const drizzled::identifier::Table &identifier);
727
 
void abort_locked_tables(Session *session, const drizzled::identifier::Table &identifier);
 
725
Table *drop_locked_tables(Session *session, const drizzled::TableIdentifier &identifier);
 
726
void abort_locked_tables(Session *session, const drizzled::TableIdentifier &identifier);
728
727
extern Field *not_found_field;
729
728
extern Field *view_ref_found;
730
729