← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/cursor.cc

  • Committer: Mark Atwood
  • Date: 2011-08-01 05:22:14 UTC
  • mfrom: (1919.3.53 drizzle_pbms)
  • Revision ID: me@mark.atwood.name-20110801052214-3wdsx3xgld6b5v4f
merge lp:~barry-leslie/drizzle/drizzle_pbms

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/cursor.cc
83
83
Cursor *Cursor::clone(memory::Root *mem_root)
84
84
{
85
85
  Cursor *new_handler= getTable()->getMutableShare()->db_type()->getCursor(*getTable());
 
86
 
86
87
  /*
87
88
    Allocate Cursor->ref here because otherwise ha_open will allocate it
88
89
    on this->table->mem_root and we will not be able to reclaim that memory
89
90
    when the clone Cursor object is destroyed.
90
91
  */
91
92
  new_handler->ref= mem_root->alloc(ALIGN_SIZE(ref_length)*2);
92
 
  identifier::Table identifier(getTable()->getShare()->getSchemaName(), getTable()->getShare()->getTableName(), getTable()->getShare()->getType());
93
 
  return new_handler->ha_open(identifier, getTable()->getDBStat(), HA_OPEN_IGNORE_IF_LOCKED) ? NULL : new_handler;
 
93
 
 
94
  identifier::Table identifier(getTable()->getShare()->getSchemaName(),
 
95
                             getTable()->getShare()->getTableName(),
 
96
                             getTable()->getShare()->getType());
 
97
 
 
98
  if (new_handler && !new_handler->ha_open(identifier,
 
99
                                           getTable()->getDBStat(),
 
100
                                           HA_OPEN_IGNORE_IF_LOCKED))
 
101
    return new_handler;
 
102
  return NULL;
94
103
}
95
104
 
96
105
/*
589
598
  next_insert_id= 0;
590
599
}
591
600
 
592
 
void Cursor::drop_table()
 
601
void Cursor::drop_table(const char *)
593
602
{
594
603
  close();
595
604
}
596
605
 
597
 
int Cursor::ha_check(Session*)
 
606
 
 
607
/**
 
608
  Performs checks upon the table.
 
609
 
 
610
  @param session                thread doing CHECK Table operation
 
611
 
 
612
  @retval
 
613
    HA_ADMIN_OK               Successful upgrade
 
614
  @retval
 
615
    HA_ADMIN_NEEDS_UPGRADE    Table has structures requiring upgrade
 
616
  @retval
 
617
    HA_ADMIN_NEEDS_ALTER      Table has structures requiring ALTER Table
 
618
  @retval
 
619
    HA_ADMIN_NOT_IMPLEMENTED
 
620
*/
 
621
int Cursor::ha_check(Session *)
598
622
{
599
623
  return HA_ADMIN_OK;
600
624
}
728
752
  @sa Cursor::discard_or_import_tablespace()
729
753
*/
730
754
 
731
 
int Cursor::ha_discard_or_import_tablespace(bool discard)
 
755
int
 
756
Cursor::ha_discard_or_import_tablespace(bool discard)
732
757
{
733
758
  setTransactionReadWrite();
 
759
 
734
760
  return discard_or_import_tablespace(discard);
735
761
}
736
762
 
740
766
  @sa Cursor::drop_table()
741
767
*/
742
768
 
743
 
void Cursor::closeMarkForDelete()
 
769
void
 
770
Cursor::closeMarkForDelete(const char *name)
744
771
{
745
772
  setTransactionReadWrite();
746
 
  return drop_table();
 
773
 
 
774
  return drop_table(name);
747
775
}
748
776
 
749
777
int Cursor::index_next_same(unsigned char *buf, const unsigned char *key, uint32_t keylen)
750
778
{
751
 
  int error= index_next(buf);
752
 
  if (error)
753
 
    return error;
754
 
 
755
 
  ptrdiff_t ptrdiff= buf - getTable()->getInsertRecord();
756
 
  unsigned char *save_record_0= NULL;
757
 
  KeyInfo *key_info= NULL;
758
 
  KeyPartInfo *key_part;
759
 
  KeyPartInfo *key_part_end= NULL;
760
 
 
761
 
  /*
762
 
  key_cmp_if_same() compares table->getInsertRecord() against 'key'.
763
 
  In parts it uses table->getInsertRecord() directly, in parts it uses
764
 
  field objects with their local pointers into table->getInsertRecord().
765
 
  If 'buf' is distinct from table->getInsertRecord(), we need to move
766
 
  all record references. This is table->getInsertRecord() itself and
767
 
  the field pointers of the fields used in this key.
768
 
  */
769
 
  if (ptrdiff)
770
 
  {
771
 
    save_record_0= getTable()->getInsertRecord();
772
 
    getTable()->record[0]= buf;
773
 
    key_info= getTable()->key_info + active_index;
774
 
    key_part= key_info->key_part;
775
 
    key_part_end= key_part + key_info->key_parts;
776
 
    for (; key_part < key_part_end; key_part++)
777
 
    {
778
 
      assert(key_part->field);
779
 
      key_part->field->move_field_offset(ptrdiff);
780
 
    }
781
 
  }
782
 
 
783
 
  if (key_cmp_if_same(getTable(), key, active_index, keylen))
784
 
  {
785
 
    getTable()->status=STATUS_NOT_FOUND;
786
 
    error= HA_ERR_END_OF_FILE;
787
 
  }
788
 
 
789
 
  /* Move back if necessary. */
790
 
  if (ptrdiff)
791
 
  {
792
 
    getTable()->record[0]= save_record_0;
793
 
    for (key_part= key_info->key_part; key_part < key_part_end; key_part++)
794
 
      key_part->field->move_field_offset(-ptrdiff);
 
779
  int error;
 
780
  if (!(error=index_next(buf)))
 
781
  {
 
782
    ptrdiff_t ptrdiff= buf - getTable()->getInsertRecord();
 
783
    unsigned char *save_record_0= NULL;
 
784
    KeyInfo *key_info= NULL;
 
785
    KeyPartInfo *key_part;
 
786
    KeyPartInfo *key_part_end= NULL;
 
787
 
 
788
    /*
 
789
      key_cmp_if_same() compares table->getInsertRecord() against 'key'.
 
790
      In parts it uses table->getInsertRecord() directly, in parts it uses
 
791
      field objects with their local pointers into table->getInsertRecord().
 
792
      If 'buf' is distinct from table->getInsertRecord(), we need to move
 
793
      all record references. This is table->getInsertRecord() itself and
 
794
      the field pointers of the fields used in this key.
 
795
    */
 
796
    if (ptrdiff)
 
797
    {
 
798
      save_record_0= getTable()->getInsertRecord();
 
799
      getTable()->record[0]= buf;
 
800
      key_info= getTable()->key_info + active_index;
 
801
      key_part= key_info->key_part;
 
802
      key_part_end= key_part + key_info->key_parts;
 
803
      for (; key_part < key_part_end; key_part++)
 
804
      {
 
805
        assert(key_part->field);
 
806
        key_part->field->move_field_offset(ptrdiff);
 
807
      }
 
808
    }
 
809
 
 
810
    if (key_cmp_if_same(getTable(), key, active_index, keylen))
 
811
    {
 
812
      getTable()->status=STATUS_NOT_FOUND;
 
813
      error=HA_ERR_END_OF_FILE;
 
814
    }
 
815
 
 
816
    /* Move back if necessary. */
 
817
    if (ptrdiff)
 
818
    {
 
819
      getTable()->record[0]= save_record_0;
 
820
      for (key_part= key_info->key_part; key_part < key_part_end; key_part++)
 
821
        key_part->field->move_field_offset(-ptrdiff);
 
822
    }
795
823
  }
796
824
  return error;
797
825
}