API tools faq
paste
zamotivator

Untitled

zamotivator
Feb 14th, 2012
114
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 24.27 KB | None | 0 0
raw download clone embed print report
  1. diff -ruN 214/sql/log_event.cc 215/sql/log_event.cc
  2. --- 214/sql/log_event.cc 2012-02-14 15:07:28.945441523 +0900
  3. +++ 215/sql/log_event.cc 2012-02-14 15:07:22.777696559 +0900
  4. @@ -7601,8 +7601,6 @@
  5. ptr->table, &conv_table,
  6. &slave_skip_columns))
  7. {
  8. -
  9. -
  10. DBUG_PRINT("debug", ("Table: %s.%s is not compatible with master",
  11. ptr->table->s->db.str,
  12. ptr->table->s->table_name.str));
  13. @@ -7619,7 +7617,8 @@
  14. DBUG_PRINT("debug", ("Table: %s.%s is compatible with master"
  15. " - conv_table: %p, slave_skip_columns: %p",
  16. ptr->table->s->db.str,
  17. - ptr->table->s->table_name.str, conv_table, slave_skip_columns));
  18. + ptr->table->s->table_name.str,
  19. + conv_table, slave_skip_columns));
  20. ptr->m_conv_table= conv_table;
  21. ptr->m_slave_skip_columns= slave_skip_columns;
  22. }
  23. @@ -8390,34 +8389,39 @@
  24. void Table_map_log_event::column_names_prepare()
  25. {
  26. DBUG_ENTER("Table_map_log_event::column_names_prepare");
  27. +
  28. /* Should we process? */
  29. if (TRUE != opt_replication_slave_skip_columns)
  30. DBUG_VOID_RETURN;
  31. +
  32. /* calculate buffer size */
  33. m_column_names_buffer_size= 0;
  34. - Field** field_array= m_table->s->field;
  35. - const ulong field_count= m_table->s->fields;
  36. +
  37. + Field** field_array= m_table->s->field;
  38. + const ulong field_count= m_table->s->fields;
  39. DBUG_PRINT("debug", ("field_count: %lu", field_count));
  40. +
  41. for (unsigned int i= 0 ; i < field_count; ++i)
  42. {
  43. - Field* field= field_array[i];
  44. - const char* name= field->field_name;
  45. - uchar length= strlen(name);
  46. + Field *field= field_array[i];
  47. + const char *name= field->field_name;
  48. + uchar length= strlen(name);
  49. /* single byte for length + name + ',' */
  50. - m_column_names_buffer_size+= (1 + length + 1);
  51. + m_column_names_buffer_size+= 1 + length + 1;
  52. }
  53. DBUG_PRINT("debug", ("m_column_name_buffer_size: %lu",
  54. m_column_names_buffer_size));
  55. +
  56. /* calculate stored size of m_column_names_buffer_size */
  57. - uchar size_buf[sizeof(m_column_names_buffer_size) + 1];
  58. - uchar *size_buf_end= net_store_length(size_buf, m_column_names_buffer_size);
  59. + uchar size_buf[sizeof(m_column_names_buffer_size) + 1];
  60. + uchar *size_buf_end= net_store_length(size_buf, m_column_names_buffer_size);
  61. size_t size_buf_size= static_cast<size_t>(size_buf_end - size_buf);
  62. DBUG_ASSERT(size_buf_size <= sizeof(size_buf));
  63. DBUG_PRINT("debug", ("size_buf_size: %lu", (ulong)size_buf_size));
  64.  
  65. /* update event length */
  66. - m_data_size += size_buf_size;
  67. - m_data_size += m_column_names_buffer_size;
  68. + m_data_size+= size_buf_size;
  69. + m_data_size+= m_column_names_buffer_size;
  70.  
  71. /* alloc memory for save data */
  72. m_column_names_buffer=
  73. @@ -8436,21 +8440,21 @@
  74.  
  75. for (unsigned int i= 0 ; i < field_count; ++i)
  76. {
  77. - Field* field= field_array[i];
  78. - const char* name= field->field_name;
  79. - uchar length= strlen(name);
  80. + Field *field= field_array[i];
  81. + const char *name= field->field_name;
  82. + uchar length= strlen(name);
  83.  
  84. /* save length of column name */
  85. *length_memory= length;
  86. - length_memory += 1;
  87. + length_memory+= 1;
  88.  
  89. /* save name of column */
  90. memcpy(name_memory, name, length);
  91. - name_memory += length;
  92. + name_memory+= length;
  93.  
  94. /* add ',' */
  95. *reinterpret_cast<char*>(name_memory)= ',';
  96. - name_memory += 1;
  97. + name_memory+= 1;
  98. }
  99.  
  100. /* self check */
  101. @@ -8460,7 +8464,8 @@
  102.  
  103. /* replace last ','by '\0' */
  104. *(name_memory - 1)= 0;
  105. - DBUG_PRINT("debug", ("column names: '%s'", (const char*)(m_column_names_buffer + field_count)));
  106. + DBUG_PRINT("debug", ("column names: '%s'",
  107. + (const char*)(m_column_names_buffer + field_count)));
  108. DBUG_VOID_RETURN;
  109. }
  110. #endif /* !defined(MYSQL_CLIENT) */
  111. @@ -8571,16 +8576,14 @@
  112. memcpy(m_field_metadata, ptr_after_colcnt, m_field_metadata_size);
  113. ptr_after_colcnt= (uchar*)ptr_after_colcnt + m_field_metadata_size;
  114. memcpy(m_null_bits, ptr_after_colcnt, num_null_bytes);
  115. - column_names_restore((uchar*) buf,
  116. - event_len,
  117. + column_names_restore((uchar*) buf, event_len,
  118. ptr_after_colcnt + num_null_bytes);
  119. }
  120. }
  121.  
  122. DBUG_VOID_RETURN;
  123. }
  124. -void Table_map_log_event::column_names_restore(uchar* event_buf,
  125. - uint event_len,
  126. +void Table_map_log_event::column_names_restore(uchar *event_buf, uint event_len,
  127. uchar* buf)
  128. {
  129. DBUG_ENTER("Table_map_log_event::column_names_restore");
  130. @@ -8871,8 +8874,7 @@
  131. new (&table_list->m_tabledef)
  132. table_def(m_coltype, m_colcnt,
  133. m_field_metadata, m_field_metadata_size,
  134. - m_null_bits, m_flags,
  135. - m_column_names_buffer,
  136. + m_null_bits, m_flags, m_column_names_buffer,
  137. m_column_names_buffer_size);
  138. table_list->m_tabledef_valid= TRUE;
  139. table_list->skip_temporary= 1;
  140. @@ -9003,14 +9005,11 @@
  141. return false;
  142. /* Prepare size of data for write */
  143. uchar buf[sizeof(m_column_names_buffer_size)+1];
  144. - uchar *buf_end= net_store_length(buf, (size_t)m_column_names_buffer_size);
  145. + uchar *buf_end= net_store_length(buf, (size_t) m_column_names_buffer_size);
  146. size_t buf_size= static_cast<size_t>(buf_end - buf);
  147. DBUG_ASSERT(buf_size < sizeof(buf));
  148. - return (my_b_safe_write(file,
  149. - buf,
  150. - buf_size) ||
  151. - my_b_safe_write(file,
  152. - m_column_names_buffer,
  153. + return (my_b_safe_write(file,buf, buf_size) ||
  154. + my_b_safe_write(file, m_column_names_buffer,
  155. m_column_names_buffer_size));
  156. }
  157. #endif
  158. @@ -9030,8 +9029,7 @@
  159. if (m_column_names_buffer == NULL)
  160. {
  161. DBUG_ASSERT(m_column_names_buffer_size == 0);
  162. - bytes= my_snprintf(buf, sizeof(buf),
  163. - "table_id: %lu (%s.%s)",
  164. + bytes= my_snprintf(buf, sizeof(buf), "table_id: %lu (%s.%s)",
  165. m_table_id, m_dbnam, m_tblnam);
  166. }
  167. else
  168. diff -ruN 214/sql/log_event.h 215/sql/log_event.h
  169. --- 214/sql/log_event.h 2012-02-14 15:07:28.951442248 +0900
  170. +++ 215/sql/log_event.h 2012-02-14 15:07:22.782697163 +0900
  171. @@ -3439,8 +3439,7 @@
  172. {
  173. return new table_def(m_coltype, m_colcnt, m_field_metadata,
  174. m_field_metadata_size, m_null_bits, m_flags,
  175. - m_column_names_buffer,
  176. - m_column_names_buffer_size);
  177. + m_column_names_buffer, m_column_names_buffer_size);
  178. }
  179. ulong get_table_id() const { return m_table_id; }
  180. const char *get_table_name() const { return m_tblnam; }
  181. @@ -3452,8 +3451,8 @@
  182. virtual Log_event_type get_type_code() { return TABLE_MAP_EVENT; }
  183. virtual bool is_valid() const
  184. {
  185. - return (m_memory != NULL) && column_names_valid();
  186. /* we check malloc */
  187. + return (m_memory != NULL) && column_names_valid();
  188. }
  189.  
  190. virtual int get_data_size() { return (uint) m_data_size; }
  191. @@ -3503,9 +3502,10 @@
  192. ulong m_field_metadata_size;
  193. uchar *m_null_bits;
  194. uchar *m_meta_memory;
  195. +
  196. /* column names */
  197. - uchar* get_column_names() const;
  198. - bool column_names_valid() const;
  199. + uchar* get_column_names() const;
  200. + bool column_names_valid() const;
  201. /* column names buffer */
  202. uchar *m_column_names_buffer;
  203. /* column names buffer size */
  204. @@ -3515,9 +3515,7 @@
  205. bool column_names_store(IO_CACHE*);
  206. #endif /* !defined(MYSQL_CLIENT) */
  207. #if defined(HAVE_REPLICATION)
  208. - void column_names_restore(uchar* event_buf,
  209. - uint event_len,
  210. - uchar* buf);
  211. + void column_names_restore(uchar* event_buf, uint event_len, uchar* buf);
  212. #endif /* defined(HAVE_REPLICATION) */
  213. };
  214.  
  215. diff -ruN 214/sql/rpl_record.cc 215/sql/rpl_record.cc
  216. --- 214/sql/rpl_record.cc 2012-02-14 15:07:28.967444180 +0900
  217. +++ 215/sql/rpl_record.cc 2012-02-14 15:07:22.793698492 +0900
  218. @@ -183,16 +183,12 @@
  219. A generic, internal, error caused the unpacking to fail.
  220. */
  221. #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
  222. -void skip_master_column(uint *master_column_index,
  223. - uint master_column_count,
  224. - MY_BITMAP const *cols,
  225. - unsigned int *null_mask,
  226. - unsigned int *null_bits,
  227. - uchar const **null_ptr,
  228. - uchar const * const row_data,
  229. +void skip_master_column(uint *master_column_index, uint master_column_count,
  230. + MY_BITMAP const *cols, unsigned int *null_mask,
  231. + unsigned int *null_bits, uchar const **null_ptr,
  232. + uchar const *const row_data,
  233. size_t const master_null_byte_count,
  234. - table_def *tabledef,
  235. - uchar const **pack_ptr)
  236. + table_def *tabledef, uchar const **pack_ptr)
  237. {
  238. DBUG_ASSERT(*master_column_index < master_column_count);
  239. if (bitmap_is_set(cols, *master_column_index))
  240. @@ -209,13 +205,14 @@
  241. tabledef->maybe_null(*master_column_index)))
  242. {
  243. *pack_ptr += tabledef->calc_field_size(*master_column_index,
  244. - (uchar *) *pack_ptr);
  245. + (uchar *) *pack_ptr);
  246. }
  247. (*null_mask) <<= 1;
  248. }
  249. ++(*master_column_index);
  250. }
  251.  
  252. +
  253. int
  254. unpack_row(Relay_log_info const *rli,
  255. TABLE *table, uint const colcnt,
  256. @@ -243,11 +240,9 @@
  257. unsigned int null_bits= *null_ptr++;
  258. uint master_column_index= 0;
  259. table_def *tabledef= NULL;
  260. - TABLE *conv_tbl= NULL;
  261. + TABLE *conv_tbl= NULL;
  262. MY_BITMAP *slave_skip_columns= NULL;
  263. - bool table_found= rli && rli->get_table_data(table,
  264. - &tabledef,
  265. - &conv_tbl,
  266. + bool table_found= rli && rli->get_table_data(table, &tabledef, &conv_tbl,
  267. &slave_skip_columns);
  268. DBUG_PRINT("debug", ("Table data: table_found: %d, tabldef: %p"
  269. ", conv_tbl: %p, slave_skip_columns %p",
  270. @@ -264,24 +259,15 @@
  271. */
  272. if (rli && !table_found)
  273. DBUG_RETURN(HA_ERR_GENERIC);
  274. - for (field_ptr= begin_ptr ;
  275. - field_ptr < end_ptr &&
  276. - *field_ptr &&
  277. - (master_column_index < master_column_count); ++field_ptr)
  278. + for (field_ptr= begin_ptr; field_ptr < end_ptr && *field_ptr &&
  279. + (master_column_index < master_column_count); ++field_ptr)
  280. {
  281. DBUG_ASSERT(master_column_index < master_column_count);
  282. while(FALSE == bitmap_is_set(slave_skip_columns, master_column_index))
  283. {
  284. - skip_master_column(&master_column_index,
  285. - master_column_count,
  286. - cols,
  287. - &null_mask,
  288. - &null_bits,
  289. - &null_ptr,
  290. - row_data,
  291. - master_null_byte_count,
  292. - tabledef,
  293. - &pack_ptr);
  294. + skip_master_column(&master_column_index, master_column_count, cols,
  295. + &null_mask, &null_bits, &null_ptr, row_data,
  296. + master_null_byte_count, tabledef, &pack_ptr);
  297. }
  298. DBUG_ASSERT(master_column_index < master_column_count);
  299.  
  300. @@ -296,8 +282,7 @@
  301. DBUG_PRINT("debug", ("Conversion %srequired for field '%s' "
  302. "(master: #%u slave: #%u)",
  303. conv_field ? "" : "not ",
  304. - (*field_ptr)->field_name,
  305. - master_column_index + 1,
  306. + (*field_ptr)->field_name, master_column_index + 1,
  307. slave_column_index + 1));
  308. DBUG_ASSERT(f != NULL);
  309.  
  310. @@ -409,9 +394,8 @@
  311. field->sql_type(target_type);
  312. rli->report(ERROR_LEVEL, ER_SLAVE_CONVERSION_WITHOUT_TRUNCATE_FAILED,
  313. ER(ER_SLAVE_CONVERSION_WITHOUT_TRUNCATE_FAILED),
  314. - field->field_name,
  315. - master_column_index, slave_column_index,
  316. - db_name, tbl_name,
  317. + field->field_name, master_column_index,
  318. + slave_column_index, db_name, tbl_name,
  319. source_type.c_ptr_safe(), target_type.c_ptr_safe());
  320. error= ER_SLAVE_CONVERSION_WITHOUT_TRUNCATE_FAILED;
  321. DBUG_RETURN(error);
  322. @@ -441,16 +425,9 @@
  323. */
  324. while(master_column_index < master_column_count)
  325. {
  326. - skip_master_column(&master_column_index,
  327. - master_column_count,
  328. - cols,
  329. - &null_mask,
  330. - &null_bits,
  331. - &null_ptr,
  332. - row_data,
  333. - master_null_byte_count,
  334. - tabledef,
  335. - &pack_ptr);
  336. + skip_master_column(&master_column_index, master_column_count, cols,
  337. + &null_mask, &null_bits, &null_ptr, row_data,
  338. + master_null_byte_count, tabledef, &pack_ptr);
  339. }
  340.  
  341. /*
  342. diff -ruN 214/sql/rpl_rli.h 215/sql/rpl_rli.h
  343. --- 214/sql/rpl_rli.h 2012-02-14 15:07:28.967444180 +0900
  344. +++ 215/sql/rpl_rli.h 2012-02-14 15:07:22.794698613 +0900
  345. @@ -327,8 +327,7 @@
  346. uint tables_to_lock_count; /* RBR: Count of tables to lock */
  347. table_mapping m_table_map; /* RBR: Mapping table-id to table */
  348.  
  349. - bool get_table_data(TABLE *table_arg,
  350. - table_def **tabledef_var,
  351. + bool get_table_data(TABLE *table_arg, table_def **tabledef_var,
  352. TABLE **conv_table_var,
  353. MY_BITMAP **slave_skip_columns) const
  354. {
  355. @@ -341,12 +340,10 @@
  356. *slave_skip_columns=
  357. static_cast<RPL_TABLE_LIST*>(ptr)->m_slave_skip_columns;
  358. DBUG_PRINT("debug", ("Fetching table data for table %s.%s:"
  359. - " tabledef: %p"
  360. - ", conv_table: %p"
  361. + " tabledef: %p, conv_table: %p"
  362. ", slave_skip_columns: %p",
  363. table_arg->s->db.str, table_arg->s->table_name.str,
  364. - *tabledef_var,
  365. - *conv_table_var,
  366. + *tabledef_var, *conv_table_var,
  367. *slave_skip_columns));
  368. return true;
  369. }
  370. diff -ruN 214/sql/rpl_utility.cc 215/sql/rpl_utility.cc
  371. --- 214/sql/rpl_utility.cc 2012-02-14 15:07:28.969444423 +0900
  372. +++ 215/sql/rpl_utility.cc 2012-02-14 15:07:22.794698613 +0900
  373. @@ -770,17 +770,17 @@
  374. */
  375. bool
  376. table_def::compatible_with(THD *thd, Relay_log_info *rli,
  377. - TABLE *table,
  378. - TABLE **conv_table_var,
  379. + TABLE *table, TABLE **conv_table_var,
  380. MY_BITMAP **slave_skip_columns_var)
  381. const
  382. {
  383. /*
  384. We only check the initial columns for the tables.
  385. */
  386. - TABLE *tmp_table= NULL;
  387. - MY_BITMAP *slave_skip_columns= *slave_skip_columns_var=
  388. - create_slave_skip_columns(thd, rli, table);
  389. + TABLE *tmp_table= NULL;
  390. + MY_BITMAP *slave_skip_columns= create_slave_skip_columns(thd, rli, table);
  391. + *slave_skip_columns_var= slave_skip_columns;
  392. +
  393.  
  394. Field **const begin_ptr = table->field;
  395. Field **field_ptr;
  396. @@ -790,10 +790,8 @@
  397.  
  398. const uint master_column_count= size();
  399.  
  400. - for(field_ptr= begin_ptr;
  401. - field_ptr < end_ptr && *field_ptr &&
  402. - (master_column_index < master_column_count);
  403. - ++field_ptr)
  404. + for(field_ptr= begin_ptr; field_ptr < end_ptr && *field_ptr &&
  405. + (master_column_index < master_column_count); ++field_ptr)
  406. {
  407. DBUG_ASSERT(master_column_index < master_column_count);
  408. uint slave_column_index= field_ptr - begin_ptr;
  409. @@ -805,15 +803,13 @@
  410. DBUG_ASSERT(master_column_index < master_column_count);
  411. Field *const field= table->field[slave_column_index];
  412. int order;
  413. - if (can_convert_field_to(field,
  414. - type(master_column_index),
  415. - field_metadata(master_column_index),
  416. - rli, m_flags, &order))
  417. + if (can_convert_field_to(field, type(master_column_index),
  418. + field_metadata(master_column_index), rli, m_flags,
  419. + &order))
  420. {
  421. DBUG_PRINT("debug", ("Checking master column %d and slave column %d-"
  422. " field '%s' can be converted - order: %d",
  423. - master_column_index + 1,
  424. - slave_column_index + 1,
  425. + master_column_index + 1, slave_column_index + 1,
  426. field->field_name, order));
  427. DBUG_ASSERT(order >= -1 && order <= 1);
  428.  
  429. @@ -845,10 +841,8 @@
  430. {
  431. DBUG_PRINT("debug", ("Checking column '%s' "
  432. "(master: #%d, slave: # %d)"
  433. - " can not be converted",
  434. - field->field_name,
  435. - master_column_index + 1,
  436. - slave_column_index + 1));
  437. + " can not be converted", field->field_name,
  438. + master_column_index + 1, slave_column_index + 1));
  439. DBUG_ASSERT(master_column_index < size() &&
  440. slave_column_index < table->s->fields);
  441. DBUG_ASSERT(table->s->db.str && table->s->table_name.str);
  442. @@ -864,11 +858,9 @@
  443. field->sql_type(target_type);
  444. rli->report(ERROR_LEVEL, ER_SLAVE_CONVERSION_FAILED,
  445. ER(ER_SLAVE_CONVERSION_FAILED),
  446. - field->field_name,
  447. - master_column_index,
  448. - slave_column_index,
  449. - db_name, tbl_name,
  450. - source_type.c_ptr_safe(), target_type.c_ptr_safe());
  451. + field->field_name, master_column_index, slave_column_index,
  452. + db_name, tbl_name, source_type.c_ptr_safe(),
  453. + target_type.c_ptr_safe());
  454. return false;
  455. }
  456. }
  457. @@ -898,23 +890,22 @@
  458. }
  459.  
  460.  
  461. -MY_BITMAP* table_def::create_slave_skip_columns(THD *thd,
  462. - Relay_log_info *rli,
  463. +MY_BITMAP* table_def::create_slave_skip_columns(THD *thd, Relay_log_info *rli,
  464. TABLE *target_table) const
  465. {
  466. MY_BITMAP *result= (MY_BITMAP*) alloc_root(thd->mem_root, sizeof(MY_BITMAP));
  467. uint master_count= size();
  468. - uint slave_count= target_table->s->fields;
  469. - uint bit_count= max(master_count, slave_count);
  470. + uint slave_count= target_table->s->fields;
  471. + uint bit_count= max(master_count, slave_count);
  472. bitmap_init(result, NULL, bit_count, FALSE);
  473. if (m_columns.is_valid())
  474. {
  475. Field** slave_field_array= target_table->field;
  476. for(uint slave_index= 0; slave_index < slave_count; ++slave_index)
  477. {
  478. - Field *slave_field= slave_field_array[slave_index];
  479. + Field *slave_field= slave_field_array[slave_index];
  480. const char *slave_name= slave_field->field_name;
  481. - uint master_index= m_columns.index(slave_name);
  482. + uint master_index= m_columns.index(slave_name);
  483. if (master_count != master_index)
  484. {
  485. bitmap_test_and_set(result, master_index);
  486. @@ -931,6 +922,7 @@
  487. return result;
  488. }
  489.  
  490. +
  491. /**
  492. Create a conversion table.
  493.  
  494. @@ -1025,18 +1017,17 @@
  495.  
  496. #endif /* MYSQL_CLIENT */
  497.  
  498. +
  499. table_def::Column_Names::Column_Names(ulong column_names_count,
  500. uchar *column_names_buffer,
  501. ulong column_names_buffer_size) :
  502. -m_count(column_names_count)
  503. -, m_offsets(NULL)
  504. -, m_buffer(NULL)
  505. - , m_buffer_size(column_names_buffer_size)
  506. + m_count(column_names_count), m_offsets(NULL), m_buffer(NULL),
  507. + m_buffer_size(column_names_buffer_size)
  508. {
  509. if (is_valid())
  510. {
  511. /* Need add check of malloc result */
  512. - m_offsets= (ulong*) my_malloc(sizeof(ulong)*m_count, MYF(MY_WME));
  513. + m_offsets= (ulong*) my_malloc(sizeof(ulong)*m_count, MYF(MY_WME));
  514. m_buffer= (uchar*) my_malloc(m_buffer_size, MYF(MY_WME));
  515. memcpy(m_buffer, column_names_buffer, m_buffer_size);
  516. for(ulong index= 0; index < m_count; ++index)
  517. @@ -1046,31 +1037,41 @@
  518. for(ulong index= 0, offset= m_count; index < m_count; ++index)
  519. {
  520. m_offsets[index]= offset;
  521. - m_buffer[ offset + length(index) ]= 0;
  522. + m_buffer[offset + length(index)]= 0;
  523. offset+= length(index) + 1;
  524. }
  525. }
  526. }
  527. +
  528. +
  529. bool table_def::Column_Names::is_valid() const
  530. {
  531. return m_buffer_size != 0;
  532. }
  533. +
  534. +
  535. table_def::Column_Names::~Column_Names()
  536. {
  537. my_free(m_offsets, MYF(MY_ALLOW_ZERO_PTR));
  538. my_free(m_buffer, MYF(MY_ALLOW_ZERO_PTR));
  539. }
  540. +
  541. +
  542. const char* table_def::Column_Names::name(ulong index) const
  543. {
  544. DBUG_ASSERT(index < m_count);
  545. return reinterpret_cast<const char*>(m_buffer + m_offsets[index]);
  546. }
  547. -uchar table_def::Column_Names::length(ulong index) const
  548. +
  549. +
  550. +uchar table_def::Column_Names::length(ulong index) const
  551. {
  552. DBUG_ASSERT(index < m_count);
  553. return m_buffer[index];
  554. }
  555. -ulong table_def::Column_Names::index(const char* another_name) const
  556. +
  557. +
  558. +ulong table_def::Column_Names::index(const char* another_name) const
  559. {
  560. ulong another_length= strlen(another_name);
  561. for(ulong index= 0; index < m_count; ++index)
  562. @@ -1083,14 +1084,14 @@
  563. return m_count;
  564. }
  565.  
  566. +
  567. table_def::table_def(unsigned char *types, ulong size,
  568. uchar *field_metadata, int metadata_size,
  569. - uchar *null_bitmap, uint16 flags,
  570. - uchar *column_names,
  571. + uchar *null_bitmap, uint16 flags, uchar *column_names,
  572. size_t column_names_size)
  573. : m_size(size), m_type(0), m_field_metadata_size(metadata_size),
  574. m_field_metadata(0), m_null_bits(0), m_flags(flags),
  575. - m_memory(NULL), m_columns(size, column_names, column_names_size)
  576. + m_memory(NULL), m_columns(size, column_names, column_names_size)
  577. {
  578. m_memory= (uchar *)my_multi_malloc(MYF(MY_WME), &m_type, size,
  579. &m_field_metadata, size * sizeof(uint16),
  580. diff -ruN 214/sql/rpl_utility.h 215/sql/rpl_utility.h
  581. --- 214/sql/rpl_utility.h 2012-02-14 15:07:28.970444544 +0900
  582. +++ 215/sql/rpl_utility.h 2012-02-14 15:07:22.795698733 +0900
  583. @@ -55,8 +55,7 @@
  584. */
  585. table_def(unsigned char *types, ulong size, uchar *field_metadata,
  586. int metadata_size, uchar *null_bitmap, uint16 flags,
  587. - uchar *column_names,
  588. - size_t column_names_size);
  589. + uchar *column_names, size_t column_names_size);
  590.  
  591. ~table_def();
  592.  
  593. @@ -208,11 +207,9 @@
  594. @return A pointer to a temporary table with memory allocated in the
  595. thread's memroot, NULL if the table could not be created
  596. */
  597. - TABLE *create_conversion_table(THD *thd,
  598. - Relay_log_info *rli,
  599. + TABLE *create_conversion_table(THD *thd, Relay_log_info *rli,
  600. TABLE *target_table) const;
  601. - MY_BITMAP* create_slave_skip_columns(THD *thd,
  602. - Relay_log_info *rli,
  603. + MY_BITMAP* create_slave_skip_columns(THD *thd, Relay_log_info *rli,
  604. TABLE *target_table) const;
  605. #endif
  606.  
  607. @@ -229,8 +226,7 @@
  608. struct Column_Names
  609. {
  610. public:
  611. - Column_Names(ulong column_names_count,
  612. - uchar *column_names_buffer,
  613. + Column_Names(ulong column_names_count, uchar *column_names_buffer,
  614. ulong column_names_buffer_size);
  615. ~Column_Names();
  616. public:
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!