← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/function_engine/cursor.cc

  • Committer: Monty Taylor
  • Date: 2010-03-02 19:10:25 UTC
  • mto: (1317.1.8)
  • mto: This revision was merged to the branch mainline in revision 1322.
  • Revision ID: mordred@inaugust.com-20100302191025-zoxjz4xwkoa6160h
Prevent unauthorized users from changing schema.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/function_engine/cursor.cc
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) 2009 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2009 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
24
24
#include <drizzled/session.h>
25
25
#include "drizzled/internal/my_sys.h"
26
26
 
27
 
#include <unistd.h>
28
 
#include <fcntl.h>
29
 
 
30
27
#include <string>
31
28
 
32
29
using namespace std;
37
34
*****************************************************************************/
38
35
 
39
36
FunctionCursor::FunctionCursor(plugin::StorageEngine &engine_arg,
40
 
                               Table &table_arg) :
 
37
                               TableShare &table_arg) :
41
38
  Cursor(engine_arg, table_arg),
42
39
  estimate_of_rows(100), // Completely fabricated, I used to use the value 2.
43
40
  rows_returned(0)
45
42
 
46
43
int FunctionCursor::open(const char *name, int, uint32_t)
47
44
{
48
 
  tool= static_cast<Function *>(getEngine())->getFunction(name); 
49
 
//  assert(tool);
50
 
 
51
 
  record_id= 0;
52
 
 
53
 
  if (not tool)
54
 
    return HA_ERR_NO_SUCH_TABLE;
 
45
  (void)name;
 
46
  string temp_name= name;
 
47
  tool= static_cast<Function *>(engine)->getFunction(temp_name); 
55
48
 
56
49
  return 0;
57
50
}
59
52
int FunctionCursor::close(void)
60
53
{
61
54
  tool= NULL;
62
 
  wipeCache();
63
 
 
64
55
  return 0;
65
56
}
66
57
 
67
 
int FunctionCursor::doStartTableScan(bool)
 
58
int FunctionCursor::rnd_init(bool)
68
59
{
 
60
  record_id= 0;
69
61
  rows_returned= 0;
70
 
  generator= tool->generator(getTable()->getFields());
 
62
  generator= tool->generator(table->field);
71
63
 
72
64
  return 0;
73
65
}
79
71
  ha_statistic_increment(&system_status_var::ha_read_rnd_next_count);
80
72
 
81
73
  /* Fix bug in the debug logic for field */
82
 
  for (Field **field= getTable()->getFields() ; *field ; field++)
 
74
  for (Field **field=table->field ; *field ; field++)
83
75
  {
84
76
    (*field)->setWriteSet();
85
77
  }
86
78
 
87
 
  more_rows= generator->sub_populate(getTable()->getShare()->sizeFields());
 
79
  more_rows= generator->sub_populate(table->s->fields);
88
80
 
89
81
  if (more_rows)
90
82
  {
102
94
 
103
95
void FunctionCursor::position(const unsigned char *record)
104
96
{
105
 
  if (row_cache.size() <= record_id * getTable()->getShare()->getRecordLength())
106
 
  {
107
 
    row_cache.resize(row_cache.size() + getTable()->getShare()->getRecordLength() * 100); // Hardwired at adding an additional 100 rows of storage
108
 
  }
109
 
  memcpy(&row_cache[record_id * getTable()->getShare()->getRecordLength()], record, getTable()->getShare()->getRecordLength());
 
97
  unsigned char *copy;
 
98
 
 
99
  copy= (unsigned char *)calloc(table->s->reclength, sizeof(unsigned char));
 
100
  assert(copy);
 
101
  memcpy(copy, record, table->s->reclength);
 
102
  row_cache.push_back(copy);
110
103
  internal::my_store_ptr(ref, ref_length, record_id);
111
104
  record_id++;
112
105
}
113
106
 
114
 
 
115
 
void FunctionCursor::wipeCache()
116
 
{
 
107
int FunctionCursor::rnd_end()
 
108
{ 
 
109
  size_t length_of_vector= row_cache.size();
 
110
 
 
111
  for (size_t x= 0; x < length_of_vector; x++)
 
112
  {
 
113
    free(row_cache[x]);
 
114
  }
 
115
 
117
116
  if (rows_returned > estimate_of_rows)
118
117
    estimate_of_rows= rows_returned;
119
118
 
120
119
  row_cache.clear();
121
120
  record_id= 0;
122
 
}
123
 
 
124
 
int FunctionCursor::extra(enum ha_extra_function operation)
125
 
{
126
 
  switch (operation)
127
 
  {
128
 
  case drizzled::HA_EXTRA_CACHE:
129
 
    break;
130
 
  case drizzled::HA_EXTRA_NO_CACHE:
131
 
    break;
132
 
  case drizzled::HA_EXTRA_RESET_STATE:
133
 
    wipeCache();
134
 
    break;
135
 
  default:
136
 
    break;
137
 
  }
138
 
 
139
 
  return 0;
140
 
}
141
 
 
142
 
int FunctionCursor::doEndTableScan()
143
 
{ 
144
121
  delete generator; // Do this in case of an early exit from rnd_next()
145
122
 
146
123
  return 0;
151
128
  ha_statistic_increment(&system_status_var::ha_read_rnd_count);
152
129
  size_t position_id= (size_t)internal::my_get_ptr(pos, ref_length);
153
130
 
154
 
  assert(position_id * getTable()->getShare()->getRecordLength() < row_cache.size());
155
 
  memcpy(buf, &row_cache[position_id * getTable()->getShare()->getRecordLength()], getTable()->getShare()->getRecordLength());
 
131
  memcpy(buf, row_cache[position_id], table->s->reclength);
156
132
 
157
133
  return 0;
158
134
}