API tools faq
paste
zamotivator

Untitled

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