← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_load.cc

  • Committer: Brian Aker
  • Date: 2009-12-03 01:17:53 UTC
  • mto: (1237.3.2 push)
  • mto: This revision was merged to the branch mainline in revision 1238.
  • Revision ID: brian@gaz-20091203011753-159h2no5m5c5dt9b
Small cleanups, did in MERGE table only engine flag.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_load.cc
16
16
 
17
17
/* Copy data from a textfile to table */
18
18
 
19
 
#include "config.h"
 
19
#include <drizzled/server_includes.h>
20
20
#include <drizzled/sql_load.h>
21
21
#include <drizzled/error.h>
22
22
#include <drizzled/data_home.h>
23
23
#include <drizzled/session.h>
24
24
#include <drizzled/sql_base.h>
25
25
#include <drizzled/field/timestamp.h>
26
 
#include "drizzled/internal/my_sys.h"
27
 
#include "drizzled/internal/iocache.h"
28
 
#include <drizzled/db.h>
29
26
 
30
 
#include <sys/stat.h>
31
 
#include <fcntl.h>
32
27
#include <algorithm>
33
 
#include <climits>
34
28
 
35
29
using namespace std;
36
 
namespace drizzled
37
 
{
38
30
 
39
31
class READ_INFO {
40
 
  int   cursor;
 
32
  File  cursor;
41
33
  unsigned char *buffer;                /* Buffer for read text */
42
34
  unsigned char *end_of_buff;           /* Data in bufferts ends here */
43
35
  size_t buff_length;                   /* Length of buffert */
48
40
  int   *stack,*stack_pos;
49
41
  bool  found_end_of_line,start_of_line,eof;
50
42
  bool  need_end_io_cache;
51
 
  internal::IO_CACHE cache;
 
43
  IO_CACHE cache;
52
44
 
53
45
public:
54
46
  bool error,line_cuted,found_null,enclosed;
56
48
        *row_end;                       /* Found row ends here */
57
49
  const CHARSET_INFO *read_charset;
58
50
 
59
 
  READ_INFO(int cursor, size_t tot_length, const CHARSET_INFO * const cs,
 
51
  READ_INFO(File cursor, size_t tot_length, const CHARSET_INFO * const cs,
60
52
            String &field_term,String &line_start,String &line_term,
61
53
            String &enclosed,int escape, bool is_fifo);
62
54
  ~READ_INFO();
73
65
  */
74
66
  void end_io_cache()
75
67
  {
76
 
    internal::end_io_cache(&cache);
 
68
    ::end_io_cache(&cache);
77
69
    need_end_io_cache = 0;
78
70
  }
79
71
 
123
115
                enum enum_duplicates handle_duplicates, bool ignore)
124
116
{
125
117
  char name[FN_REFLEN];
126
 
  int file;
 
118
  File file;
127
119
  Table *table= NULL;
128
120
  int error;
129
121
  String *field_term=ex->field_term,*escaped=ex->escaped;
256
248
#ifdef DONT_ALLOW_FULL_LOAD_DATA_PATHS
257
249
    ex->file_name+=dirname_length(ex->file_name);
258
250
#endif
259
 
    if (!internal::dirname_length(ex->file_name))
 
251
    if (!dirname_length(ex->file_name))
260
252
    {
261
253
      strcpy(name, drizzle_real_data_home);
262
254
      strncat(name, tdb, FN_REFLEN-strlen(drizzle_real_data_home)-1);
263
 
      (void) internal::fn_format(name, ex->file_name, name, "",
 
255
      (void) fn_format(name, ex->file_name, name, "",
264
256
                       MY_RELATIVE_PATH | MY_UNPACK_FILENAME);
265
257
    }
266
258
    else
267
259
    {
268
 
      (void) internal::fn_format(name, ex->file_name, drizzle_real_data_home, "",
 
260
      (void) fn_format(name, ex->file_name, drizzle_real_data_home, "",
269
261
                       MY_RELATIVE_PATH | MY_UNPACK_FILENAME);
270
262
 
271
263
      if (opt_secure_file_priv &&
295
287
      if ((stat_info.st_mode & S_IFIFO) == S_IFIFO)
296
288
        is_fifo = 1;
297
289
    }
298
 
    if ((file=internal::my_open(name,O_RDONLY,MYF(MY_WME))) < 0)
 
290
    if ((file=my_open(name,O_RDONLY,MYF(MY_WME))) < 0)
299
291
    {
300
 
      my_error(ER_CANT_OPEN_FILE, MYF(0), name, errno);
 
292
      my_error(ER_CANT_OPEN_FILE, MYF(0), name, my_errno);
301
293
      return(true);
302
294
    }
303
295
  }
308
300
  info.handle_duplicates=handle_duplicates;
309
301
  info.escape_char=escaped->length() ? (*escaped)[0] : INT_MAX;
310
302
 
311
 
  SchemaIdentifier identifier(session->db);
312
303
  READ_INFO read_info(file, tot_length,
313
 
                      ex->cs ? ex->cs : plugin::StorageEngine::getSchemaCollation(identifier),
314
 
                      *field_term, *ex->line_start, *ex->line_term, *enclosed,
 
304
                      ex->cs ? ex->cs : get_default_db_collation(session->db.c_str()),
 
305
                      *field_term,*ex->line_start, *ex->line_term, *enclosed,
315
306
                      info.escape_char, is_fifo);
316
307
  if (read_info.error)
317
308
  {
318
309
    if  (file >= 0)
319
 
      internal::my_close(file,MYF(0));                  // no files in net reading
 
310
      my_close(file,MYF(0));                    // no files in net reading
320
311
    return(true);                               // Can't allocate buffers
321
312
  }
322
313
 
366
357
                            *enclosed, skip_lines, ignore);
367
358
    if (table->cursor->ha_end_bulk_insert() && !error)
368
359
    {
369
 
      table->print_error(errno, MYF(0));
 
360
      table->print_error(my_errno, MYF(0));
370
361
      error= 1;
371
362
    }
372
363
    table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
374
365
    table->next_number_field=0;
375
366
  }
376
367
  if (file >= 0)
377
 
    internal::my_close(file,MYF(0));
 
368
    my_close(file,MYF(0));
378
369
  free_blobs(table);                            /* if pack_blob was used */
379
370
  table->copy_blobs=0;
380
371
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
388
379
    error= -1;                          // Error on read
389
380
    goto err;
390
381
  }
391
 
  snprintf(name, sizeof(name), ER(ER_LOAD_INFO), (uint32_t) info.records, (uint32_t) info.deleted,
 
382
  sprintf(name, ER(ER_LOAD_INFO), (uint32_t) info.records, (uint32_t) info.deleted,
392
383
          (uint32_t) (info.records - info.copied), (uint32_t) session->cuted_fields);
393
384
 
394
 
  if (session->transaction.stmt.hasModifiedNonTransData())
395
 
    session->transaction.all.markModifiedNonTransData();
 
385
  if (session->transaction.stmt.modified_non_trans_table)
 
386
    session->transaction.all.modified_non_trans_table= true;
396
387
 
397
388
  /* ok to client sent only after binlog write and engine commit */
398
389
  session->my_ok(info.copied + info.deleted, 0, 0L, name);
399
390
err:
400
391
  assert(transactional_table || !(info.copied || info.deleted) ||
401
 
              session->transaction.stmt.hasModifiedNonTransData());
 
392
              session->transaction.stmt.modified_non_trans_table);
402
393
  table->cursor->ha_release_auto_increment();
403
394
  table->auto_increment_field_not_null= false;
404
395
  session->abort_on_warning= 0;
738
729
*/
739
730
 
740
731
 
741
 
READ_INFO::READ_INFO(int file_par, size_t tot_length,
 
732
READ_INFO::READ_INFO(File file_par, size_t tot_length,
742
733
                     const CHARSET_INFO * const cs,
743
734
                     String &field_term, String &line_start, String &line_term,
744
735
                     String &enclosed_par, int escape, bool is_fifo)
778
769
  /* Set of a stack for unget if long terminators */
779
770
  uint32_t length= max(field_term_length,line_term_length)+1;
780
771
  set_if_bigger(length,line_start.length());
781
 
  stack= stack_pos= (int*) memory::sql_alloc(sizeof(int)*length);
 
772
  stack= stack_pos= (int*) sql_alloc(sizeof(int)*length);
782
773
 
783
774
  if (!(buffer=(unsigned char*) calloc(1, buff_length+1)))
784
775
    error=1;
786
777
  {
787
778
    end_of_buff=buffer+buff_length;
788
779
    if (init_io_cache(&cache,(false) ? -1 : cursor, 0,
789
 
                      (false) ? internal::READ_NET :
790
 
                      (is_fifo ? internal::READ_FIFO : internal::READ_CACHE),0L,1,
 
780
                      (false) ? READ_NET :
 
781
                      (is_fifo ? READ_FIFO : READ_CACHE),0L,1,
791
782
                      MYF(MY_WME)))
792
783
    {
793
784
      free((unsigned char*) buffer);
811
802
  if (!error)
812
803
  {
813
804
    if (need_end_io_cache)
814
 
      internal::end_io_cache(&cache);
 
805
      ::end_io_cache(&cache);
815
806
    free(buffer);
816
807
    error=1;
817
808
  }
1143
1134
}
1144
1135
 
1145
1136
 
1146
 
} /* namespace drizzled */