← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/event_observer.h

  • Committer: Brian Aker
  • Date: 2010-06-03 22:55:32 UTC
  • mto: (1578.6.9 explain-drizzle)
  • mto: This revision was merged to the branch mainline in revision 1591.
  • Revision ID: brian@gir-2.local-20100603225532-5yuc8um41i4owavf
Additional pass through to remove raw field access.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/event_observer.h
44
44
#define DRIZZLED_PLUGIN_EVENT_OBSERVER_H
45
45
 
46
46
#include "drizzled/plugin/plugin.h"
47
 
#include "drizzled/session.h"
48
47
 
49
48
#include <string>
50
49
 
51
50
namespace drizzled
52
51
{
53
52
 
54
 
class Table;
55
53
class TableShare;
56
 
class Session;
57
54
 
58
55
namespace plugin
59
56
{
60
 
class EventObserverList;
61
 
class EventData;
62
 
class EventObserver;
 
57
  class EventObserverList;
 
58
  class EventData;
63
59
 
64
 
typedef std::vector<EventObserver *> EventObserverVector;
65
 
typedef EventObserver* EventObserverPtr;
66
60
 
67
61
class EventObserver : public Plugin
68
62
{
75
69
  {}
76
70
  virtual ~EventObserver() {}
77
71
 
78
 
  enum EventType{
79
 
    /* Session events: */
80
 
    BEFORE_CREATE_DATABASE, AFTER_CREATE_DATABASE, 
81
 
    BEFORE_DROP_DATABASE,   AFTER_DROP_DATABASE,
82
 
    CONNECT_SESSION,
83
 
    DISCONNECT_SESSION,
84
 
    AFTER_STATEMENT,
85
 
    BEFORE_STATEMENT,
86
 
 
87
 
    /* Schema events: */
88
 
    BEFORE_DROP_TABLE,   AFTER_DROP_TABLE, 
89
 
    BEFORE_RENAME_TABLE, AFTER_RENAME_TABLE, 
90
 
 
91
 
    /* Table events: */
92
 
    BEFORE_INSERT_RECORD,   AFTER_INSERT_RECORD, 
93
 
    BEFORE_UPDATE_RECORD,   AFTER_UPDATE_RECORD, 
94
 
    BEFORE_DELETE_RECORD,   AFTER_DELETE_RECORD,
95
 
 
96
 
    /* The max event ID marker. */
97
 
    MAX_EVENT_COUNT
98
 
  };
 
72
   enum EventType{
 
73
      /* Session events: */
 
74
      BEFORE_CREATE_DATABASE, AFTER_CREATE_DATABASE, 
 
75
      BEFORE_DROP_DATABASE,   AFTER_DROP_DATABASE,
 
76
      
 
77
      /* Schema events: */
 
78
      BEFORE_DROP_TABLE,   AFTER_DROP_TABLE, 
 
79
      BEFORE_RENAME_TABLE, AFTER_RENAME_TABLE, 
 
80
      
 
81
      /* Table events: */
 
82
      BEFORE_INSERT_RECORD,   AFTER_INSERT_RECORD, 
 
83
      BEFORE_UPDATE_RECORD,   AFTER_UPDATE_RECORD, 
 
84
      BEFORE_DELETE_RECORD,   AFTER_DELETE_RECORD,
 
85
      
 
86
      /* The max event ID marker. */
 
87
      MAX_EVENT_COUNT
 
88
    };
99
89
 
100
90
  static const char *eventName(EventType event) 
101
91
  {
103
93
    {
104
94
    case BEFORE_DROP_TABLE:
105
95
      return "BEFORE_DROP_TABLE";
106
 
 
 
96
    
107
97
    case AFTER_DROP_TABLE:
108
98
      return "AFTER_DROP_TABLE";
109
 
 
 
99
    
110
100
    case BEFORE_RENAME_TABLE:
111
101
      return "BEFORE_RENAME_TABLE";
112
 
 
 
102
      
113
103
    case AFTER_RENAME_TABLE:
114
104
      return "AFTER_RENAME_TABLE";
115
 
 
 
105
      
116
106
    case BEFORE_INSERT_RECORD:
117
 
      return "BEFORE_INSERT_RECORD";
118
 
 
 
107
       return "BEFORE_INSERT_RECORD";
 
108
      
119
109
    case AFTER_INSERT_RECORD:
120
 
      return "AFTER_INSERT_RECORD";
121
 
 
 
110
       return "AFTER_INSERT_RECORD";
 
111
      
122
112
    case BEFORE_UPDATE_RECORD:
123
113
      return "BEFORE_UPDATE_RECORD";
124
 
 
 
114
               
125
115
    case AFTER_UPDATE_RECORD:
126
116
      return "AFTER_UPDATE_RECORD";
127
 
 
 
117
      
128
118
    case BEFORE_DELETE_RECORD:
129
119
      return "BEFORE_DELETE_RECORD";
130
120
 
142
132
 
143
133
    case AFTER_DROP_DATABASE:
144
134
      return "AFTER_DROP_DATABASE";
145
 
 
146
 
    case CONNECT_SESSION:
147
 
      return "CONNECT_SESSION";
148
 
 
149
 
    case DISCONNECT_SESSION:
150
 
      return "DISCONNECT_SESSION";
151
 
 
152
 
    case AFTER_STATEMENT:
153
 
      return "AFTER_STATEMENT";
154
 
 
155
 
    case BEFORE_STATEMENT:
156
 
      return "BEFORE_STATEMENT";
157
 
 
 
135
      
158
136
    case MAX_EVENT_COUNT:
159
137
      break;
160
 
    }
161
 
 
 
138
   }
 
139
    
162
140
    return "Unknown";
163
141
  }
164
 
 
 
142
  
165
143
  /*==========================================================*/
166
144
  /* registerEvents() must be implemented to allow the plugin to
167
145
   * register which events it is interested in.
168
 
 */
 
146
   */
169
147
  virtual void registerTableEventsDo(TableShare &, EventObserverList &){}
170
148
  virtual void registerSchemaEventsDo(const std::string &/*db*/, EventObserverList &) {}
171
149
  virtual void registerSessionEventsDo(Session &, EventObserverList &) {}
176
154
  /* Static access methods called by drizzle: */
177
155
  static bool addPlugin(EventObserver *handler);
178
156
  static void removePlugin(EventObserver *handler);
179
 
 
 
157
  
180
158
  /*==========================================================*/
181
159
  /* Register an event of interest for this plugin. 
182
160
   * This is called from with in the plugin when registering itself.
192
170
   * It is good practice that if the event position matters not to hard code the position
193
171
   * but supply a systen variable so that it can be set at runtime so that the user can
194
172
   * decide which event should be called first.
195
 
 */
 
173
   */
196
174
  void registerEvent(EventObserverList &observers, EventType event, int32_t position= 0); 
197
175
 
198
176
  /*==========================================================*/
199
177
  /* Called from drizzle to register all events for all event plugins 
200
178
   * interested in this table. 
201
 
 */
 
179
   */
202
180
  static void registerTableEvents(TableShare &table_share); 
203
181
  static void deregisterTableEvents(TableShare &table_share); 
204
182
 
205
183
  /*==========================================================*/
206
184
  /* Called from drizzle to register all events for all event plugins 
207
 
   * interested in this database. 
208
 
 */
 
185
  * interested in this database. 
 
186
  */
209
187
  static void registerSchemaEvents(Session &session, const std::string &db); 
210
188
  static void deregisterSchemaEvents(Session &session, const std::string &db); 
211
189
 
212
190
  /*==========================================================*/
213
191
  /* Called from drizzle to register all events for all event plugins 
214
 
   * interested in this session. 
215
 
 */
 
192
  * interested in this session. 
 
193
  */
216
194
  static void registerSessionEvents(Session &session); 
217
195
  static void deregisterSessionEvents(Session &session); 
218
196
 
219
 
 
 
197
 
220
198
  /*==========================================================*/
221
199
  /* Static meathods called by drizzle to notify interested plugins 
222
200
   * of a schema an event,
223
 
 */
224
 
  static bool beforeDropTable(Session &session, const drizzled::TableIdentifier &table);
225
 
  static bool afterDropTable(Session &session, const drizzled::TableIdentifier &table, int err);
226
 
  static bool beforeRenameTable(Session &session, const drizzled::TableIdentifier &from, const drizzled::TableIdentifier &to);
227
 
  static bool afterRenameTable(Session &session, const drizzled::TableIdentifier &from, const drizzled::TableIdentifier &to, int err);
228
 
  static bool connectSession(Session &session);
229
 
  static bool disconnectSession(Session &session);
230
 
  static bool beforeStatement(Session &session);
231
 
  static bool afterStatement(Session &session);
232
 
 
233
 
  /*==========================================================*/
234
 
  /* Static meathods called by drizzle to notify interested plugins 
235
 
   * of a table an event,
236
 
 */
237
 
  static bool beforeInsertRecord(Table &table, unsigned char *buf);
238
 
  static bool afterInsertRecord(Table &table, const unsigned char *buf, int err);
239
 
  static bool beforeDeleteRecord(Table &table, const unsigned char *buf);
240
 
  static bool afterDeleteRecord(Table &table, const unsigned char *buf, int err);
241
 
  static bool beforeUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data);
242
 
  static bool afterUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data, int err);
243
 
 
244
 
  /*==========================================================*/
245
 
  /* Static meathods called by drizzle to notify interested plugins 
246
 
   * of a table an event,
247
 
 */
 
201
   */
 
202
  static bool beforeDropTable(Session &session, TableIdentifier &table);
 
203
  static bool afterDropTable(Session &session, TableIdentifier &table, int err);
 
204
  static bool beforeRenameTable(Session &session, TableIdentifier &from, TableIdentifier &to);
 
205
  static bool afterRenameTable(Session &session, TableIdentifier &from, TableIdentifier &to, int err);
 
206
 
 
207
  /*==========================================================*/
 
208
  /* Static meathods called by drizzle to notify interested plugins 
 
209
   * of a table an event,
 
210
   */
 
211
  static bool beforeInsertRecord(Session &session, TableShare &table_share, unsigned char *buf);
 
212
  static bool afterInsertRecord(Session &session, TableShare &table_share, const unsigned char *buf, int err);
 
213
  static bool beforeDeleteRecord(Session &session, TableShare &table_share, const unsigned char *buf);
 
214
  static bool afterDeleteRecord(Session &session, TableShare &table_share, const unsigned char *buf, int err);
 
215
  static bool beforeUpdateRecord(Session &session, TableShare &table_share, const unsigned char *old_data, unsigned char *new_data);
 
216
  static bool afterUpdateRecord(Session &session, TableShare &table_share, const unsigned char *old_data, unsigned char *new_data, int err);
 
217
 
 
218
  /*==========================================================*/
 
219
  /* Static meathods called by drizzle to notify interested plugins 
 
220
   * of a table an event,
 
221
   */
248
222
  static bool beforeCreateDatabase(Session &session, const std::string &db);
249
223
  static bool afterCreateDatabase(Session &session, const std::string &db, int err);
250
224
  static bool beforeDropDatabase(Session &session, const std::string &db);
251
225
  static bool afterDropDatabase(Session &session, const std::string &db, int err);
252
226
 
253
 
  static const EventObserverVector &getEventObservers(void);
254
 
 
255
227
};
256
228
 
257
229
 
258
 
 
259
 
 
260
230
/* EventObserver data classes: */
261
231
//======================================
262
232
class EventData
263
233
{
264
234
public:
265
235
  EventObserver::EventType event;
266
 
 
 
236
   
267
237
  EventData(EventObserver::EventType event_arg): 
268
238
    event(event_arg),
269
239
    observerList(NULL)
270
 
  {}
 
240
    {}
271
241
  virtual ~EventData(){}
272
 
 
 
242
  
273
243
  // Call all the event observers that are registered for this event.
274
244
  virtual bool callEventObservers();
275
 
 
 
245
  
276
246
protected:
277
247
  EventObserverList *observerList;
278
 
 
 
248
  
279
249
};
280
250
 
281
251
//-----
283
253
{
284
254
public:
285
255
  Session &session;
286
 
 
 
256
  
287
257
  SessionEventData(EventObserver::EventType event_arg, Session &session_arg): 
288
258
    EventData(event_arg),
289
259
    session(session_arg)
290
 
  {}
 
260
    {}
291
261
  virtual ~SessionEventData(){}
292
 
 
293
 
 
 
262
  
 
263
  
294
264
  // Call all the event observers that are registered for this event.
295
265
  virtual bool callEventObservers();
296
 
  
297
 
  static bool hasEvents(Session &in_session) { return (in_session.getSessionObservers() != NULL);}
298
266
};
299
267
 
300
268
//-----
303
271
public:
304
272
  Session &session;
305
273
  const std::string &db;
306
 
 
 
274
  
307
275
  SchemaEventData(EventObserver::EventType event_arg, Session &session_arg, const std::string &db_arg): 
308
276
    EventData(event_arg),
309
277
    session(session_arg),
310
278
    db(db_arg)
311
 
  {}
 
279
    {}
312
280
  virtual ~SchemaEventData(){}
313
 
 
314
 
 
 
281
  
 
282
  
315
283
  // Call all the event observers that are registered for this event.
316
284
  virtual bool callEventObservers();
317
 
  
318
285
};
319
286
 
320
287
//-----
322
289
{
323
290
public:
324
291
  Session &session;
325
 
  Table &table;  
326
 
 
327
 
  TableEventData(EventObserver::EventType event_arg, Session &session_arg, Table &table_arg): 
 
292
  TableShare &table;  
 
293
  
 
294
  TableEventData(EventObserver::EventType event_arg, Session &session_arg, TableShare &table_arg): 
328
295
    EventData(event_arg),
329
296
    session(session_arg),
330
297
    table(table_arg)
331
 
  {}
 
298
    {}
332
299
  virtual ~TableEventData(){}
333
 
 
334
 
 
 
300
  
 
301
  
335
302
  // Call all the event observers that are registered for this event.
336
303
  virtual bool callEventObservers();
337
 
  
338
 
  static bool hasEvents(Table &in_table) { return (in_table.getMutableShare()->getTableObservers() != NULL);}
339
304
};
340
305
 
341
306
//-----
345
310
  const std::string &db;
346
311
 
347
312
  BeforeCreateDatabaseEventData(Session &session_arg, const std::string &db_arg): 
348
 
    SessionEventData(EventObserver::BEFORE_CREATE_DATABASE, session_arg), 
349
 
    db(db_arg)
 
313
  SessionEventData(EventObserver::BEFORE_CREATE_DATABASE, session_arg), 
 
314
  db(db_arg)
350
315
  {}  
351
316
};
352
317
 
358
323
  int err;
359
324
 
360
325
  AfterCreateDatabaseEventData(Session &session_arg, const std::string &db_arg, int err_arg): 
361
 
    SessionEventData(EventObserver::AFTER_CREATE_DATABASE, session_arg), 
362
 
    db(db_arg), 
363
 
    err(err_arg)
 
326
  SessionEventData(EventObserver::AFTER_CREATE_DATABASE, session_arg), 
 
327
  db(db_arg), 
 
328
  err(err_arg)
364
329
  {}  
365
330
};
366
331
 
371
336
  const std::string &db;
372
337
 
373
338
  BeforeDropDatabaseEventData(Session &session_arg, const std::string &db_arg): 
374
 
    SessionEventData(EventObserver::BEFORE_DROP_DATABASE, session_arg), 
375
 
    db(db_arg)
 
339
  SessionEventData(EventObserver::BEFORE_DROP_DATABASE, session_arg), 
 
340
  db(db_arg)
376
341
  {}  
377
342
};
378
343
 
384
349
  int err;
385
350
 
386
351
  AfterDropDatabaseEventData(Session &session_arg, const std::string &db_arg, int err_arg): 
387
 
    SessionEventData(EventObserver::AFTER_DROP_DATABASE, session_arg), 
388
 
    db(db_arg), 
389
 
    err(err_arg) 
390
 
  {}  
391
 
};
392
 
 
393
 
//-----
394
 
class ConnectSessionEventData: public SessionEventData
395
 
{
396
 
public:
397
 
 
398
 
  ConnectSessionEventData(Session &session_arg):
399
 
    SessionEventData(EventObserver::CONNECT_SESSION, session_arg)
400
 
  {}  
401
 
};
402
 
 
403
 
//-----
404
 
class DisconnectSessionEventData: public SessionEventData
405
 
{
406
 
public:
407
 
 
408
 
  DisconnectSessionEventData(Session &session_arg):
409
 
    SessionEventData(EventObserver::DISCONNECT_SESSION, session_arg)
410
 
  {}  
411
 
};
412
 
 
413
 
//-----
414
 
class BeforeStatementEventData: public SessionEventData
415
 
{
416
 
public:
417
 
 
418
 
  BeforeStatementEventData(Session &session_arg):
419
 
    SessionEventData(EventObserver::BEFORE_STATEMENT, session_arg)
420
 
  {}  
421
 
};
422
 
 
423
 
//-----
424
 
class AfterStatementEventData: public SessionEventData
425
 
{
426
 
public:
427
 
 
428
 
  AfterStatementEventData(Session &session_arg):
429
 
    SessionEventData(EventObserver::AFTER_STATEMENT, session_arg)
 
352
  SessionEventData(EventObserver::AFTER_DROP_DATABASE, session_arg), 
 
353
  db(db_arg), 
 
354
  err(err_arg) 
430
355
  {}  
431
356
};
432
357
 
434
359
class BeforeDropTableEventData: public SchemaEventData
435
360
{
436
361
public:
437
 
  const drizzled::TableIdentifier &table;
 
362
  TableIdentifier &table;
438
363
 
439
 
  BeforeDropTableEventData(Session &session_arg, const drizzled::TableIdentifier &table_arg): 
440
 
    SchemaEventData(EventObserver::BEFORE_DROP_TABLE, session_arg, table_arg.getSchemaName()), 
441
 
    table(table_arg)
 
364
  BeforeDropTableEventData(Session &session_arg, TableIdentifier &table_arg): 
 
365
  SchemaEventData(EventObserver::BEFORE_DROP_TABLE, session_arg, table_arg.getSchemaName()), 
 
366
  table(table_arg)
442
367
  {}  
443
368
};
444
369
 
446
371
class AfterDropTableEventData: public SchemaEventData
447
372
{
448
373
public:
449
 
  const drizzled::TableIdentifier &table;
 
374
  TableIdentifier &table;
450
375
  int err;
451
376
 
452
 
  AfterDropTableEventData(Session &session_arg, const drizzled::TableIdentifier &table_arg, int err_arg): 
453
 
    SchemaEventData(EventObserver::AFTER_DROP_TABLE, session_arg, table_arg.getSchemaName()), 
454
 
    table(table_arg), 
455
 
    err(err_arg)
 
377
  AfterDropTableEventData(Session &session_arg, TableIdentifier &table_arg, int err_arg): 
 
378
  SchemaEventData(EventObserver::AFTER_DROP_TABLE, session_arg, table_arg.getSchemaName()), 
 
379
  table(table_arg), 
 
380
  err(err_arg)
456
381
  {}  
457
382
};
458
383
 
460
385
class BeforeRenameTableEventData: public SchemaEventData
461
386
{
462
387
public:
463
 
  const drizzled::TableIdentifier &from;
464
 
  const drizzled::TableIdentifier &to;
 
388
  TableIdentifier &from;
 
389
  TableIdentifier &to;
465
390
 
466
 
  BeforeRenameTableEventData(Session &session_arg, const drizzled::TableIdentifier &from_arg, const drizzled::TableIdentifier &to_arg): 
467
 
    SchemaEventData(EventObserver::BEFORE_RENAME_TABLE, session_arg, from_arg.getSchemaName()), 
468
 
    from(from_arg), 
469
 
    to(to_arg)
 
391
  BeforeRenameTableEventData(Session &session_arg, TableIdentifier &from_arg, TableIdentifier &to_arg): 
 
392
  SchemaEventData(EventObserver::BEFORE_RENAME_TABLE, session_arg, from_arg.getSchemaName()), 
 
393
  from(from_arg), 
 
394
  to(to_arg)
470
395
  {}  
471
396
};
472
397
 
474
399
class AfterRenameTableEventData: public SchemaEventData
475
400
{
476
401
public:
477
 
  const drizzled::TableIdentifier &from;
478
 
  const drizzled::TableIdentifier &to;
 
402
  TableIdentifier &from;
 
403
  TableIdentifier &to;
479
404
  int err;
480
405
 
481
 
  AfterRenameTableEventData(Session &session_arg, const drizzled::TableIdentifier &from_arg, const drizzled::TableIdentifier &to_arg, int err_arg): 
482
 
    SchemaEventData(EventObserver::AFTER_RENAME_TABLE, session_arg, from_arg.getSchemaName()), 
483
 
    from(from_arg), 
484
 
    to(to_arg), 
485
 
    err(err_arg)
 
406
  AfterRenameTableEventData(Session &session_arg, TableIdentifier &from_arg, TableIdentifier &to_arg, int err_arg): 
 
407
  SchemaEventData(EventObserver::AFTER_RENAME_TABLE, session_arg, from_arg.getSchemaName()), 
 
408
  from(from_arg), 
 
409
  to(to_arg), 
 
410
  err(err_arg)
486
411
  {}  
487
412
};
488
413
 
492
417
public:
493
418
  unsigned char *row;
494
419
 
495
 
  BeforeInsertRecordEventData(Session &session_arg, Table &table_arg, unsigned char *row_arg): 
496
 
    TableEventData(EventObserver::BEFORE_INSERT_RECORD, session_arg, table_arg), 
497
 
    row(row_arg)
 
420
  BeforeInsertRecordEventData(Session &session_arg, TableShare &table_arg, unsigned char *row_arg): 
 
421
  TableEventData(EventObserver::BEFORE_INSERT_RECORD, session_arg, table_arg), 
 
422
  row(row_arg)
498
423
  {}  
499
424
};
500
425
 
505
430
  const unsigned char *row;
506
431
  int err;
507
432
 
508
 
  AfterInsertRecordEventData(Session &session_arg, Table &table_arg, const unsigned char *row_arg, int err_arg): 
509
 
    TableEventData(EventObserver::AFTER_INSERT_RECORD, session_arg, table_arg), 
510
 
    row(row_arg),
511
 
    err(err_arg)
 
433
  AfterInsertRecordEventData(Session &session_arg, TableShare &table_arg, const unsigned char *row_arg, int err_arg): 
 
434
  TableEventData(EventObserver::AFTER_INSERT_RECORD, session_arg, table_arg), 
 
435
  row(row_arg),
 
436
  err(err_arg)
512
437
  {}  
513
438
};
514
439
 
518
443
public:
519
444
  const unsigned char *row;
520
445
 
521
 
  BeforeDeleteRecordEventData(Session &session_arg, Table &table_arg, const unsigned char *row_arg): 
522
 
    TableEventData(EventObserver::BEFORE_DELETE_RECORD, session_arg, table_arg), 
523
 
    row(row_arg)
 
446
  BeforeDeleteRecordEventData(Session &session_arg, TableShare &table_arg, const unsigned char *row_arg): 
 
447
  TableEventData(EventObserver::BEFORE_DELETE_RECORD, session_arg, table_arg), 
 
448
  row(row_arg)
524
449
  {}  
525
450
};
526
451
 
531
456
  const unsigned char *row;
532
457
  int err;
533
458
 
534
 
  AfterDeleteRecordEventData(Session &session_arg, Table &table_arg, const unsigned char *row_arg, int err_arg): 
535
 
    TableEventData(EventObserver::AFTER_DELETE_RECORD, session_arg, table_arg), 
536
 
    row(row_arg),
537
 
    err(err_arg)
 
459
  AfterDeleteRecordEventData(Session &session_arg, TableShare &table_arg, const unsigned char *row_arg, int err_arg): 
 
460
  TableEventData(EventObserver::AFTER_DELETE_RECORD, session_arg, table_arg), 
 
461
  row(row_arg),
 
462
  err(err_arg)
538
463
  {}  
539
464
};
540
465
 
545
470
  const unsigned char *old_row;
546
471
  unsigned char *new_row;
547
472
 
548
 
  BeforeUpdateRecordEventData(Session &session_arg, Table &table_arg,  
549
 
                              const unsigned char *old_row_arg, 
550
 
                              unsigned char *new_row_arg): 
551
 
    TableEventData(EventObserver::BEFORE_UPDATE_RECORD, session_arg, table_arg), 
552
 
    old_row(old_row_arg),
553
 
    new_row(new_row_arg)      
554
 
  {}  
 
473
  BeforeUpdateRecordEventData(Session &session_arg, TableShare &table_arg,  
 
474
    const unsigned char *old_row_arg, 
 
475
    unsigned char *new_row_arg): 
 
476
      TableEventData(EventObserver::BEFORE_UPDATE_RECORD, session_arg, table_arg), 
 
477
      old_row(old_row_arg),
 
478
      new_row(new_row_arg)      
 
479
      {}  
555
480
};
556
481
 
557
482
//-----
562
487
  const unsigned char *new_row;
563
488
  int err;
564
489
 
565
 
  AfterUpdateRecordEventData(Session &session_arg, Table &table_arg, 
566
 
                             const unsigned char *old_row_arg, 
567
 
                             const unsigned char *new_row_arg, 
568
 
                             int err_arg): 
569
 
    TableEventData(EventObserver::AFTER_UPDATE_RECORD, session_arg, table_arg), 
570
 
    old_row(old_row_arg),
571
 
    new_row(new_row_arg),
572
 
    err(err_arg)
573
 
  {}  
 
490
  AfterUpdateRecordEventData(Session &session_arg, TableShare &table_arg, 
 
491
    const unsigned char *old_row_arg, 
 
492
    const unsigned char *new_row_arg, 
 
493
    int err_arg): 
 
494
      TableEventData(EventObserver::AFTER_UPDATE_RECORD, session_arg, table_arg), 
 
495
      old_row(old_row_arg),
 
496
      new_row(new_row_arg),
 
497
      err(err_arg)
 
498
      {}  
574
499
};
575
500
 
576
501
//=======================================================