← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/event_observer.h

merged with latest trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/event_observer.h
50
50
namespace drizzled
51
51
{
52
52
 
 
53
class Table;
53
54
class TableShare;
54
55
 
55
56
namespace plugin
56
57
{
57
 
  class EventObserverList;
58
 
  class EventData;
 
58
class EventObserverList;
 
59
class EventData;
59
60
 
60
61
 
61
62
class EventObserver : public Plugin
62
 
{
63
 
  EventObserver();
64
 
  EventObserver(const EventObserver &);
65
 
  EventObserver& operator=(const EventObserver &);
66
 
public:
67
 
  explicit EventObserver(std::string name_arg)
68
 
    : Plugin(name_arg, "EventObserver")
69
 
  {}
70
 
  virtual ~EventObserver() {}
 
63
  {
 
64
    EventObserver();
 
65
    EventObserver(const EventObserver &);
 
66
    EventObserver& operator=(const EventObserver &);
 
67
  public:
 
68
    explicit EventObserver(std::string name_arg)
 
69
      : Plugin(name_arg, "EventObserver")
 
70
    {}
 
71
    virtual ~EventObserver() {}
71
72
 
72
 
   enum EventType{
 
73
    enum EventType{
73
74
      /* Session events: */
74
75
      BEFORE_CREATE_DATABASE, AFTER_CREATE_DATABASE, 
75
76
      BEFORE_DROP_DATABASE,   AFTER_DROP_DATABASE,
76
 
      
 
77
 
77
78
      /* Schema events: */
78
79
      BEFORE_DROP_TABLE,   AFTER_DROP_TABLE, 
79
80
      BEFORE_RENAME_TABLE, AFTER_RENAME_TABLE, 
80
 
      
 
81
 
81
82
      /* Table events: */
82
83
      BEFORE_INSERT_RECORD,   AFTER_INSERT_RECORD, 
83
84
      BEFORE_UPDATE_RECORD,   AFTER_UPDATE_RECORD, 
84
85
      BEFORE_DELETE_RECORD,   AFTER_DELETE_RECORD,
85
 
      
 
86
 
86
87
      /* The max event ID marker. */
87
88
      MAX_EVENT_COUNT
88
89
    };
89
90
 
90
 
  static const char *eventName(EventType event) 
91
 
  {
92
 
    switch(event) 
 
91
    static const char *eventName(EventType event) 
93
92
    {
94
 
    case BEFORE_DROP_TABLE:
95
 
      return "BEFORE_DROP_TABLE";
96
 
    
97
 
    case AFTER_DROP_TABLE:
98
 
      return "AFTER_DROP_TABLE";
99
 
    
100
 
    case BEFORE_RENAME_TABLE:
101
 
      return "BEFORE_RENAME_TABLE";
102
 
      
103
 
    case AFTER_RENAME_TABLE:
104
 
      return "AFTER_RENAME_TABLE";
105
 
      
106
 
    case BEFORE_INSERT_RECORD:
107
 
       return "BEFORE_INSERT_RECORD";
108
 
      
109
 
    case AFTER_INSERT_RECORD:
110
 
       return "AFTER_INSERT_RECORD";
111
 
      
112
 
    case BEFORE_UPDATE_RECORD:
113
 
      return "BEFORE_UPDATE_RECORD";
114
 
               
115
 
    case AFTER_UPDATE_RECORD:
116
 
      return "AFTER_UPDATE_RECORD";
117
 
      
118
 
    case BEFORE_DELETE_RECORD:
119
 
      return "BEFORE_DELETE_RECORD";
120
 
 
121
 
    case AFTER_DELETE_RECORD:
122
 
      return "AFTER_DELETE_RECORD";
123
 
 
124
 
    case BEFORE_CREATE_DATABASE:
125
 
      return "BEFORE_CREATE_DATABASE";
126
 
 
127
 
    case AFTER_CREATE_DATABASE:
128
 
      return "AFTER_CREATE_DATABASE";
129
 
 
130
 
    case BEFORE_DROP_DATABASE:
131
 
      return "BEFORE_DROP_DATABASE";
132
 
 
133
 
    case AFTER_DROP_DATABASE:
134
 
      return "AFTER_DROP_DATABASE";
135
 
      
136
 
    case MAX_EVENT_COUNT:
137
 
      break;
138
 
   }
139
 
    
140
 
    return "Unknown";
141
 
  }
142
 
  
143
 
  /*==========================================================*/
144
 
  /* registerEvents() must be implemented to allow the plugin to
145
 
   * register which events it is interested in.
146
 
   */
147
 
  virtual void registerTableEventsDo(TableShare &, EventObserverList &){}
148
 
  virtual void registerSchemaEventsDo(const std::string &/*db*/, EventObserverList &) {}
149
 
  virtual void registerSessionEventsDo(Session &, EventObserverList &) {}
150
 
 
151
 
  virtual bool observeEventDo(EventData &)= 0;
152
 
 
153
 
  /*==========================================================*/
154
 
  /* Static access methods called by drizzle: */
155
 
  static bool addPlugin(EventObserver *handler);
156
 
  static void removePlugin(EventObserver *handler);
157
 
  
158
 
  /*==========================================================*/
159
 
  /* Register an event of interest for this plugin. 
160
 
   * This is called from with in the plugin when registering itself.
161
 
   *
162
 
   * The position field is used to indicate the order the event observer is to be 
163
 
   * called. If the event observer must be called before any other observer then 
164
 
   * the position must be set to 1. If it must be called last then the position must be 
165
 
   * set to -1. A position of 0 indicated the position doesn't matter.
166
 
   *
167
 
   * If 2 plugins require the same position then which is called first in not guarenteed.
168
 
   * In this case a warrning will be logged but execution will continue.
169
 
   * 
170
 
   * It is good practice that if the event position matters not to hard code the position
171
 
   * but supply a systen variable so that it can be set at runtime so that the user can
172
 
   * decide which event should be called first.
173
 
   */
174
 
  void registerEvent(EventObserverList &observers, EventType event, int32_t position= 0); 
175
 
 
176
 
  /*==========================================================*/
177
 
  /* Called from drizzle to register all events for all event plugins 
178
 
   * interested in this table. 
179
 
   */
180
 
  static void registerTableEvents(TableShare &table_share); 
181
 
  static void deregisterTableEvents(TableShare &table_share); 
182
 
 
183
 
  /*==========================================================*/
184
 
  /* Called from drizzle to register all events for all event plugins 
185
 
  * interested in this database. 
186
 
  */
187
 
  static void registerSchemaEvents(Session &session, const std::string &db); 
188
 
  static void deregisterSchemaEvents(Session &session, const std::string &db); 
189
 
 
190
 
  /*==========================================================*/
191
 
  /* Called from drizzle to register all events for all event plugins 
192
 
  * interested in this session. 
193
 
  */
194
 
  static void registerSessionEvents(Session &session); 
195
 
  static void deregisterSessionEvents(Session &session); 
196
 
 
197
 
 
198
 
  /*==========================================================*/
199
 
  /* Static meathods called by drizzle to notify interested plugins 
200
 
   * of a schema an event,
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
 
   */
222
 
  static bool beforeCreateDatabase(Session &session, const std::string &db);
223
 
  static bool afterCreateDatabase(Session &session, const std::string &db, int err);
224
 
  static bool beforeDropDatabase(Session &session, const std::string &db);
225
 
  static bool afterDropDatabase(Session &session, const std::string &db, int err);
226
 
 
227
 
};
 
93
      switch(event) 
 
94
      {
 
95
      case BEFORE_DROP_TABLE:
 
96
        return "BEFORE_DROP_TABLE";
 
97
 
 
98
      case AFTER_DROP_TABLE:
 
99
        return "AFTER_DROP_TABLE";
 
100
 
 
101
      case BEFORE_RENAME_TABLE:
 
102
        return "BEFORE_RENAME_TABLE";
 
103
 
 
104
      case AFTER_RENAME_TABLE:
 
105
        return "AFTER_RENAME_TABLE";
 
106
 
 
107
      case BEFORE_INSERT_RECORD:
 
108
        return "BEFORE_INSERT_RECORD";
 
109
 
 
110
      case AFTER_INSERT_RECORD:
 
111
        return "AFTER_INSERT_RECORD";
 
112
 
 
113
      case BEFORE_UPDATE_RECORD:
 
114
        return "BEFORE_UPDATE_RECORD";
 
115
 
 
116
      case AFTER_UPDATE_RECORD:
 
117
        return "AFTER_UPDATE_RECORD";
 
118
 
 
119
      case BEFORE_DELETE_RECORD:
 
120
        return "BEFORE_DELETE_RECORD";
 
121
 
 
122
      case AFTER_DELETE_RECORD:
 
123
        return "AFTER_DELETE_RECORD";
 
124
 
 
125
      case BEFORE_CREATE_DATABASE:
 
126
        return "BEFORE_CREATE_DATABASE";
 
127
 
 
128
      case AFTER_CREATE_DATABASE:
 
129
        return "AFTER_CREATE_DATABASE";
 
130
 
 
131
      case BEFORE_DROP_DATABASE:
 
132
        return "BEFORE_DROP_DATABASE";
 
133
 
 
134
      case AFTER_DROP_DATABASE:
 
135
        return "AFTER_DROP_DATABASE";
 
136
 
 
137
      case MAX_EVENT_COUNT:
 
138
        break;
 
139
      }
 
140
 
 
141
      return "Unknown";
 
142
    }
 
143
 
 
144
    /*==========================================================*/
 
145
    /* registerEvents() must be implemented to allow the plugin to
 
146
     * register which events it is interested in.
 
147
   */
 
148
    virtual void registerTableEventsDo(TableShare &, EventObserverList &){}
 
149
    virtual void registerSchemaEventsDo(const std::string &/*db*/, EventObserverList &) {}
 
150
    virtual void registerSessionEventsDo(Session &, EventObserverList &) {}
 
151
 
 
152
    virtual bool observeEventDo(EventData &)= 0;
 
153
 
 
154
    /*==========================================================*/
 
155
    /* Static access methods called by drizzle: */
 
156
    static bool addPlugin(EventObserver *handler);
 
157
    static void removePlugin(EventObserver *handler);
 
158
 
 
159
    /*==========================================================*/
 
160
    /* Register an event of interest for this plugin. 
 
161
     * This is called from with in the plugin when registering itself.
 
162
     *
 
163
     * The position field is used to indicate the order the event observer is to be 
 
164
     * called. If the event observer must be called before any other observer then 
 
165
     * the position must be set to 1. If it must be called last then the position must be 
 
166
     * set to -1. A position of 0 indicated the position doesn't matter.
 
167
     *
 
168
     * If 2 plugins require the same position then which is called first in not guarenteed.
 
169
     * In this case a warrning will be logged but execution will continue.
 
170
     * 
 
171
     * It is good practice that if the event position matters not to hard code the position
 
172
     * but supply a systen variable so that it can be set at runtime so that the user can
 
173
     * decide which event should be called first.
 
174
   */
 
175
    void registerEvent(EventObserverList &observers, EventType event, int32_t position= 0); 
 
176
 
 
177
    /*==========================================================*/
 
178
    /* Called from drizzle to register all events for all event plugins 
 
179
     * interested in this table. 
 
180
   */
 
181
    static void registerTableEvents(TableShare &table_share); 
 
182
    static void deregisterTableEvents(TableShare &table_share); 
 
183
 
 
184
    /*==========================================================*/
 
185
    /* Called from drizzle to register all events for all event plugins 
 
186
     * interested in this database. 
 
187
   */
 
188
    static void registerSchemaEvents(Session &session, const std::string &db); 
 
189
    static void deregisterSchemaEvents(Session &session, const std::string &db); 
 
190
 
 
191
    /*==========================================================*/
 
192
    /* Called from drizzle to register all events for all event plugins 
 
193
     * interested in this session. 
 
194
   */
 
195
    static void registerSessionEvents(Session &session); 
 
196
    static void deregisterSessionEvents(Session &session); 
 
197
 
 
198
 
 
199
    /*==========================================================*/
 
200
    /* Static meathods called by drizzle to notify interested plugins 
 
201
     * of a schema an event,
 
202
   */
 
203
    static bool beforeDropTable(Session &session, TableIdentifier &table);
 
204
    static bool afterDropTable(Session &session, TableIdentifier &table, int err);
 
205
    static bool beforeRenameTable(Session &session, TableIdentifier &from, TableIdentifier &to);
 
206
    static bool afterRenameTable(Session &session, TableIdentifier &from, TableIdentifier &to, int err);
 
207
 
 
208
    /*==========================================================*/
 
209
    /* Static meathods called by drizzle to notify interested plugins 
 
210
     * of a table an event,
 
211
   */
 
212
    static bool beforeInsertRecord(Table &table, unsigned char *buf);
 
213
    static bool afterInsertRecord(Table &table, const unsigned char *buf, int err);
 
214
    static bool beforeDeleteRecord(Table &table, const unsigned char *buf);
 
215
    static bool afterDeleteRecord(Table &table, const unsigned char *buf, int err);
 
216
    static bool beforeUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data);
 
217
    static bool afterUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data, int err);
 
218
 
 
219
    /*==========================================================*/
 
220
    /* Static meathods called by drizzle to notify interested plugins 
 
221
     * of a table an event,
 
222
   */
 
223
    static bool beforeCreateDatabase(Session &session, const std::string &db);
 
224
    static bool afterCreateDatabase(Session &session, const std::string &db, int err);
 
225
    static bool beforeDropDatabase(Session &session, const std::string &db);
 
226
    static bool afterDropDatabase(Session &session, const std::string &db, int err);
 
227
 
 
228
  };
228
229
 
229
230
 
230
231
/* EventObserver data classes: */
233
234
{
234
235
public:
235
236
  EventObserver::EventType event;
236
 
   
 
237
 
237
238
  EventData(EventObserver::EventType event_arg): 
238
239
    event(event_arg),
239
240
    observerList(NULL)
240
 
    {}
 
241
  {}
241
242
  virtual ~EventData(){}
242
 
  
 
243
 
243
244
  // Call all the event observers that are registered for this event.
244
245
  virtual bool callEventObservers();
245
 
  
 
246
 
246
247
protected:
247
248
  EventObserverList *observerList;
248
 
  
 
249
 
249
250
};
250
251
 
251
252
//-----
253
254
{
254
255
public:
255
256
  Session &session;
256
 
  
 
257
 
257
258
  SessionEventData(EventObserver::EventType event_arg, Session &session_arg): 
258
259
    EventData(event_arg),
259
260
    session(session_arg)
260
 
    {}
 
261
  {}
261
262
  virtual ~SessionEventData(){}
262
 
  
263
 
  
 
263
 
 
264
 
264
265
  // Call all the event observers that are registered for this event.
265
266
  virtual bool callEventObservers();
266
267
};
271
272
public:
272
273
  Session &session;
273
274
  const std::string &db;
274
 
  
 
275
 
275
276
  SchemaEventData(EventObserver::EventType event_arg, Session &session_arg, const std::string &db_arg): 
276
277
    EventData(event_arg),
277
278
    session(session_arg),
278
279
    db(db_arg)
279
 
    {}
 
280
  {}
280
281
  virtual ~SchemaEventData(){}
281
 
  
282
 
  
 
282
 
 
283
 
283
284
  // Call all the event observers that are registered for this event.
284
285
  virtual bool callEventObservers();
285
286
};
289
290
{
290
291
public:
291
292
  Session &session;
292
 
  TableShare &table;  
293
 
  
294
 
  TableEventData(EventObserver::EventType event_arg, Session &session_arg, TableShare &table_arg): 
 
293
  Table &table;  
 
294
 
 
295
  TableEventData(EventObserver::EventType event_arg, Session &session_arg, Table &table_arg): 
295
296
    EventData(event_arg),
296
297
    session(session_arg),
297
298
    table(table_arg)
298
 
    {}
 
299
  {}
299
300
  virtual ~TableEventData(){}
300
 
  
301
 
  
 
301
 
 
302
 
302
303
  // Call all the event observers that are registered for this event.
303
304
  virtual bool callEventObservers();
304
305
};
310
311
  const std::string &db;
311
312
 
312
313
  BeforeCreateDatabaseEventData(Session &session_arg, const std::string &db_arg): 
313
 
  SessionEventData(EventObserver::BEFORE_CREATE_DATABASE, session_arg), 
314
 
  db(db_arg)
 
314
    SessionEventData(EventObserver::BEFORE_CREATE_DATABASE, session_arg), 
 
315
    db(db_arg)
315
316
  {}  
316
317
};
317
318
 
323
324
  int err;
324
325
 
325
326
  AfterCreateDatabaseEventData(Session &session_arg, const std::string &db_arg, int err_arg): 
326
 
  SessionEventData(EventObserver::AFTER_CREATE_DATABASE, session_arg), 
327
 
  db(db_arg), 
328
 
  err(err_arg)
 
327
    SessionEventData(EventObserver::AFTER_CREATE_DATABASE, session_arg), 
 
328
    db(db_arg), 
 
329
    err(err_arg)
329
330
  {}  
330
331
};
331
332
 
336
337
  const std::string &db;
337
338
 
338
339
  BeforeDropDatabaseEventData(Session &session_arg, const std::string &db_arg): 
339
 
  SessionEventData(EventObserver::BEFORE_DROP_DATABASE, session_arg), 
340
 
  db(db_arg)
 
340
    SessionEventData(EventObserver::BEFORE_DROP_DATABASE, session_arg), 
 
341
    db(db_arg)
341
342
  {}  
342
343
};
343
344
 
349
350
  int err;
350
351
 
351
352
  AfterDropDatabaseEventData(Session &session_arg, const std::string &db_arg, int err_arg): 
352
 
  SessionEventData(EventObserver::AFTER_DROP_DATABASE, session_arg), 
353
 
  db(db_arg), 
354
 
  err(err_arg) 
 
353
    SessionEventData(EventObserver::AFTER_DROP_DATABASE, session_arg), 
 
354
    db(db_arg), 
 
355
    err(err_arg) 
355
356
  {}  
356
357
};
357
358
 
362
363
  TableIdentifier &table;
363
364
 
364
365
  BeforeDropTableEventData(Session &session_arg, TableIdentifier &table_arg): 
365
 
  SchemaEventData(EventObserver::BEFORE_DROP_TABLE, session_arg, table_arg.getSchemaName()), 
366
 
  table(table_arg)
 
366
    SchemaEventData(EventObserver::BEFORE_DROP_TABLE, session_arg, table_arg.getSchemaName()), 
 
367
    table(table_arg)
367
368
  {}  
368
369
};
369
370
 
375
376
  int err;
376
377
 
377
378
  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)
 
379
    SchemaEventData(EventObserver::AFTER_DROP_TABLE, session_arg, table_arg.getSchemaName()), 
 
380
    table(table_arg), 
 
381
    err(err_arg)
381
382
  {}  
382
383
};
383
384
 
389
390
  TableIdentifier &to;
390
391
 
391
392
  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)
 
393
    SchemaEventData(EventObserver::BEFORE_RENAME_TABLE, session_arg, from_arg.getSchemaName()), 
 
394
    from(from_arg), 
 
395
    to(to_arg)
395
396
  {}  
396
397
};
397
398
 
404
405
  int err;
405
406
 
406
407
  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)
 
408
    SchemaEventData(EventObserver::AFTER_RENAME_TABLE, session_arg, from_arg.getSchemaName()), 
 
409
    from(from_arg), 
 
410
    to(to_arg), 
 
411
    err(err_arg)
411
412
  {}  
412
413
};
413
414
 
417
418
public:
418
419
  unsigned char *row;
419
420
 
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)
 
421
  BeforeInsertRecordEventData(Session &session_arg, Table &table_arg, unsigned char *row_arg): 
 
422
    TableEventData(EventObserver::BEFORE_INSERT_RECORD, session_arg, table_arg), 
 
423
    row(row_arg)
423
424
  {}  
424
425
};
425
426
 
430
431
  const unsigned char *row;
431
432
  int err;
432
433
 
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)
 
434
  AfterInsertRecordEventData(Session &session_arg, Table &table_arg, const unsigned char *row_arg, int err_arg): 
 
435
    TableEventData(EventObserver::AFTER_INSERT_RECORD, session_arg, table_arg), 
 
436
    row(row_arg),
 
437
    err(err_arg)
437
438
  {}  
438
439
};
439
440
 
443
444
public:
444
445
  const unsigned char *row;
445
446
 
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)
 
447
  BeforeDeleteRecordEventData(Session &session_arg, Table &table_arg, const unsigned char *row_arg): 
 
448
    TableEventData(EventObserver::BEFORE_DELETE_RECORD, session_arg, table_arg), 
 
449
    row(row_arg)
449
450
  {}  
450
451
};
451
452
 
456
457
  const unsigned char *row;
457
458
  int err;
458
459
 
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)
 
460
  AfterDeleteRecordEventData(Session &session_arg, Table &table_arg, const unsigned char *row_arg, int err_arg): 
 
461
    TableEventData(EventObserver::AFTER_DELETE_RECORD, session_arg, table_arg), 
 
462
    row(row_arg),
 
463
    err(err_arg)
463
464
  {}  
464
465
};
465
466
 
470
471
  const unsigned char *old_row;
471
472
  unsigned char *new_row;
472
473
 
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
 
      {}  
 
474
  BeforeUpdateRecordEventData(Session &session_arg, Table &table_arg,  
 
475
                              const unsigned char *old_row_arg, 
 
476
                              unsigned char *new_row_arg): 
 
477
    TableEventData(EventObserver::BEFORE_UPDATE_RECORD, session_arg, table_arg), 
 
478
    old_row(old_row_arg),
 
479
    new_row(new_row_arg)      
 
480
  {}  
480
481
};
481
482
 
482
483
//-----
487
488
  const unsigned char *new_row;
488
489
  int err;
489
490
 
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
 
      {}  
 
491
  AfterUpdateRecordEventData(Session &session_arg, Table &table_arg, 
 
492
                             const unsigned char *old_row_arg, 
 
493
                             const unsigned char *new_row_arg, 
 
494
                             int err_arg): 
 
495
    TableEventData(EventObserver::AFTER_UPDATE_RECORD, session_arg, table_arg), 
 
496
    old_row(old_row_arg),
 
497
    new_row(new_row_arg),
 
498
    err(err_arg)
 
499
  {}  
499
500
};
500
501
 
501
502
//=======================================================