开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
log_event.cc
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：17k
源码类别：

MySQL数据库

开发平台：

Visual C++

log_event.cc：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. #ifndef MYSQL_CLIENT
  19. #ifdef __GNUC__
  20. #pragma implementation // gcc: Class implementation
  21. #endif
  22. #include  "mysql_priv.h"
  23. #endif /* MYSQL_CLIENT */
  26. static void pretty_print_char(FILE* file, int c)
  27. {
  28.   fputc(''', file);
  29.   switch(c) {
  30.   case 'n': fprintf(file, "\n"); break;
  31.   case 'r': fprintf(file, "\r"); break;
  32.   case '\': fprintf(file, "\\"); break;
  33.   case 'b': fprintf(file, "\b"); break;
  34.   case ''': fprintf(file, "\'"); break;
  35.   case 0   : fprintf(file, "\0"); break;
  36.   default:
  37.     fputc(c, file);
  38.     break;
  39.   }
  40.   fputc(''', file);
  41. }
  43. int Query_log_event::write(IO_CACHE* file)
  44. {
  45.   return query ? Log_event::write(file) : -1; 
  46. }
  48. int Log_event::write(IO_CACHE* file)
  49. {
  50.   return (write_header(file) || write_data(file)) ? -1 : 0;
  51. }
  53. int Log_event::write_header(IO_CACHE* file)
  54. {
  55.   // make sure to change this when the header gets bigger
  56.   char buf[LOG_EVENT_HEADER_LEN];
  57.   char* pos = buf;
  58.   int4store(pos, when); // timestamp
  59.   pos += 4;
  60.   *pos++ = get_type_code(); // event type code
  61.   int4store(pos, server_id);
  62.   pos += 4;
  63.   long tmp=get_data_size() + LOG_EVENT_HEADER_LEN;
  64.   int4store(pos, tmp);
  65.   pos += 4;
  66.   return (my_b_write(file, (byte*) buf, (uint) (pos - buf)));
  67. }
  69. #ifndef MYSQL_CLIENT
  71. int Log_event::read_log_event(IO_CACHE* file, String* packet,
  72.       pthread_mutex_t* log_lock)
  73. {
  74.   ulong data_len;
  75.   char buf[LOG_EVENT_HEADER_LEN];
  76.   if (log_lock)
  77.     pthread_mutex_lock(log_lock);
  78.   if (my_b_read(file, (byte*) buf, sizeof(buf)))
  79.   {
  80.     if (log_lock) pthread_mutex_unlock(log_lock);
  81.     // if the read hits eof, we must report it as eof
  82.     // so the caller will know it can go into cond_wait to be woken up
  83.     // on the next update to the log
  84.     if(!file->error) return LOG_READ_EOF;
  85.     return file->error > 0 ? LOG_READ_TRUNC: LOG_READ_IO;
  86.   }
  87.   data_len = uint4korr(buf + EVENT_LEN_OFFSET);
  88.   if (data_len < LOG_EVENT_HEADER_LEN || data_len > max_allowed_packet)
  89.   {
  90.     if (log_lock) pthread_mutex_unlock(log_lock);
  91.     return (data_len < LOG_EVENT_HEADER_LEN) ? LOG_READ_BOGUS :
  92.       LOG_READ_TOO_LARGE;
  93.   }
  94.   packet->append(buf, sizeof(buf));
  95.   data_len -= LOG_EVENT_HEADER_LEN;
  96.   if (data_len)
  97.   {
  98.     if (packet->append(file, data_len))
  99.     {
  100.       if(log_lock)
  101. pthread_mutex_unlock(log_lock);
  102.       // here we should never hit eof in a non-error condtion
  103.       // eof means we are reading the event partially, which should
  104.       // never happen
  105.       return file->error >= 0 ? LOG_READ_TRUNC: LOG_READ_IO;
  106.     }
  107.   }
  108.   if (log_lock) pthread_mutex_unlock(log_lock);
  109.   return 0;
  110. }
  112. #endif // MYSQL_CLIENT
  114. // allocates memory - the caller is responsible for clean-up
  116. Log_event* Log_event::read_log_event(IO_CACHE* file, pthread_mutex_t* log_lock)
  117. {
  118.   time_t timestamp;
  119.   uint32 server_id;
  120.   
  121.   char buf[LOG_EVENT_HEADER_LEN-4];
  122.   if(log_lock) pthread_mutex_lock(log_lock);
  123.   if (my_b_read(file, (byte *) buf, sizeof(buf)))
  124.   {
  125.     if (log_lock) pthread_mutex_unlock(log_lock);
  126.     return NULL;
  127.   }
  128.   timestamp = uint4korr(buf);
  129.   server_id = uint4korr(buf + 5);
  130.   
  131.   switch(buf[EVENT_TYPE_OFFSET])
  132.   {
  133.   case QUERY_EVENT:
  134.   {
  135.     Query_log_event* q = new Query_log_event(file, timestamp, server_id);
  136.     if(log_lock) pthread_mutex_unlock(log_lock);
  137.     if (!q->query)
  138.     {
  139.       delete q;
  140.       q=NULL;
  141.     }
  142.     return q;
  143.   }
  144.   
  145.   case LOAD_EVENT:
  146.   {
  147.     Load_log_event* l = new Load_log_event(file, timestamp, server_id);
  148.     if(log_lock) pthread_mutex_unlock(log_lock);
  149.     if (!l->table_name)
  150.     {
  151.       delete l;
  152.       l=NULL;
  153.     }
  154.     return l;
  155.   }
  158.   case ROTATE_EVENT:
  159.   {
  160.     Rotate_log_event* r = new Rotate_log_event(file, timestamp, server_id);
  161.     if(log_lock) pthread_mutex_unlock(log_lock);
  162.     
  163.     if (!r->new_log_ident)
  164.     {
  165.       delete r;
  166.       r=NULL;
  167.     }
  168.     return r;
  169.   }
  171.   case INTVAR_EVENT:
  172.   {
  173.     Intvar_log_event* e = new Intvar_log_event(file, timestamp, server_id);
  174.     if(log_lock) pthread_mutex_unlock(log_lock);
  175.     
  176.     if (e->type == INVALID_INT_EVENT)
  177.     {
  178.       delete e;
  179.       e=NULL;
  180.     }
  181.     return e;
  182.   }
  183.   
  184.   case START_EVENT:
  185.     {
  186.       Start_log_event* e = new Start_log_event(file, timestamp, server_id);
  187.       if(log_lock) pthread_mutex_unlock(log_lock);
  188.       return e;
  189.     }   
  190.   case STOP_EVENT:
  191.     {
  192.       Stop_log_event* e = new Stop_log_event(file, timestamp, server_id);
  193.       if(log_lock) pthread_mutex_unlock(log_lock);
  194.       return e;
  195.     }
  196.   default:
  197.     break;
  198.   }
  200.   // default
  201.   if (log_lock) pthread_mutex_unlock(log_lock);
  202.   return NULL;
  203. }
  205. Log_event* Log_event::read_log_event(const char* buf, int event_len)
  206. {
  207.   if(event_len < EVENT_LEN_OFFSET ||
  208.      (uint)event_len != uint4korr(buf+EVENT_LEN_OFFSET))
  209.     return NULL; // general sanity check - will fail on a partial read
  210.   
  211.   switch(buf[EVENT_TYPE_OFFSET])
  212.   {
  213.   case QUERY_EVENT:
  214.   {
  215.     Query_log_event* q = new Query_log_event(buf, event_len);
  216.     if (!q->query)
  217.     {
  218.       delete q;
  219.       return NULL;
  220.     }
  222.     return q;
  223.   }
  225.   case LOAD_EVENT:
  226.   {
  227.     Load_log_event* l = new Load_log_event(buf, event_len);
  228.     if (!l->table_name)
  229.     {
  230.       delete l;
  231.       return NULL;
  232.     }
  234.     return l;
  235.   }
  237.   case ROTATE_EVENT:
  238.   {
  239.     Rotate_log_event* r = new Rotate_log_event(buf, event_len);
  240.     if (!r->new_log_ident)
  241.     {
  242.       delete r;
  243.       return NULL;
  244.     }
  246.     return r;
  247.   }
  248.   case START_EVENT:  return  new Start_log_event(buf);
  249.   case STOP_EVENT:  return  new Stop_log_event(buf);
  250.   case INTVAR_EVENT:  return  new Intvar_log_event(buf);
  251.   default:
  252.     break;
  253.   }
  254.   return NULL;  // default value
  255. }
  257. void Log_event::print_header(FILE* file)
  258. {
  259.   fputc('#', file);
  260.   print_timestamp(file);
  261.   fprintf(file, " server id  %d ", server_id); 
  262. }
  264. void Log_event::print_timestamp(FILE* file, time_t* ts)
  265. {
  266.   struct tm tm_tmp;
  267.   if (!ts)
  268.   {
  269.     ts = &when;
  270.   }
  271.   localtime_r(ts,&tm_tmp);
  273.   fprintf(file,"%02d%02d%02d %2d:%02d:%02d",
  274.   tm_tmp.tm_year % 100,
  275.   tm_tmp.tm_mon+1,
  276.   tm_tmp.tm_mday,
  277.   tm_tmp.tm_hour,
  278.   tm_tmp.tm_min,
  279.   tm_tmp.tm_sec);
  280. }
  283. void Start_log_event::print(FILE* file, bool short_form)
  284. {
  285.   if (short_form)
  286.     return;
  288.   print_header(file);
  289.   fprintf(file, "tStart: binlog v %d, server v %s created ", binlog_version,
  290.   server_version);
  291.   print_timestamp(file, (time_t*)&created);
  292.   fputc('n', file);
  293.   fflush(file);
  294. }
  296. void Stop_log_event::print(FILE* file, bool short_form)
  297. {
  298.   if (short_form)
  299.     return;
  301.   print_header(file);
  302.   fprintf(file, "tStopn");
  303.   fflush(file);
  304. }
  306. void Rotate_log_event::print(FILE* file, bool short_form)
  307. {
  308.   if (short_form)
  309.     return;
  311.   print_header(file);
  312.   fprintf(file, "tRotate to ");
  313.   if (new_log_ident)
  314.     my_fwrite(file, (byte*) new_log_ident, (uint)ident_len, 
  315.       MYF(MY_NABP | MY_WME));
  316.   fprintf(file, "n");
  317.   fflush(file);
  318. }
  320. Rotate_log_event::Rotate_log_event(IO_CACHE* file, time_t when_arg,
  321.    uint32 server_id):
  322.   Log_event(when_arg, 0, 0, server_id),new_log_ident(NULL),alloced(0)
  323. {
  324.   char *tmp_ident;
  325.   char buf[4];
  327.   if (my_b_read(file, (byte*) buf, sizeof(buf)))
  328.     return;
  329.   ulong event_len;
  330.   event_len = uint4korr(buf);
  331.   if (event_len < ROTATE_EVENT_OVERHEAD)
  332.     return;
  334.   ident_len = (uchar)(event_len - ROTATE_EVENT_OVERHEAD);
  335.   if (!(tmp_ident = (char*) my_malloc((uint)ident_len, MYF(MY_WME))))
  336.     return;
  337.   if (my_b_read( file, (byte*) tmp_ident, (uint) ident_len))
  338.   {
  339.     my_free((gptr) tmp_ident, MYF(0));
  340.     return;
  341.   }
  343.   new_log_ident = tmp_ident;
  344.   alloced = 1;
  345. }
  347. Start_log_event::Start_log_event(const char* buf) :Log_event(buf)
  348. {
  349.   buf += EVENT_LEN_OFFSET + 4; // skip even length
  350.   binlog_version = uint2korr(buf);
  351.   memcpy(server_version, buf + 2, sizeof(server_version));
  352.   created = uint4korr(buf + 2 + sizeof(server_version));
  353. }
  355. int Start_log_event::write_data(IO_CACHE* file)
  356. {
  357.   char buff[sizeof(server_version)+2+4];
  358.   int2store(buff,binlog_version);
  359.   memcpy(buff+2,server_version,sizeof(server_version));
  360.   int4store(buff+2+sizeof(server_version),created);
  361.   return (my_b_write(file, (byte*) buff, sizeof(buff)) ? -1 : 0);
  362. }
  364. Rotate_log_event::Rotate_log_event(const char* buf, int event_len):
  365.   Log_event(buf),new_log_ident(NULL),alloced(0)
  366. {
  367.   // the caller will ensure that event_len is what we have at
  368.   // EVENT_LEN_OFFSET
  369.   if(event_len < ROTATE_EVENT_OVERHEAD)
  370.     return;
  372.   ident_len = (uchar)(event_len - ROTATE_EVENT_OVERHEAD);
  373.   if (!(new_log_ident = (char*) my_memdup((byte*) buf + LOG_EVENT_HEADER_LEN,
  374.   (uint) ident_len, MYF(MY_WME))))
  375.     return;
  377.   alloced = 1;
  378. }
  380. int Rotate_log_event::write_data(IO_CACHE* file)
  381. {
  382.   return my_b_write(file, (byte*) new_log_ident, (uint) ident_len) ? -1 :0;
  383. }
  385. Query_log_event::Query_log_event(IO_CACHE* file, time_t when_arg,
  386.  uint32 server_id):
  387.   Log_event(when_arg,0,0,server_id),data_buf(0),query(NULL),db(NULL)
  388. {
  389.   char buf[QUERY_HEADER_LEN + 4];
  390.   ulong data_len;
  391.   if (my_b_read(file, (byte*) buf, sizeof(buf)))
  392.     return; // query == NULL will tell the
  393. // caller there was a problem
  394.   data_len = uint4korr(buf);
  395.   if (data_len < QUERY_EVENT_OVERHEAD)
  396.     return; // tear-drop attack protection :)
  398.   data_len -= QUERY_EVENT_OVERHEAD;
  399.   exec_time = uint4korr(buf + 8);
  400.   db_len = (uint)buf[12];
  401.   error_code = uint2korr(buf + 13);
  402.   
  403.   /* Allocate one byte extra for end  */
  404.   if (!(data_buf = (char*) my_malloc(data_len+1, MYF(MY_WME))))
  405.     return;
  406.   if (my_b_read( file, (byte*) data_buf, data_len))
  407.   {
  408.     my_free((gptr) data_buf, MYF(0));
  409.     data_buf = 0;
  410.     return;
  411.   }
  413.   thread_id = uint4korr(buf + 4);
  414.   db = data_buf;
  415.   query=data_buf + db_len + 1;
  416.   q_len = data_len - 1 - db_len;
  417.   *((char*) query + q_len) = 0; // Safety
  418. }
  420. Query_log_event::Query_log_event(const char* buf, int event_len):
  421.   Log_event(buf),data_buf(0), query(NULL), db(NULL)
  422. {
  423.   if ((uint)event_len < QUERY_EVENT_OVERHEAD)
  424.     return;
  425.   ulong data_len;
  426.   buf += EVENT_LEN_OFFSET;
  427.   data_len = event_len - QUERY_EVENT_OVERHEAD;
  429.   exec_time = uint4korr(buf + 8);
  430.   error_code = uint2korr(buf + 13);
  432.   if (!(data_buf = (char*) my_malloc(data_len + 1, MYF(MY_WME))))
  433.     return;
  435.   memcpy(data_buf, buf + QUERY_HEADER_LEN + 4, data_len);
  436.   thread_id = uint4korr(buf + 4);
  437.   db = data_buf;
  438.   db_len = (uint)buf[12];
  439.   query=data_buf + db_len + 1;
  440.   q_len = data_len - 1 - db_len;
  441.   *((char*)query+q_len) = 0;
  442. }
  444. void Query_log_event::print(FILE* file, bool short_form)
  445. {
  446.   char buff[40],*end; // Enough for SET TIMESTAMP
  447.   if (!short_form)
  448.   {
  449.     print_header(file);
  450.     fprintf(file, "tQuerytthread_id=%lutexec_time=%luterror_code=%dn",
  451.     (ulong) thread_id, (ulong) exec_time, error_code);
  452.   }
  454.   if (db && db[0])
  455.     fprintf(file, "use %s;n", db);
  456.   end=int10_to_str((long) when, strmov(buff,"SET TIMESTAMP="),10);
  457.   *end++=';';
  458.   *end++='n';
  459.   my_fwrite(file, (byte*) buff, (uint) (end-buff),MYF(MY_NABP | MY_WME));
  460.   my_fwrite(file, (byte*) query, q_len, MYF(MY_NABP | MY_WME));
  461.   fprintf(file, ";n");
  462. }
  464. int Query_log_event::write_data(IO_CACHE* file)
  465. {
  466.   if (!query) return -1;
  467.   
  468.   char buf[QUERY_HEADER_LEN]; 
  469.   char* pos = buf;
  470.   int4store(pos, thread_id);
  471.   pos += 4;
  472.   int4store(pos, exec_time);
  473.   pos += 4;
  474.   *pos++ = (char)db_len;
  475.   int2store(pos, error_code);
  476.   pos += 2;
  478.   return (my_b_write(file, (byte*) buf, (uint)(pos - buf)) ||
  479.   my_b_write(file, (db) ? (byte*) db : (byte*)"", db_len + 1) ||
  480.   my_b_write(file, (byte*) query, q_len)) ? -1 : 0;
  481. }
  483. Intvar_log_event:: Intvar_log_event(IO_CACHE* file, time_t when_arg,
  484.     uint32 server_id)
  485.   :Log_event(when_arg,0,0,server_id), type(INVALID_INT_EVENT)
  486. {
  487.   char buf[9+4];
  488.   if (!my_b_read(file, (byte*) buf, sizeof(buf)))
  489.   {
  490.     type = buf[4];
  491.     val = uint8korr(buf+1+4);
  492.   }
  493. }
  495. Intvar_log_event::Intvar_log_event(const char* buf):Log_event(buf)
  496. {
  497.   buf += LOG_EVENT_HEADER_LEN;
  498.   type = buf[0];
  499.   val = uint8korr(buf+1);
  500. }
  502. int Intvar_log_event::write_data(IO_CACHE* file)
  503. {
  504.   char buf[9];
  505.   buf[0] = type;
  506.   int8store(buf + 1, val);
  507.   return my_b_write(file, (byte*) buf, sizeof(buf));
  508. }
  510. void Intvar_log_event::print(FILE* file, bool short_form)
  511. {
  512.   char llbuff[22];
  513.   if(!short_form)
  514.   {
  515.     print_header(file);
  516.     fprintf(file, "tIntvarn");
  517.   }
  519.   fprintf(file, "SET ");
  520.   switch(type)
  521.   {
  522.   case LAST_INSERT_ID_EVENT:
  523.     fprintf(file, "LAST_INSERT_ID = ");
  524.     break;
  525.   case INSERT_ID_EVENT:
  526.     fprintf(file, "INSERT_ID = ");
  527.     break;
  528.   }
  529.   fprintf(file, "%s;n", llstr(val,llbuff));
  530.   fflush(file);
  531.   
  532. }
  534. int Load_log_event::write_data(IO_CACHE* file)
  535. {
  536.   char buf[LOAD_HEADER_LEN];
  537.   int4store(buf, thread_id);
  538.   int4store(buf + 4, exec_time);
  539.   int4store(buf + 8, skip_lines);
  540.   buf[12] = (char)table_name_len;
  541.   buf[13] = (char)db_len;
  542.   int4store(buf + 14, num_fields);
  543.   
  544.   if(my_b_write(file, (byte*)buf, sizeof(buf)) ||
  545.      my_b_write(file, (byte*)&sql_ex, sizeof(sql_ex)))
  546.     return 1;
  548.   if (num_fields && fields && field_lens)
  549.   {
  550.     if(my_b_write(file, (byte*)field_lens, num_fields) ||
  551.        my_b_write(file, (byte*)fields, field_block_len))
  552.       return 1;
  553.   }
  554.   if(my_b_write(file, (byte*)table_name, table_name_len + 1) ||
  555.      my_b_write(file, (byte*)db, db_len + 1) ||
  556.      my_b_write(file, (byte*)fname, fname_len))
  557.     return 1;
  558.   return 0;
  559. }
  561. Load_log_event::Load_log_event(IO_CACHE* file, time_t when, uint32 server_id):
  562.   Log_event(when,0,0,server_id),data_buf(0),num_fields(0),
  563.   fields(0),field_lens(0),field_block_len(0),
  564.   table_name(0),db(0),fname(0)
  565. {
  566.   char buf[LOAD_HEADER_LEN + 4];
  567.   ulong data_len;
  568.   if (my_b_read(file, (byte*)buf, sizeof(buf)) ||
  569.       my_b_read(file, (byte*)&sql_ex, sizeof(sql_ex)))
  570.     return;
  572.   data_len = uint4korr(buf) - LOAD_EVENT_OVERHEAD;
  573.   if (!(data_buf = (char*)my_malloc(data_len + 1, MYF(MY_WME))))
  574.     return;
  575.   if (my_b_read(file, (byte*)data_buf, data_len))
  576.     return;
  577.   copy_log_event(buf,data_len);
  578. }
  580. Load_log_event::Load_log_event(const char* buf, int event_len):
  581.   Log_event(buf),data_buf(0),num_fields(0),fields(0),
  582.   field_lens(0),field_block_len(0),
  583.   table_name(0),db(0),fname(0)
  584. {
  585.   ulong data_len;
  587.   if((uint)event_len < (LOAD_EVENT_OVERHEAD + LOG_EVENT_HEADER_LEN))
  588.     return;
  589.   buf += EVENT_LEN_OFFSET;
  590.   memcpy(&sql_ex, buf + LOAD_HEADER_LEN + 4, sizeof(sql_ex));
  591.   data_len = event_len;
  592.   
  593.   if(!(data_buf = (char*)my_malloc(data_len + 1, MYF(MY_WME))))
  594.     return;
  595.   memcpy(data_buf, buf + 22 + sizeof(sql_ex), data_len);
  596.   copy_log_event(buf, data_len);
  597. }
  599. void Load_log_event::copy_log_event(const char *buf, ulong data_len)
  600. {
  601.   thread_id = uint4korr(buf+4);
  602.   exec_time = uint4korr(buf+8);
  603.   skip_lines = uint4korr(buf + 12);
  604.   table_name_len = (uint)buf[16];
  605.   db_len = (uint)buf[17];
  606.   num_fields = uint4korr(buf + 18);
  607.   
  608.   if (num_fields > data_len) // simple sanity check against corruption
  609.     return;
  611.   field_lens = (uchar*) data_buf;
  612.   uint i;
  613.   for (i = 0; i < num_fields; i++)
  614.   {
  615.     field_block_len += (uint)field_lens[i] + 1;
  616.   }
  617.   fields = (char*)field_lens + num_fields;
  618.   
  619.   *((char*)data_buf+data_len) = 0;
  620.   table_name  = fields + field_block_len;
  621.   db = table_name + table_name_len + 1;
  622.   fname = db + db_len + 1;
  623.   fname_len = data_len - 2 - db_len - table_name_len - num_fields -
  624.     field_block_len;
  625. }
  628. void Load_log_event::print(FILE* file, bool short_form)
  629. {
  630.   if (!short_form)
  631.   {
  632.     print_header(file);
  633.     fprintf(file, "tQuerytthread_id=%ldtexec_time=%ldn",
  634.     thread_id, exec_time);
  635.   }
  637.   if(db && db[0])
  638.     fprintf(file, "use %s;n", db);
  640.   fprintf(file, "LOAD DATA INFILE '%s' ", fname);
  642.   if(sql_ex.opt_flags && REPLACE_FLAG )
  643.     fprintf(file," REPLACE ");
  644.   else if(sql_ex.opt_flags && IGNORE_FLAG )
  645.     fprintf(file," IGNORE ");
  646.   
  647.   fprintf(file, "INTO TABLE %s ", table_name);
  648.   if(!(sql_ex.empty_flags & FIELD_TERM_EMPTY))
  649.   {
  650.     fprintf(file, " FIELDS TERMINATED BY ");
  651.     pretty_print_char(file, sql_ex.field_term);
  652.   }
  654.   if(!(sql_ex.empty_flags & ENCLOSED_EMPTY))
  655.   {
  656.     if(sql_ex.opt_flags && OPT_ENCLOSED_FLAG )
  657.       fprintf(file," OPTIONALLY ");
  658.     fprintf(file, " ENCLOSED BY ");
  659.     pretty_print_char(file, sql_ex.enclosed);
  660.   }
  661.      
  662.   if(!(sql_ex.empty_flags & ESCAPED_EMPTY))
  663.   {
  664.     fprintf(file, " ESCAPED BY ");
  665.     pretty_print_char(file, sql_ex.escaped);
  666.   }
  667.      
  668.   if(!(sql_ex.empty_flags & LINE_TERM_EMPTY))
  669.   {
  670.     fprintf(file," LINES TERMINATED BY ");
  671.     pretty_print_char(file, sql_ex.line_term);
  672.   }
  674.   if(!(sql_ex.empty_flags & LINE_START_EMPTY))
  675.   {
  676.     fprintf(file," LINES STARTING BY ");
  677.     pretty_print_char(file, sql_ex.line_start);
  678.   }
  679.      
  680.   if((int)skip_lines > 0)
  681.     fprintf(file, " IGNORE %d LINES ", skip_lines);
  683.   if (num_fields)
  684.   {
  685.     uint i;
  686.     const char* field = fields;
  687.     fprintf( file, " (");
  688.     for(i = 0; i < num_fields; i++)
  689.     {
  690.       if(i)
  691. fputc(',', file);
  692.       fprintf(file, field);
  693.   
  694.       field += field_lens[i]  + 1;
  695.     }
  696.     fputc(')', file);
  697.   }
  699.   fprintf(file, ";n");
  700. }
  702. #ifndef MYSQL_CLIENT
  704. void Load_log_event::set_fields(List<Item> &fields)
  705. {
  706.   uint i;
  707.   const char* field = this->fields;
  708.   for(i = 0; i < num_fields; i++)
  709.     {
  710.       fields.push_back(new Item_field(db, table_name, field));   
  711.       field += field_lens[i]  + 1;
  712.     }
  713.   
  714. }
  716. #endif