sql_load.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:27k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /* Copy data from a textfile to table */
  14. #include "mysql_priv.h"
  15. #include <my_dir.h>
  16. #include <m_ctype.h>
  17. #include "sql_repl.h"
  18. class READ_INFO {
  19.   File file;
  20.   byte *buffer, /* Buffer for read text */
  21. *end_of_buff; /* Data in bufferts ends here */
  22.   uint buff_length, /* Length of buffert */
  23. max_length; /* Max length of row */
  24.   char *field_term_ptr,*line_term_ptr,*line_start_ptr,*line_start_end;
  25.   uint field_term_length,line_term_length,enclosed_length;
  26.   int field_term_char,line_term_char,enclosed_char,escape_char;
  27.   int *stack,*stack_pos;
  28.   bool found_end_of_line,start_of_line,eof;
  29.   bool  need_end_io_cache;
  30.   IO_CACHE cache;
  31.   NET *io_net;
  32. public:
  33.   bool error,line_cuted,found_null,enclosed;
  34.   byte *row_start, /* Found row starts here */
  35. *row_end; /* Found row ends here */
  36.   CHARSET_INFO *read_charset;
  37.   READ_INFO(File file,uint tot_length,CHARSET_INFO *cs,
  38.     String &field_term,String &line_start,String &line_term,
  39.     String &enclosed,int escape,bool get_it_from_net, bool is_fifo);
  40.   ~READ_INFO();
  41.   int read_field();
  42.   int read_fixed_length(void);
  43.   int next_line(void);
  44.   char unescape(char chr);
  45.   int terminator(char *ptr,uint length);
  46.   bool find_start_of_fields();
  47.   /*
  48.     We need to force cache close before destructor is invoked to log
  49.     the last read block
  50.   */
  51.   void end_io_cache()
  52.   {
  53.     ::end_io_cache(&cache);
  54.     need_end_io_cache = 0;
  55.   }
  56.   /*
  57.     Either this method, or we need to make cache public
  58.     Arg must be set from mysql_load() since constructor does not see
  59.     either the table or THD value
  60.   */
  61.   void set_io_cache_arg(void* arg) { cache.arg = arg; }
  62. };
  63. static int read_fixed_length(THD *thd,COPY_INFO &info,TABLE *table,
  64.      List<Item> &fields, READ_INFO &read_info,
  65.      ulong skip_lines);
  66. static int read_sep_field(THD *thd,COPY_INFO &info,TABLE *table,
  67.   List<Item> &fields, READ_INFO &read_info,
  68.   String &enclosed, ulong skip_lines);
  69. int mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list,
  70.        List<Item> &fields, enum enum_duplicates handle_duplicates,
  71.                bool ignore,
  72.        bool read_file_from_client,thr_lock_type lock_type)
  73. {
  74.   char name[FN_REFLEN];
  75.   File file;
  76.   TABLE *table;
  77.   int error;
  78.   String *field_term=ex->field_term,*escaped=ex->escaped;
  79.   String *enclosed=ex->enclosed;
  80.   bool is_fifo=0;
  81. #ifndef EMBEDDED_LIBRARY
  82.   LOAD_FILE_INFO lf_info;
  83. #endif
  84.   char *db = table_list->db; // This is never null
  85.   /*
  86.     If path for file is not defined, we will use the current database.
  87.     If this is not set, we will use the directory where the table to be
  88.     loaded is located
  89.   */
  90.   char *tdb= thd->db ? thd->db : db; // Result is never null
  91.   bool transactional_table, log_delayed;
  92.   ulong skip_lines= ex->skip_lines;
  93.   DBUG_ENTER("mysql_load");
  94. #ifdef EMBEDDED_LIBRARY
  95.   read_file_from_client  = 0; //server is always in the same process 
  96. #endif
  97.   if (escaped->length() > 1 || enclosed->length() > 1)
  98.   {
  99.     my_message(ER_WRONG_FIELD_TERMINATORS,ER(ER_WRONG_FIELD_TERMINATORS),
  100.        MYF(0));
  101.     DBUG_RETURN(-1);
  102.   }
  103.   /*
  104.     This needs to be done before external_lock
  105.   */
  106.   ha_enable_transaction(thd, FALSE); 
  107.   if (!(table = open_ltable(thd,table_list,lock_type)))
  108.     DBUG_RETURN(-1);
  109.   transactional_table= table->file->has_transactions();
  110.   log_delayed= (transactional_table || table->tmp_table);
  111.   if (!fields.elements)
  112.   {
  113.     Field **field;
  114.     for (field=table->field; *field ; field++)
  115.       fields.push_back(new Item_field(*field));
  116.   }
  117.   else
  118.   { // Part field list
  119.     thd->dupp_field=0;
  120.     if (setup_tables(table_list) ||
  121. setup_fields(thd, 0, table_list, fields, 1, 0, 0))
  122.       DBUG_RETURN(-1);
  123.     if (thd->dupp_field)
  124.     {
  125.       my_error(ER_FIELD_SPECIFIED_TWICE, MYF(0), thd->dupp_field->field_name);
  126.       DBUG_RETURN(-1);
  127.     }
  128.   }
  129.   uint tot_length=0;
  130.   bool use_blobs=0,use_timestamp=0;
  131.   List_iterator_fast<Item> it(fields);
  132.   Item_field *field;
  133.   while ((field=(Item_field*) it++))
  134.   {
  135.     if (field->field->flags & BLOB_FLAG)
  136.     {
  137.       use_blobs=1;
  138.       tot_length+=256; // Will be extended if needed
  139.     }
  140.     else
  141.       tot_length+=field->field->field_length;
  142.     if (!field_term->length() && !(field->field->flags & NOT_NULL_FLAG))
  143.       field->field->set_notnull();
  144.     if (field->field == table->timestamp_field)
  145.       use_timestamp=1;
  146.   }
  147.   if (use_blobs && !ex->line_term->length() && !field_term->length())
  148.   {
  149.     my_message(ER_BLOBS_AND_NO_TERMINATED,ER(ER_BLOBS_AND_NO_TERMINATED),
  150.        MYF(0));
  151.     DBUG_RETURN(-1);
  152.   }
  153.   /* We can't give an error in the middle when using LOCAL files */
  154.   if (read_file_from_client && handle_duplicates == DUP_ERROR)
  155.     ignore= 1;
  156. #ifndef EMBEDDED_LIBRARY
  157.   if (read_file_from_client)
  158.   {
  159.     (void)net_request_file(&thd->net,ex->file_name);
  160.     file = -1;
  161.   }
  162.   else
  163. #endif
  164.   {
  165. #ifdef DONT_ALLOW_FULL_LOAD_DATA_PATHS
  166.     ex->file_name+=dirname_length(ex->file_name);
  167. #endif
  168.     if (!dirname_length(ex->file_name))
  169.     {
  170.       strxnmov(name, FN_REFLEN, mysql_real_data_home, tdb, NullS);
  171.       (void) fn_format(name, ex->file_name, name, "",
  172.        MY_RELATIVE_PATH | MY_UNPACK_FILENAME);
  173.     }
  174.     else
  175.     {
  176.       (void) fn_format(name, ex->file_name, mysql_real_data_home, "",
  177.        MY_RELATIVE_PATH | MY_UNPACK_FILENAME);
  178. #if !defined(__WIN__) && !defined(OS2) && ! defined(__NETWARE__)
  179.       MY_STAT stat_info;
  180.       if (!my_stat(name,&stat_info,MYF(MY_WME)))
  181. DBUG_RETURN(-1);
  182.       // if we are not in slave thread, the file must be:
  183.       if (!thd->slave_thread &&
  184.   !((stat_info.st_mode & S_IROTH) == S_IROTH &&  // readable by others
  185. #ifndef __EMX__
  186.     (stat_info.st_mode & S_IFLNK) != S_IFLNK && // and not a symlink
  187. #endif
  188.     ((stat_info.st_mode & S_IFREG) == S_IFREG ||
  189.      (stat_info.st_mode & S_IFIFO) == S_IFIFO)))
  190.       {
  191. my_error(ER_TEXTFILE_NOT_READABLE,MYF(0),name);
  192. DBUG_RETURN(-1);
  193.       }
  194.       if ((stat_info.st_mode & S_IFIFO) == S_IFIFO)
  195. is_fifo = 1;
  196. #endif
  197.     }
  198.     if ((file=my_open(name,O_RDONLY,MYF(MY_WME))) < 0)
  199.       DBUG_RETURN(-1);
  200.   }
  201.   COPY_INFO info;
  202.   bzero((char*) &info,sizeof(info));
  203.   info.ignore= ignore;
  204.   info.handle_duplicates=handle_duplicates;
  205.   info.escape_char=escaped->length() ? (*escaped)[0] : INT_MAX;
  206.   READ_INFO read_info(file,tot_length,thd->variables.collation_database,
  207.       *field_term,*ex->line_start, *ex->line_term, *enclosed,
  208.       info.escape_char, read_file_from_client, is_fifo);
  209.   if (read_info.error)
  210.   {
  211.     if (file >= 0)
  212.       my_close(file,MYF(0)); // no files in net reading
  213.     DBUG_RETURN(-1); // Can't allocate buffers
  214.   }
  215. #ifndef EMBEDDED_LIBRARY
  216.   if (mysql_bin_log.is_open())
  217.   {
  218.     lf_info.thd = thd;
  219.     lf_info.ex = ex;
  220.     lf_info.db = db;
  221.     lf_info.table_name = table_list->real_name;
  222.     lf_info.fields = &fields;
  223.     lf_info.ignore= ignore;
  224.     lf_info.handle_dup = handle_duplicates;
  225.     lf_info.wrote_create_file = 0;
  226.     lf_info.last_pos_in_file = HA_POS_ERROR;
  227.     lf_info.log_delayed= log_delayed;
  228.     read_info.set_io_cache_arg((void*) &lf_info);
  229.   }
  230. #endif /*!EMBEDDED_LIBRARY*/
  231.   restore_record(table,default_values);
  232.   thd->count_cuted_fields= CHECK_FIELD_WARN; /* calc cuted fields */
  233.   thd->cuted_fields=0L;
  234.   /* Skip lines if there is a line terminator */
  235.   if (ex->line_term->length())
  236.   {
  237.     /* ex->skip_lines needs to be preserved for logging */
  238.     while (skip_lines > 0)
  239.     {
  240.       skip_lines--;
  241.       if (read_info.next_line())
  242. break;
  243.     }
  244.   }
  245.   if (!(error=test(read_info.error)))
  246.   {
  247.     if (use_timestamp)
  248.       table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
  249.     table->next_number_field=table->found_next_number_field;
  250.     if (ignore ||
  251. handle_duplicates == DUP_REPLACE)
  252.       table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
  253.     table->file->start_bulk_insert((ha_rows) 0);
  254.     table->copy_blobs=1;
  255.     if (!field_term->length() && !enclosed->length())
  256.       error=read_fixed_length(thd,info,table,fields,read_info,
  257.       skip_lines);
  258.     else
  259.       error=read_sep_field(thd,info,table,fields,read_info,*enclosed,
  260.    skip_lines);
  261.     if (table->file->end_bulk_insert())
  262.       error=1; /* purecov: inspected */
  263.     table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
  264.     table->next_number_field=0;
  265.   }
  266.   ha_enable_transaction(thd, TRUE);
  267.   if (file >= 0)
  268.     my_close(file,MYF(0));
  269.   free_blobs(table); /* if pack_blob was used */
  270.   table->copy_blobs=0;
  271.   thd->count_cuted_fields= CHECK_FIELD_IGNORE;
  272.   /*
  273.     We must invalidate the table in query cache before binlog writing and
  274.     ha_autocommit_...
  275.   */
  276.   query_cache_invalidate3(thd, table_list, 0);
  277.   if (error)
  278.   {
  279.     if (transactional_table)
  280.       ha_autocommit_or_rollback(thd,error);
  281.     if (read_file_from_client)
  282.       while (!read_info.next_line())
  283. ;
  284. #ifndef EMBEDDED_LIBRARY
  285.     if (mysql_bin_log.is_open())
  286.     {
  287.       /*
  288.         Make sure last block (the one which caused the error) gets logged.
  289.         This is needed because otherwise after write of
  290.         (to the binlog, not to read_info (which is a cache))
  291.         Delete_file_log_event the bad block will remain in read_info (because
  292.         pre_read is not called at the end of the last block; remember pre_read
  293.         is called whenever a new block is read from disk).
  294.         At the end of mysql_load(), the destructor of read_info will call
  295.         end_io_cache() which will flush read_info, so we will finally have
  296.         this in the binlog:
  297.         Append_block # The last successfull block
  298.         Delete_file
  299.         Append_block # The failing block
  300.         which is nonsense.
  301.         Or could also be (for a small file)
  302.         Create_file  # The failing block
  303.         which is nonsense (Delete_file is not written in this case, because:
  304.         Create_file has not been written, so Delete_file is not written, then
  305.         when read_info is destroyed end_io_cache() is called which writes
  306.         Create_file.
  307.       */
  308.       read_info.end_io_cache();
  309.       /* If the file was not empty, wrote_create_file is true */
  310.       if (lf_info.wrote_create_file)
  311.       {
  312.         Delete_file_log_event d(thd, db, log_delayed);
  313.         mysql_bin_log.write(&d);
  314.       }
  315.     }
  316. #endif /*!EMBEDDED_LIBRARY*/
  317.     error= -1; // Error on read
  318.     goto err;
  319.   }
  320.   sprintf(name, ER(ER_LOAD_INFO), (ulong) info.records, (ulong) info.deleted,
  321.   (ulong) (info.records - info.copied), (ulong) thd->cuted_fields);
  322.   send_ok(thd,info.copied+info.deleted,0L,name);
  323.   // on the slave thd->query is never initialized
  324.   if (!thd->slave_thread)
  325.     mysql_update_log.write(thd,thd->query,thd->query_length);
  326.   if (!log_delayed)
  327.     thd->options|=OPTION_STATUS_NO_TRANS_UPDATE;
  328. #ifndef EMBEDDED_LIBRARY
  329.   if (mysql_bin_log.is_open())
  330.   {
  331.     /*
  332.       As already explained above, we need to call end_io_cache() or the last
  333.       block will be logged only after Execute_load_log_event (which is wrong),
  334.       when read_info is destroyed.
  335.     */
  336.     read_info.end_io_cache(); 
  337.     if (lf_info.wrote_create_file)
  338.     {
  339.       Execute_load_log_event e(thd, db, log_delayed);
  340.       mysql_bin_log.write(&e);
  341.     }
  342.   }
  343. #endif /*!EMBEDDED_LIBRARY*/
  344.   if (transactional_table)
  345.     error=ha_autocommit_or_rollback(thd,error); 
  346. err:
  347.   if (thd->lock)
  348.   {
  349.     mysql_unlock_tables(thd, thd->lock);
  350.     thd->lock=0;
  351.   }
  352.   DBUG_RETURN(error);
  353. }
  354. /****************************************************************************
  355. ** Read of rows of fixed size + optional garage + optonal newline
  356. ****************************************************************************/
  357. static int
  358. read_fixed_length(THD *thd,COPY_INFO &info,TABLE *table,List<Item> &fields,
  359.   READ_INFO &read_info, ulong skip_lines)
  360. {
  361.   List_iterator_fast<Item> it(fields);
  362.   Item_field *sql_field;
  363.   ulonglong id;
  364.   DBUG_ENTER("read_fixed_length");
  365.   id= 0;
  366.   
  367.   /* No fields can be null in this format. mark all fields as not null */
  368.   while ((sql_field= (Item_field*) it++))
  369.       sql_field->field->set_notnull();
  370.   while (!read_info.read_fixed_length())
  371.   {
  372.     if (thd->killed)
  373.     {
  374.       my_error(ER_SERVER_SHUTDOWN,MYF(0));
  375.       DBUG_RETURN(1);
  376.     }
  377.     if (skip_lines)
  378.     {
  379.       /*
  380. We could implement this with a simple seek if:
  381. - We are not using DATA INFILE LOCAL
  382. - escape character is  ""
  383. - line starting prefix is ""
  384.       */
  385.       skip_lines--;
  386.       continue;
  387.     }
  388.     it.rewind();
  389.     byte *pos=read_info.row_start;
  390. #ifdef HAVE_purify
  391.     read_info.row_end[0]=0;
  392. #endif
  393.     while ((sql_field= (Item_field*) it++))
  394.     {
  395.       Field *field= sql_field->field;                  
  396.       if (pos == read_info.row_end)
  397.       {
  398.         thd->cuted_fields++; /* Not enough fields */
  399.         push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
  400.                             ER_WARN_TOO_FEW_RECORDS, 
  401.                             ER(ER_WARN_TOO_FEW_RECORDS), thd->row_count);
  402.       field->reset();
  403.       }
  404.       else
  405.       {
  406. uint length;
  407. byte save_chr;
  408.         if (field == table->next_number_field)
  409.           table->auto_increment_field_not_null= TRUE;
  410. if ((length=(uint) (read_info.row_end-pos)) >
  411.     field->field_length)
  412.   length=field->field_length;
  413. save_chr=pos[length]; pos[length]=''; // Safeguard aganst malloc
  414.         field->store((char*) pos,length,read_info.read_charset);
  415. pos[length]=save_chr;
  416. if ((pos+=length) > read_info.row_end)
  417.   pos= read_info.row_end; /* Fills rest with space */
  418.       }
  419.     }
  420.     if (pos != read_info.row_end)
  421.     {
  422.       thd->cuted_fields++; /* To long row */
  423.       push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
  424.                           ER_WARN_TOO_MANY_RECORDS, 
  425.                           ER(ER_WARN_TOO_MANY_RECORDS), thd->row_count); 
  426.     }
  427.     if (write_record(table,&info))
  428.       DBUG_RETURN(1);
  429.     /*
  430.       If auto_increment values are used, save the first one
  431.        for LAST_INSERT_ID() and for the binary/update log.
  432.        We can't use insert_id() as we don't want to touch the
  433.        last_insert_id_used flag.
  434.     */
  435.     if (!id && thd->insert_id_used)
  436.       id= thd->last_insert_id;
  437.     if (table->next_number_field)
  438.       table->next_number_field->reset(); // Clear for next record
  439.     if (read_info.next_line()) // Skip to next line
  440.       break;
  441.     if (read_info.line_cuted)
  442.     {
  443.       thd->cuted_fields++; /* To long row */
  444.       push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
  445.                           ER_WARN_TOO_MANY_RECORDS, 
  446.                           ER(ER_WARN_TOO_MANY_RECORDS), thd->row_count); 
  447.     }
  448.     thd->row_count++;
  449.   }
  450.   if (id && !read_info.error)
  451.     thd->insert_id(id); // For binary/update log
  452.   DBUG_RETURN(test(read_info.error));
  453. }
  454. static int
  455. read_sep_field(THD *thd,COPY_INFO &info,TABLE *table,
  456.        List<Item> &fields, READ_INFO &read_info,
  457.        String &enclosed, ulong skip_lines)
  458. {
  459.   List_iterator_fast<Item> it(fields);
  460.   Item_field *sql_field;
  461.   uint enclosed_length;
  462.   ulonglong id;
  463.   DBUG_ENTER("read_sep_field");
  464.   enclosed_length=enclosed.length();
  465.   id= 0;
  466.   for (;;it.rewind())
  467.   {
  468.     if (thd->killed)
  469.     {
  470.       my_error(ER_SERVER_SHUTDOWN,MYF(0));
  471.       DBUG_RETURN(1);
  472.     }
  473.     while ((sql_field=(Item_field*) it++))
  474.     {
  475.       uint length;
  476.       byte *pos;
  477.       if (read_info.read_field())
  478. break;
  479.       pos=read_info.row_start;
  480.       length=(uint) (read_info.row_end-pos);
  481.       Field *field=sql_field->field;
  482.       if (!read_info.enclosed &&
  483.   (enclosed_length && length == 4 && !memcmp(pos,"NULL",4)) ||
  484.   (length == 1 && read_info.found_null))
  485.       {
  486. field->reset();
  487. field->set_null();
  488. if (!field->maybe_null())
  489. {
  490.   if (field->type() == FIELD_TYPE_TIMESTAMP)
  491.     ((Field_timestamp*) field)->set_time();
  492.   else if (field != table->next_number_field)      
  493.     field->set_warning((uint) MYSQL_ERROR::WARN_LEVEL_WARN, 
  494.        ER_WARN_NULL_TO_NOTNULL, 1);
  495. }
  496. continue;
  497.       }
  498.       if (field == table->next_number_field)
  499.         table->auto_increment_field_not_null= TRUE;
  500.       field->set_notnull();
  501.       read_info.row_end[0]=0; // Safe to change end marker
  502.       field->store((char*) read_info.row_start,length,read_info.read_charset);
  503.     }
  504.     if (read_info.error)
  505.       break;
  506.     if (skip_lines)
  507.     {
  508.       if (!--skip_lines)
  509. thd->cuted_fields= 0L; // Reset warnings
  510.       continue;
  511.     }
  512.     if (sql_field)
  513.     { // Last record
  514.       if (sql_field == (Item_field*) fields.head())
  515. break;
  516.       for (; sql_field ; sql_field=(Item_field*) it++)
  517.       {
  518. sql_field->field->set_null();
  519. sql_field->field->reset();
  520. thd->cuted_fields++;
  521.   push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
  522.                      ER_WARN_TOO_FEW_RECORDS,
  523.                      ER(ER_WARN_TOO_FEW_RECORDS), thd->row_count);
  524.       }
  525.     }
  526.     if (write_record(table,&info))
  527.       DBUG_RETURN(1);
  528.     /*
  529.       If auto_increment values are used, save the first one
  530.        for LAST_INSERT_ID() and for the binary/update log.
  531.        We can't use insert_id() as we don't want to touch the
  532.        last_insert_id_used flag.
  533.     */
  534.     if (!id && thd->insert_id_used)
  535.       id= thd->last_insert_id;
  536.     if (table->next_number_field)
  537.       table->next_number_field->reset(); // Clear for next record
  538.     if (read_info.next_line()) // Skip to next line
  539.       break;
  540.     if (read_info.line_cuted)
  541.     {
  542.       thd->cuted_fields++; /* To long row */
  543.       push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
  544.                           ER_WARN_TOO_MANY_RECORDS, ER(ER_WARN_TOO_MANY_RECORDS), 
  545.                           thd->row_count);   
  546.     }
  547.     thd->row_count++;
  548.   }
  549.   if (id && !read_info.error)
  550.     thd->insert_id(id); // For binary/update log
  551.   DBUG_RETURN(test(read_info.error));
  552. }
  553. /* Unescape all escape characters, mark N as null */
  554. char
  555. READ_INFO::unescape(char chr)
  556. {
  557.   switch(chr) {
  558.   case 'n': return 'n';
  559.   case 't': return 't';
  560.   case 'r': return 'r';
  561.   case 'b': return 'b';
  562.   case '0': return 0; // Ascii null
  563.   case 'Z': return '32'; // Win32 end of file
  564.   case 'N': found_null=1;
  565.     /* fall through */
  566.   default:  return chr;
  567.   }
  568. }
  569. /*
  570.   Read a line using buffering
  571.   If last line is empty (in line mode) then it isn't outputed
  572. */
  573. READ_INFO::READ_INFO(File file_par, uint tot_length, CHARSET_INFO *cs,
  574.      String &field_term, String &line_start, String &line_term,
  575.      String &enclosed_par, int escape, bool get_it_from_net,
  576.      bool is_fifo)
  577.   :file(file_par),escape_char(escape)
  578. {
  579.   read_charset= cs;
  580.   field_term_ptr=(char*) field_term.ptr();
  581.   field_term_length= field_term.length();
  582.   line_term_ptr=(char*) line_term.ptr();
  583.   line_term_length= line_term.length();
  584.   if (line_start.length() == 0)
  585.   {
  586.     line_start_ptr=0;
  587.     start_of_line= 0;
  588.   }
  589.   else
  590.   {
  591.     line_start_ptr=(char*) line_start.ptr();
  592.     line_start_end=line_start_ptr+line_start.length();
  593.     start_of_line= 1;
  594.   }
  595.   /* If field_terminator == line_terminator, don't use line_terminator */
  596.   if (field_term_length == line_term_length &&
  597.       !memcmp(field_term_ptr,line_term_ptr,field_term_length))
  598.   {
  599.     line_term_length=0;
  600.     line_term_ptr=(char*) "";
  601.   }
  602.   enclosed_char= (enclosed_length=enclosed_par.length()) ?
  603.     (uchar) enclosed_par[0] : INT_MAX;
  604.   field_term_char= field_term_length ? (uchar) field_term_ptr[0] : INT_MAX;
  605.   line_term_char= line_term_length ? (uchar) line_term_ptr[0] : INT_MAX;
  606.   error=eof=found_end_of_line=found_null=line_cuted=0;
  607.   buff_length=tot_length;
  608.   /* Set of a stack for unget if long terminators */
  609.   uint length=max(field_term_length,line_term_length)+1;
  610.   set_if_bigger(length,line_start.length());
  611.   stack=stack_pos=(int*) sql_alloc(sizeof(int)*length);
  612.   if (!(buffer=(byte*) my_malloc(buff_length+1,MYF(0))))
  613.     error=1; /* purecov: inspected */
  614.   else
  615.   {
  616.     end_of_buff=buffer+buff_length;
  617.     if (init_io_cache(&cache,(get_it_from_net) ? -1 : file, 0,
  618.       (get_it_from_net) ? READ_NET :
  619.       (is_fifo ? READ_FIFO : READ_CACHE),0L,1,
  620.       MYF(MY_WME)))
  621.     {
  622.       my_free((gptr) buffer,MYF(0)); /* purecov: inspected */
  623.       error=1;
  624.     }
  625.     else 
  626.     {
  627.       /*
  628. init_io_cache() will not initialize read_function member
  629. if the cache is READ_NET. The reason is explained in
  630. mysys/mf_iocache.c. So we work around the problem with a
  631. manual assignment
  632.       */
  633.       need_end_io_cache = 1;
  634. #ifndef EMBEDDED_LIBRARY
  635.       if (get_it_from_net)
  636. cache.read_function = _my_b_net_read;
  637.       if (mysql_bin_log.is_open())
  638. cache.pre_read = cache.pre_close =
  639.   (IO_CACHE_CALLBACK) log_loaded_block;
  640. #endif
  641.     }
  642.   }
  643. }
  644. READ_INFO::~READ_INFO()
  645. {
  646.   if (!error)
  647.   {
  648.     if (need_end_io_cache)
  649.       ::end_io_cache(&cache);
  650.     my_free((gptr) buffer,MYF(0));
  651.     error=1;
  652.   }
  653. }
  654. #define GET (stack_pos != stack ? *--stack_pos : my_b_get(&cache))
  655. #define PUSH(A) *(stack_pos++)=(A)
  656. inline int READ_INFO::terminator(char *ptr,uint length)
  657. {
  658.   int chr=0; // Keep gcc happy
  659.   uint i;
  660.   for (i=1 ; i < length ; i++)
  661.   {
  662.     if ((chr=GET) != *++ptr)
  663.     {
  664.       break;
  665.     }
  666.   }
  667.   if (i == length)
  668.     return 1;
  669.   PUSH(chr);
  670.   while (i-- > 1)
  671.     PUSH((uchar) *--ptr);
  672.   return 0;
  673. }
  674. int READ_INFO::read_field()
  675. {
  676.   int chr,found_enclosed_char;
  677.   byte *to,*new_buffer;
  678.   found_null=0;
  679.   if (found_end_of_line)
  680.     return 1; // One have to call next_line
  681.   /* Skip until we find 'line_start' */
  682.   if (start_of_line)
  683.   { // Skip until line_start
  684.     start_of_line=0;
  685.     if (find_start_of_fields())
  686.       return 1;
  687.   }
  688.   if ((chr=GET) == my_b_EOF)
  689.   {
  690.     found_end_of_line=eof=1;
  691.     return 1;
  692.   }
  693.   to=buffer;
  694.   if (chr == enclosed_char)
  695.   {
  696.     found_enclosed_char=enclosed_char;
  697.     *to++=(byte) chr; // If error
  698.   }
  699.   else
  700.   {
  701.     found_enclosed_char= INT_MAX;
  702.     PUSH(chr);
  703.   }
  704.   for (;;)
  705.   {
  706.     while ( to < end_of_buff)
  707.     {
  708.       chr = GET;
  709. #ifdef USE_MB
  710.       if ((my_mbcharlen(read_charset, chr) > 1) &&
  711.           to+my_mbcharlen(read_charset, chr) <= end_of_buff)
  712.       {
  713.   uchar* p = (uchar*)to;
  714.   *to++ = chr;
  715.   int ml = my_mbcharlen(read_charset, chr);
  716.   int i;
  717.   for (i=1; i<ml; i++) {
  718.       chr = GET;
  719.       if (chr == my_b_EOF)
  720.   goto found_eof;
  721.       *to++ = chr;
  722.   }
  723.   if (my_ismbchar(read_charset,
  724.                           (const char *)p,
  725.                           (const char *)to))
  726.     continue;
  727.   for (i=0; i<ml; i++)
  728.     PUSH((uchar) *--to);
  729.   chr = GET;
  730.       }
  731. #endif
  732.       if (chr == my_b_EOF)
  733. goto found_eof;
  734.       if (chr == escape_char)
  735.       {
  736. if ((chr=GET) == my_b_EOF)
  737. {
  738.   *to++= (byte) escape_char;
  739.   goto found_eof;
  740. }
  741.         /*
  742.           When escape_char == enclosed_char, we treat it like we do for
  743.           handling quotes in SQL parsing -- you can double-up the
  744.           escape_char to include it literally, but it doesn't do escapes
  745.           like n. This allows: LOAD DATA ... ENCLOSED BY '"' ESCAPED BY '"'
  746.           with data like: "fie""ld1", "field2"
  747.          */
  748.         if (escape_char != enclosed_char || chr == escape_char)
  749.         {
  750.           *to++ = (byte) unescape((char) chr);
  751.           continue;
  752.         }
  753.         PUSH(chr);
  754.         chr= escape_char;
  755.       }
  756. #ifdef ALLOW_LINESEPARATOR_IN_STRINGS
  757.       if (chr == line_term_char)
  758. #else
  759.       if (chr == line_term_char && found_enclosed_char == INT_MAX)
  760. #endif
  761.       {
  762. if (terminator(line_term_ptr,line_term_length))
  763. { // Maybe unexpected linefeed
  764.   enclosed=0;
  765.   found_end_of_line=1;
  766.   row_start=buffer;
  767.   row_end=  to;
  768.   return 0;
  769. }
  770.       }
  771.       if (chr == found_enclosed_char)
  772.       {
  773. if ((chr=GET) == found_enclosed_char)
  774. { // Remove dupplicated
  775.   *to++ = (byte) chr;
  776.   continue;
  777. }
  778. // End of enclosed field if followed by field_term or line_term
  779. if (chr == my_b_EOF ||
  780.     chr == line_term_char && terminator(line_term_ptr,
  781. line_term_length))
  782. { // Maybe unexpected linefeed
  783.   enclosed=1;
  784.   found_end_of_line=1;
  785.   row_start=buffer+1;
  786.   row_end=  to;
  787.   return 0;
  788. }
  789. if (chr == field_term_char &&
  790.     terminator(field_term_ptr,field_term_length))
  791. {
  792.   enclosed=1;
  793.   row_start=buffer+1;
  794.   row_end=  to;
  795.   return 0;
  796. }
  797. /*
  798.   The string didn't terminate yet.
  799.   Store back next character for the loop
  800. */
  801. PUSH(chr);
  802. /* copy the found term character to 'to' */
  803. chr= found_enclosed_char;
  804.       }
  805.       else if (chr == field_term_char && found_enclosed_char == INT_MAX)
  806.       {
  807. if (terminator(field_term_ptr,field_term_length))
  808. {
  809.   enclosed=0;
  810.   row_start=buffer;
  811.   row_end=  to;
  812.   return 0;
  813. }
  814.       }
  815.       *to++ = (byte) chr;
  816.     }
  817.     /*
  818.     ** We come here if buffer is too small. Enlarge it and continue
  819.     */
  820.     if (!(new_buffer=(byte*) my_realloc((char*) buffer,buff_length+1+IO_SIZE,
  821. MYF(MY_WME))))
  822.       return (error=1);
  823.     to=new_buffer + (to-buffer);
  824.     buffer=new_buffer;
  825.     buff_length+=IO_SIZE;
  826.     end_of_buff=buffer+buff_length;
  827.   }
  828. found_eof:
  829.   enclosed=0;
  830.   found_end_of_line=eof=1;
  831.   row_start=buffer;
  832.   row_end=to;
  833.   return 0;
  834. }
  835. /*
  836.   Read a row with fixed length.
  837.   NOTES
  838.     The row may not be fixed size on disk if there are escape
  839.     characters in the file.
  840.   IMPLEMENTATION NOTE
  841.     One can't use fixed length with multi-byte charset **
  842.   RETURN
  843.     0  ok
  844.     1  error
  845. */
  846. int READ_INFO::read_fixed_length()
  847. {
  848.   int chr;
  849.   byte *to;
  850.   if (found_end_of_line)
  851.     return 1; // One have to call next_line
  852.   if (start_of_line)
  853.   { // Skip until line_start
  854.     start_of_line=0;
  855.     if (find_start_of_fields())
  856.       return 1;
  857.   }
  858.   to=row_start=buffer;
  859.   while (to < end_of_buff)
  860.   {
  861.     if ((chr=GET) == my_b_EOF)
  862.       goto found_eof;
  863.     if (chr == escape_char)
  864.     {
  865.       if ((chr=GET) == my_b_EOF)
  866.       {
  867. *to++= (byte) escape_char;
  868. goto found_eof;
  869.       }
  870.       *to++ =(byte) unescape((char) chr);
  871.       continue;
  872.     }
  873.     if (chr == line_term_char)
  874.     {
  875.       if (terminator(line_term_ptr,line_term_length))
  876.       { // Maybe unexpected linefeed
  877. found_end_of_line=1;
  878. row_end=  to;
  879. return 0;
  880.       }
  881.     }
  882.     *to++ = (byte) chr;
  883.   }
  884.   row_end=to; // Found full line
  885.   return 0;
  886. found_eof:
  887.   found_end_of_line=eof=1;
  888.   row_start=buffer;
  889.   row_end=to;
  890.   return to == buffer ? 1 : 0;
  891. }
  892. int READ_INFO::next_line()
  893. {
  894.   line_cuted=0;
  895.   start_of_line= line_start_ptr != 0;
  896.   if (found_end_of_line || eof)
  897.   {
  898.     found_end_of_line=0;
  899.     return eof;
  900.   }
  901.   found_end_of_line=0;
  902.   if (!line_term_length)
  903.     return 0; // No lines
  904.   for (;;)
  905.   {
  906.     int chr = GET;
  907. #ifdef USE_MB
  908.    if (my_mbcharlen(read_charset, chr) > 1)
  909.    {
  910.        for (int i=1;
  911.             chr != my_b_EOF && i<my_mbcharlen(read_charset, chr);
  912.             i++)
  913.    chr = GET;
  914.        if (chr == escape_char)
  915.    continue;
  916.    }
  917. #endif
  918.    if (chr == my_b_EOF)
  919.    {
  920.       eof=1;
  921.       return 1;
  922.     }
  923.     if (chr == escape_char)
  924.     {
  925.       line_cuted=1;
  926.       if (GET == my_b_EOF)
  927. return 1;
  928.       continue;
  929.     }
  930.     if (chr == line_term_char && terminator(line_term_ptr,line_term_length))
  931.       return 0;
  932.     line_cuted=1;
  933.   }
  934. }
  935. bool READ_INFO::find_start_of_fields()
  936. {
  937.   int chr;
  938.  try_again:
  939.   do
  940.   {
  941.     if ((chr=GET) == my_b_EOF)
  942.     {
  943.       found_end_of_line=eof=1;
  944.       return 1;
  945.     }
  946.   } while ((char) chr != line_start_ptr[0]);
  947.   for (char *ptr=line_start_ptr+1 ; ptr != line_start_end ; ptr++)
  948.   {
  949.     chr=GET; // Eof will be checked later
  950.     if ((char) chr != *ptr)
  951.     { // Can't be line_start
  952.       PUSH(chr);
  953.       while (--ptr != line_start_ptr)
  954.       { // Restart with next char
  955. PUSH((uchar) *ptr);
  956.       }
  957.       goto try_again;
  958.     }
  959.   }
  960.   return 0;
  961. }