← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/hello_events/hello_events.cc

  • Committer: lbieber at stabletransit
  • Date: 2010-10-16 03:50:39 UTC
  • mfrom: (1857.1.2 build)
  • Revision ID: lbieber@drizzle-build-n02.wc1.dfw1.stabletransit.com-20101016035039-j8shvyewemcex8kc
Merge Vijay - fix for distcheck
Merge Brian - clean up events add tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/hello_events/hello_events.cc
74
74
static bool observeBeforeInsertRecord(BeforeInsertRecordEventData &data)
75
75
{
76
76
 
77
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeBeforeInsertRecord(%s)\n", data.table.getTableName());
 
77
  static int count= 0;
 
78
  count++;
 
79
  data.session.setVariable("BEFORE_INSERT_RECORD", boost::lexical_cast<std::string>(count));
78
80
  return false;
79
81
}
80
82
 
81
83
//---
82
84
static void observeAfterInsertRecord(AfterInsertRecordEventData &data)
83
85
{
84
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeAfterInsertRecord(%s) err = %d\n", data.table.getTableName(), data.err);
 
86
  static int count= 0;
 
87
  count++;
 
88
  data.session.setVariable("AFTER_INSERT_RECORD", boost::lexical_cast<std::string>(count));
85
89
}
86
90
 
87
91
//---
88
92
static bool observeBeforeDeleteRecord(BeforeDeleteRecordEventData &data)
89
93
{
90
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeBeforeDeleteRecord(%s)\n", data.table.getTableName());
 
94
  static int count= 0;
 
95
  count++;
 
96
  data.session.setVariable("AFTER_DELETE_RECORD", boost::lexical_cast<std::string>(count));
91
97
  return false;
92
98
}
93
99
 
94
100
//---
95
101
static void observeAfterDeleteRecord(AfterDeleteRecordEventData &data)
96
102
{
97
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeAfterDeleteRecord(%s) err = %d\n", data.table.getTableName(), data.err);
 
103
  static int count= 0;
 
104
  count++;
 
105
  data.session.setVariable("AFTER_DELETE_RECORD", boost::lexical_cast<std::string>(count));
98
106
}
99
107
 
100
108
//---
101
109
static bool observeBeforeUpdateRecord(BeforeUpdateRecordEventData &data)
102
110
{
103
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeBeforeUpdateRecord(%s)\n", data.table.getTableName());
 
111
  static int count= 0;
 
112
  count++;
 
113
  data.session.setVariable("BEFORE_UPDATE_RECORD", boost::lexical_cast<std::string>(count));
104
114
  return false;
105
115
}
106
116
 
107
117
//---
108
118
static void observeAfterUpdateRecord(AfterUpdateRecordEventData &data)
109
119
{
110
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeAfterUpdateRecord(%s) err = %d\n", data.table.getTableName(), data.err);
 
120
  static int count= 0;
 
121
  count++;
 
122
  data.session.setVariable("AFTER_UPDATE_RECORD", boost::lexical_cast<std::string>(count));
111
123
}
112
124
 
113
125
//==================================
114
126
// My schema event observers: 
115
127
static void observeAfterDropTable(AfterDropTableEventData &data)
116
128
{
117
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeAfterDropTable(%s) err = %d\n", data.table.getTableName().c_str(), data.err);
 
129
  static int count= 0;
 
130
  count++;
 
131
  data.session.setVariable("AFTER_DROP_TABLE", boost::lexical_cast<std::string>(count));
118
132
}
119
133
 
120
134
//---
121
135
static void observeAfterRenameTable(AfterRenameTableEventData &data)
122
136
{
123
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeAfterRenameTable(%s, %s) err = %d\n", data.from.getTableName().c_str(), data.to.getTableName().c_str(), data.err);
 
137
  static int count= 0;
 
138
  count++;
 
139
  data.session.setVariable("AFTER_RENAME_TABLE", boost::lexical_cast<std::string>(count));
124
140
}
125
141
 
126
142
//---
127
143
static void observeAfterCreateDatabase(AfterCreateDatabaseEventData &data)
128
144
{
129
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeAfterCreateDatabase(%s) err = %d\n", data.db.c_str(), data.err);
 
145
  static int count= 0;
 
146
  count++;
 
147
  data.session.setVariable("AFTER_CREATE_DATABASE", boost::lexical_cast<std::string>(count));
130
148
}
131
149
 
132
150
//---
133
151
static void observeAfterDropDatabase(AfterDropDatabaseEventData &data)
134
152
{
135
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeAfterDropDatabase(%s) err = %d\n", data.db.c_str(), data.err);
 
153
  static int count= 0;
 
154
  count++;
 
155
  data.session.setVariable("AFTER_DROP_DATABASE", boost::lexical_cast<std::string>(count));
136
156
}
137
157
 
138
158
//---
139
159
static void observeConnectSession(ConnectSessionEventData &data)
140
160
{
141
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeConnectSession %d\n", static_cast<int>(data.session.getSessionId()));
 
161
  static int count= 0;
 
162
  count++;
 
163
  data.session.setVariable("CONNECT_SESSION", boost::lexical_cast<std::string>(count));
142
164
}
143
165
 
144
166
//---
145
167
static void observeDisconnectSession(DisconnectSessionEventData &data)
146
168
{
147
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeDisconnectSession %d\n", static_cast<int>(data.session.getSessionId()));
 
169
  static int count= 0;
 
170
  count++;
 
171
  data.session.setVariable("DISCONNECT_SESSION", boost::lexical_cast<std::string>(count));
148
172
}
149
173
 
150
174
//---
151
175
static void observeBeforeStatement(BeforeStatementEventData &data)
152
176
{
153
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeBeforeStatement %d\n", static_cast<int>(data.session.getSessionId()));
 
177
  static int count= 0;
 
178
  count++;
 
179
  data.session.setVariable("BEFORE_STATEMENT", boost::lexical_cast<std::string>(count));
154
180
}
155
181
 
156
182
//---
157
183
static void observeAfterStatement(AfterStatementEventData &data)
158
184
{
159
 
  fprintf(stderr, PLUGIN_NAME" EVENT observeAfterStatement %d\n", static_cast<int>(data.session.getSessionId()));
 
185
  static int count= 0;
 
186
  count++;
 
187
  data.session.setVariable("AFTER_STATEMENT", boost::lexical_cast<std::string>(count));
160
188
}
161
189
 
162
190
HelloEvents::~HelloEvents()
464
492
                           INT32_MAX -1, /* max */
465
493
                           0 /* blk */);
466
494
 
467
 
static DRIZZLE_SYSVAR_INT(post_drop_db_position,
468
 
                           sysvar_post_drop_db_position,
469
 
                           PLUGIN_VAR_NOCMDARG,
470
 
                           N_("After drop database event observer call position"),
471
 
                           NULL, /* check func */
472
 
                           NULL, /* update func */
473
 
                           -1, /* default */
474
 
                           INT32_MIN +1, /* min */
475
 
                           -1, /* max */
476
 
                           0 /* blk */);
477
 
 
478
495
static drizzle_sys_var* system_var[]= {
479
496
  DRIZZLE_SYSVAR(watch_databases),
480
497
  DRIZZLE_SYSVAR(watch_tables),
481
498
  DRIZZLE_SYSVAR(enable),
482
499
  DRIZZLE_SYSVAR(before_write_position),
483
500
  DRIZZLE_SYSVAR(before_update_position),
484
 
  DRIZZLE_SYSVAR(post_drop_db_position),
485
501
  NULL
486
502
};
487
503