← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/sql_binlog.cc

Merged from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/sql_binlog.cc
30
30
 
31
31
void mysql_client_binlog_statement(THD* thd)
32
32
{
33
 
  DBUG_ENTER("mysql_client_binlog_statement");
34
 
  DBUG_PRINT("info",("binlog base64: '%*s'",
35
 
                     (int) (thd->lex->comment.length < 2048 ?
36
 
                            thd->lex->comment.length : 2048),
37
 
                     thd->lex->comment.str));
38
 
 
39
33
  size_t coded_len= thd->lex->comment.length + 1;
40
34
  size_t decoded_len= base64_needed_decoded_length(coded_len);
41
 
  DBUG_ASSERT(coded_len > 0);
 
35
  assert(coded_len > 0);
42
36
 
43
37
  /*
44
38
    Allocation
49
43
    one here.  In this case, the first event we read must be a
50
44
    Format_description_event.
51
45
  */
52
 
  my_bool have_fd_event= TRUE;
 
46
  my_bool have_fd_event= true;
53
47
  if (!thd->rli_fake)
54
48
  {
55
49
    thd->rli_fake= new Relay_log_info;
56
50
#ifdef HAVE_purify
57
 
    thd->rli_fake->is_fake= TRUE;
 
51
    thd->rli_fake->is_fake= true;
58
52
#endif
59
 
    have_fd_event= FALSE;
 
53
    have_fd_event= false;
60
54
  }
61
55
  if (thd->rli_fake && !thd->rli_fake->relay_log.description_event_for_exec)
62
56
  {
63
57
    thd->rli_fake->relay_log.description_event_for_exec=
64
58
      new Format_description_log_event(4);
65
 
    have_fd_event= FALSE;
 
59
    have_fd_event= false;
66
60
  }
67
61
 
68
62
  const char *error= 0;
81
75
  }
82
76
 
83
77
  thd->rli_fake->sql_thd= thd;
84
 
  thd->rli_fake->no_storage= TRUE;
 
78
  thd->rli_fake->no_storage= true;
85
79
 
86
80
  for (char const *strptr= thd->lex->comment.str ;
87
81
       strptr < thd->lex->comment.str + thd->lex->comment.length ; )
89
83
    char const *endptr= 0;
90
84
    int bytes_decoded= base64_decode(strptr, coded_len, buf, &endptr);
91
85
 
92
 
#ifndef HAVE_purify
93
 
      /*
94
 
        This debug printout should not be used for valgrind builds
95
 
        since it will read from unassigned memory.
96
 
      */
97
 
    DBUG_PRINT("info",
98
 
               ("bytes_decoded: %d  strptr: 0x%lx  endptr: 0x%lx ('%c':%d)",
99
 
                bytes_decoded, (long) strptr, (long) endptr, *endptr,
100
 
                *endptr));
101
 
#endif
102
 
 
103
86
    if (bytes_decoded < 0)
104
87
    {
105
88
      my_error(ER_BASE64_DECODE_ERROR, MYF(0));
108
91
    else if (bytes_decoded == 0)
109
92
      break; // If no bytes where read, the string contained only whitespace
110
93
 
111
 
    DBUG_ASSERT(bytes_decoded > 0);
112
 
    DBUG_ASSERT(endptr > strptr);
 
94
    assert(bytes_decoded > 0);
 
95
    assert(endptr > strptr);
113
96
    coded_len-= endptr - strptr;
114
97
    strptr= endptr;
115
98
 
124
107
      order to be able to read exactly what is necessary.
125
108
    */
126
109
 
127
 
    DBUG_PRINT("info",("binlog base64 decoded_len: %lu  bytes_decoded: %d",
128
 
                       (ulong) decoded_len, bytes_decoded));
129
 
 
130
110
    /*
131
111
      Now we start to read events of the buffer, until there are no
132
112
      more.
137
117
        Checking that the first event in the buffer is not truncated.
138
118
      */
139
119
      ulong event_len= uint4korr(bufptr + EVENT_LEN_OFFSET);
140
 
      DBUG_PRINT("info", ("event_len=%lu, bytes_decoded=%d",
141
 
                          event_len, bytes_decoded));
142
120
      if (bytes_decoded < EVENT_LEN_OFFSET || (uint) bytes_decoded < event_len)
143
121
      {
144
122
        my_error(ER_SYNTAX_ERROR, MYF(0));
154
132
      {
155
133
        int type = bufptr[EVENT_TYPE_OFFSET];
156
134
        if (type == FORMAT_DESCRIPTION_EVENT || type == START_EVENT_V3)
157
 
          have_fd_event= TRUE;
 
135
          have_fd_event= true;
158
136
        else
159
137
        {
160
138
          my_error(ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT,
167
145
                                    thd->rli_fake->relay_log.
168
146
                                      description_event_for_exec);
169
147
 
170
 
      DBUG_PRINT("info",("binlog base64 err=%s", error));
171
148
      if (!ev)
172
149
      {
173
150
        /*
181
158
      bytes_decoded -= event_len;
182
159
      bufptr += event_len;
183
160
 
184
 
      DBUG_PRINT("info",("ev->get_type_code()=%d", ev->get_type_code()));
185
 
#ifndef HAVE_purify
186
 
      /*
187
 
        This debug printout should not be used for valgrind builds
188
 
        since it will read from unassigned memory.
189
 
      */
190
 
      DBUG_PRINT("info",("bufptr+EVENT_TYPE_OFFSET: 0x%lx",
191
 
                         (long) (bufptr+EVENT_TYPE_OFFSET)));
192
 
      DBUG_PRINT("info", ("bytes_decoded: %d   bufptr: 0x%lx  buf[EVENT_LEN_OFFSET]: %lu",
193
 
                          bytes_decoded, (long) bufptr,
194
 
                          (ulong) uint4korr(bufptr+EVENT_LEN_OFFSET)));
195
 
#endif
196
161
      ev->thd= thd;
197
162
      /*
198
163
        We go directly to the application phase, since we don't need
203
168
        reporting.
204
169
      */
205
170
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
206
 
      if (apply_event_and_update_pos(ev, thd, thd->rli_fake, FALSE))
 
171
      if (apply_event_and_update_pos(ev, thd, thd->rli_fake, false))
207
172
      {
208
173
        /*
209
174
          TODO: Maybe a better error message since the BINLOG statement
226
191
    }
227
192
  }
228
193
 
229
 
 
230
 
  DBUG_PRINT("info",("binlog base64 execution finished successfully"));
231
194
  my_ok(thd);
232
195
 
233
196
end:
234
197
  thd->rli_fake->clear_tables_to_lock();
235
198
  my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
236
 
  DBUG_VOID_RETURN;
 
199
  return;
237
200
}