← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_load.cc

  • Committer: Monty Taylor
  • Date: 2010-11-08 18:26:08 UTC
  • mto: This revision was merged to the branch mainline in revision 1931.
  • Revision ID: mordred@inaugust.com-20101108182608-lci86acl7r53sbi3
Replaced auto_ptr with scoped_ptr.

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>
20
 
 
 
19
#include "config.h"
21
20
#include <drizzled/sql_load.h>
22
21
#include <drizzled/error.h>
23
22
#include <drizzled/data_home.h>
24
23
#include <drizzled/session.h>
25
24
#include <drizzled/sql_base.h>
26
 
#include <drizzled/field/epoch.h>
27
 
#include <drizzled/internal/my_sys.h>
28
 
#include <drizzled/internal/iocache.h>
29
 
#include <drizzled/plugin/storage_engine.h>
 
25
#include <drizzled/field/timestamp.h>
 
26
#include "drizzled/internal/my_sys.h"
 
27
#include "drizzled/internal/iocache.h"
 
28
#include <drizzled/db.h>
30
29
 
31
30
#include <sys/stat.h>
32
31
#include <fcntl.h>
82
81
 
83
82
  /*
84
83
    Either this method, or we need to make cache public
85
 
    Arg must be set from load() since constructor does not see
 
84
    Arg must be set from mysql_load() since constructor does not see
86
85
    either the table or Session value
87
86
  */
88
87
  void set_io_cache_arg(void* arg) { cache.arg = arg; }
104
103
  Execute LOAD DATA query
105
104
 
106
105
  SYNOPSYS
107
 
    load()
 
106
    mysql_load()
108
107
      session - current thread
109
108
      ex  - file_exchange object representing source cursor and its parsing rules
110
109
      table_list  - list of tables to which we are loading data
120
119
    true - error / false - success
121
120
*/
122
121
 
123
 
int load(Session *session,file_exchange *ex,TableList *table_list,
 
122
int mysql_load(Session *session,file_exchange *ex,TableList *table_list,
124
123
                List<Item> &fields_vars, List<Item> &set_fields,
125
124
                List<Item> &set_values,
126
125
                enum enum_duplicates handle_duplicates, bool ignore)
139
138
    If this is not set, we will use the directory where the table to be
140
139
    loaded is located
141
140
  */
142
 
  util::string::const_shared_ptr schema(session->schema());
143
 
  const char *tdb= (schema and not schema->empty()) ? schema->c_str() : table_list->getSchemaName(); // Result should never be null
 
141
  const char *tdb= session->db.empty() ? table_list->getSchemaName()  : session->db.c_str();            // Result is never null
144
142
  assert(tdb);
145
143
  uint32_t skip_lines= ex->skip_lines;
146
144
  bool transactional_table;
156
154
  if (session->openTablesLock(table_list))
157
155
    return(true);
158
156
 
159
 
  if (setup_tables_and_check_access(session, &session->getLex()->select_lex.context,
160
 
                                    &session->getLex()->select_lex.top_join_list,
 
157
  if (setup_tables_and_check_access(session, &session->lex->select_lex.context,
 
158
                                    &session->lex->select_lex.top_join_list,
161
159
                                    table_list,
162
 
                                    &session->getLex()->select_lex.leaf_tables, true))
 
160
                                    &session->lex->select_lex.leaf_tables, true))
163
161
     return(-1);
164
162
 
165
163
  /*
207
205
    */
208
206
    if (table->timestamp_field)
209
207
    {
210
 
      if (table->isWriteSet(table->timestamp_field->position()))
211
 
      {
 
208
      if (table->isWriteSet(table->timestamp_field->field_index))
212
209
        table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
213
 
      }
214
210
      else
215
211
      {
216
 
        table->setWriteSet(table->timestamp_field->position());
 
212
        table->setWriteSet(table->timestamp_field->field_index);
217
213
      }
218
214
    }
219
215
    /* Fix the expressions in SET clause */
225
221
 
226
222
  size_t tot_length=0;
227
223
  bool use_blobs= 0, use_vars= 0;
228
 
  List<Item>::iterator it(fields_vars.begin());
 
224
  List_iterator_fast<Item> it(fields_vars);
229
225
  Item *item;
230
226
 
231
227
  while ((item= it++))
320
316
  info.handle_duplicates=handle_duplicates;
321
317
  info.escape_char=escaped->length() ? (*escaped)[0] : INT_MAX;
322
318
 
323
 
  identifier::Schema identifier(*schema);
 
319
  SchemaIdentifier identifier(session->db);
324
320
  READ_INFO read_info(file, tot_length,
325
321
                      ex->cs ? ex->cs : plugin::StorageEngine::getSchemaCollation(identifier),
326
322
                      *field_term, *ex->line_start, *ex->line_term, *enclosed,
366
362
    table->cursor->ha_start_bulk_insert((ha_rows) 0);
367
363
    table->copy_blobs=1;
368
364
 
369
 
    session->setAbortOnWarning(true);
 
365
    session->abort_on_warning= true;
370
366
 
371
367
    if (!field_term->length() && !enclosed->length())
372
368
      error= read_fixed_length(session, info, table_list, fields_vars,
415
411
              session->transaction.stmt.hasModifiedNonTransData());
416
412
  table->cursor->ha_release_auto_increment();
417
413
  table->auto_increment_field_not_null= false;
418
 
  session->setAbortOnWarning(false);
419
 
 
 
414
  session->abort_on_warning= 0;
420
415
  return(error);
421
416
}
422
417
 
431
426
                  List<Item> &set_values, READ_INFO &read_info,
432
427
                  uint32_t skip_lines, bool ignore_check_option_errors)
433
428
{
434
 
  List<Item>::iterator it(fields_vars.begin());
 
429
  List_iterator_fast<Item> it(fields_vars);
435
430
  Item_field *sql_field;
436
431
  Table *table= table_list->table;
437
432
  uint64_t id;
457
452
      skip_lines--;
458
453
      continue;
459
454
    }
460
 
    it= fields_vars.begin();
 
455
    it.rewind();
461
456
    unsigned char *pos=read_info.row_start;
462
457
#ifdef HAVE_VALGRIND
463
458
    read_info.row_end[0]=0;
486
481
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
487
482
                            ER_WARN_TOO_FEW_RECORDS,
488
483
                            ER(ER_WARN_TOO_FEW_RECORDS), session->row_count);
489
 
 
490
 
        if (not field->maybe_null() and field->is_timestamp())
491
 
            ((field::Epoch::pointer) field)->set_time();
 
484
        if (!field->maybe_null() && field->type() == DRIZZLE_TYPE_TIMESTAMP)
 
485
            ((Field_timestamp*) field)->set_time();
492
486
      }
493
487
      else
494
488
      {
552
546
               String &enclosed, uint32_t skip_lines,
553
547
               bool ignore_check_option_errors)
554
548
{
555
 
  List<Item>::iterator it(fields_vars.begin());
 
549
  List_iterator_fast<Item> it(fields_vars);
556
550
  Item *item;
557
551
  Table *table= table_list->table;
558
552
  uint32_t enclosed_length;
562
556
  enclosed_length=enclosed.length();
563
557
  id= 0;
564
558
 
565
 
  for (;;it= fields_vars.begin())
 
559
  for (;;it.rewind())
566
560
  {
567
561
    if (session->getKilled())
568
562
    {
604
598
            return(1);
605
599
          }
606
600
          field->set_null();
607
 
          if (not field->maybe_null())
 
601
          if (!field->maybe_null())
608
602
          {
609
 
            if (field->is_timestamp())
610
 
            {
611
 
              ((field::Epoch::pointer) field)->set_time();
612
 
            }
 
603
            if (field->type() == DRIZZLE_TYPE_TIMESTAMP)
 
604
              ((Field_timestamp*) field)->set_time();
613
605
            else if (field != table->next_number_field)
614
 
            {
615
 
              field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_NULL_TO_NOTNULL, 1);
616
 
            }
 
606
              field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
607
                                 ER_WARN_NULL_TO_NOTNULL, 1);
617
608
          }
618
609
        }
619
610
        else if (item->type() == Item::STRING_ITEM)
674
665
                     session->row_count);
675
666
            return(1);
676
667
          }
677
 
          if (not field->maybe_null() and field->is_timestamp())
678
 
              ((field::Epoch::pointer) field)->set_time();
 
668
          if (!field->maybe_null() && field->type() == DRIZZLE_TYPE_TIMESTAMP)
 
669
              ((Field_timestamp*) field)->set_time();
679
670
          /*
680
671
            QQ: We probably should not throw warning for each field.
681
672
            But how about intention to always have the same number