← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_binlog.cc

  • Committer: mordred
  • Date: 2008-11-01 00:46:20 UTC
  • mto: (572.1.1 devel) (575.1.1 devel)
  • mto: This revision was merged to the branch mainline in revision 573.
  • Revision ID: mordred@opensolaris-20081101004620-vd0kzsl9k40hvf4p
Some updates to dtrace support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_binlog.cc
14
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
15
 
16
16
#include <drizzled/server_includes.h>
17
 
#include "rpl_rli.h"
 
17
#include <drizzled/rpl_rli.h>
18
18
#include <mysys/base64.h>
 
19
#include <drizzled/error.h>
 
20
#include <drizzled/slave.h>
19
21
 
20
22
/**
21
23
  Execute a BINLOG statement
28
30
  rli->description_event_for_exec.
29
31
*/
30
32
 
31
 
void mysql_client_binlog_statement(THD* thd)
 
33
void mysql_client_binlog_statement(Session* session)
32
34
{
33
 
  size_t coded_len= thd->lex->comment.length + 1;
 
35
  size_t coded_len= session->lex->comment.length + 1;
34
36
  size_t decoded_len= base64_needed_decoded_length(coded_len);
35
37
  assert(coded_len > 0);
36
38
 
44
46
    Format_description_event.
45
47
  */
46
48
  bool have_fd_event= true;
47
 
  if (!thd->rli_fake)
 
49
  if (!session->rli_fake)
48
50
  {
49
 
    thd->rli_fake= new Relay_log_info;
 
51
    session->rli_fake= new Relay_log_info;
50
52
#ifdef HAVE_purify
51
 
    thd->rli_fake->is_fake= true;
 
53
    session->rli_fake->is_fake= true;
52
54
#endif
53
55
    have_fd_event= false;
54
56
  }
55
 
  if (thd->rli_fake && !thd->rli_fake->relay_log.description_event_for_exec)
 
57
  if (session->rli_fake && !session->rli_fake->relay_log.description_event_for_exec)
56
58
  {
57
 
    thd->rli_fake->relay_log.description_event_for_exec=
 
59
    session->rli_fake->relay_log.description_event_for_exec=
58
60
      new Format_description_log_event(4);
59
61
    have_fd_event= false;
60
62
  }
66
68
  /*
67
69
    Out of memory check
68
70
  */
69
 
  if (!(thd->rli_fake &&
70
 
        thd->rli_fake->relay_log.description_event_for_exec &&
 
71
  if (!(session->rli_fake &&
 
72
        session->rli_fake->relay_log.description_event_for_exec &&
71
73
        buf))
72
74
  {
73
75
    my_error(ER_OUTOFMEMORY, MYF(0), 1);  /* needed 1 bytes */
74
76
    goto end;
75
77
  }
76
78
 
77
 
  thd->rli_fake->sql_thd= thd;
78
 
  thd->rli_fake->no_storage= true;
 
79
  session->rli_fake->sql_session= session;
 
80
  session->rli_fake->no_storage= true;
79
81
 
80
 
  for (char const *strptr= thd->lex->comment.str ;
81
 
       strptr < thd->lex->comment.str + thd->lex->comment.length ; )
 
82
  for (char const *strptr= session->lex->comment.str ;
 
83
       strptr < session->lex->comment.str + session->lex->comment.length ; )
82
84
  {
83
85
    char const *endptr= 0;
84
86
    int bytes_decoded= base64_decode(strptr, coded_len, buf, &endptr);
142
144
      }
143
145
 
144
146
      ev= Log_event::read_log_event(bufptr, event_len, &error,
145
 
                                    thd->rli_fake->relay_log.
 
147
                                    session->rli_fake->relay_log.
146
148
                                      description_event_for_exec);
147
149
 
148
150
      if (!ev)
158
160
      bytes_decoded -= event_len;
159
161
      bufptr += event_len;
160
162
 
161
 
      ev->thd= thd;
 
163
      ev->session= session;
162
164
      /*
163
165
        We go directly to the application phase, since we don't need
164
166
        to check if the event shall be skipped or not.
167
169
        not used at all: the rli_fake instance is used only for error
168
170
        reporting.
169
171
      */
170
 
      if (apply_event_and_update_pos(ev, thd, thd->rli_fake, false))
 
172
      if (apply_event_and_update_pos(ev, session, session->rli_fake, false))
171
173
      {
172
174
        /*
173
175
          TODO: Maybe a better error message since the BINLOG statement
189
191
    }
190
192
  }
191
193
 
192
 
  my_ok(thd);
 
194
  my_ok(session);
193
195
 
194
196
end:
195
 
  thd->rli_fake->clear_tables_to_lock();
 
197
  session->rli_fake->clear_tables_to_lock();
196
198
  free(buf);
197
199
  return;
198
200
}