3#include <drizzled/field/varstring.h>
4#include <drizzled/key_part_info.h>
5#include <drizzled/table.h>
6#include <drizzled/thr_lock.h>
8#include "wiredtiger_drizzle.h"
9#include "wt_to_drizzle_error.h"
15#define TO_STR(s) _TO_STR(s)
16#define SOURCE_LOCATION "in " __FILE__ ":" TO_STR(__LINE__)
21#include <boost/thread/mutex.hpp>
22static boost::mutex wt_share_mutex;
28WiredTigerCursor::WiredTigerCursor(plugin::StorageEngine &engine_arg,
30 :
Cursor(engine_arg, table_arg), records_changed(0), key_stat_version(0),
31 internal_table(0), wt_session(NULL), wt_cursor(NULL), key_fields(NULL),
32 index_key_fields(NULL), index_value_fields(NULL), table_uri()
47#define MEMORY_STATS_UPDATE_THRESHOLD 10
49int WiredTigerCursor::open_table_cursor()
51 if (wt_cursor == NULL)
54 wt_session= get_wt_session(*getTable()->getSession());
55 ret = wt_session->open_cursor(wt_session, table_uri.c_str(),
56 NULL,
"append,raw", &wt_cursor);
58 return wt_to_drizzle_error(ret);
64void WiredTigerCursor::reopen_cursor_if_needed()
67 && wt_cursor->session != get_wt_session(*getTable()->getSession()))
69 string uri(wt_cursor->uri);
70 if (wt_cursor != NULL)
71 wt_cursor->close(wt_cursor);
72 wt_session= get_wt_session(*getTable()->getSession());
73 int ret = wt_session->open_cursor(wt_session, uri.c_str(),
74 NULL,
"append,raw", &wt_cursor);
79int WiredTigerCursor::setupTableURI(
82 table_uri.assign(
"table:");
83 table_uri.append(identifier.getPath());
89 for (uint32_t k= 0; k < table.getShare()->keys; k++)
91 if (table.key_info[k].flags & HA_NOSAME)
100int WiredTigerCursor::setupKeyFields(uint32_t keynr,
bool recreate)
102 const drizzled::KeyInfo *key_info= getTable()->key_info + keynr;
104 if (key_fields != NULL) {
117 key_fields =
new std::vector<int32_t>();
118 message::Table *tableMessage = getShare()->getTableMessage();
119 const message::Table::Index *primary = NULL;
120 for (
int indexnr= 0; indexnr < tableMessage->indexes_size() ; indexnr++)
122 const message::Table::Index &index = tableMessage->
indexes(indexnr);
123 if (index.is_primary()) {
126 }
else if (index.is_unique()) {
131 if (primary && keynr == 0)
133 for (
int partnr= 0; partnr < primary->index_part_size(); partnr++)
135 const message::Table::Index::IndexPart part= primary->index_part(partnr);
136 key_fields->push_back(part.fieldnr());
141 if (getShare()->hasPrimaryKey() ==
false)
144 uint32_t first_unique= get_first_unique_index(*getTable());
145 errmsg_printf(error::INSPECT,
"wiredtiger: first uniq=%d keynr=%d\n", first_unique, keynr);
147 if (first_unique == MAX_KEY || first_unique != keynr)
150 if (key_info != NULL)
152 KeyPartInfo *key_part= key_info->key_part;
153 KeyPartInfo *end= key_part + key_info->key_parts;
155 for(; key_part != end; key_part++)
157 errmsg_printf(error::INSPECT,
"wiredtiger: index %d field %d\n", keynr, key_part->fieldnr);
158 key_fields->push_back(key_part->fieldnr - 1);
168 wt_session= get_wt_session(*getTable()->getSession());
170 if ((ret = setupTableURI(identifier)) != 0)
175 share= get_share(identifier);
176 lock.init(&share->lock);
179 key_buf.memsize = value_buf.memsize =
180 getTable()->getRecordLength() + getTable()->sizeFields();
181 key_buf.data = key_buf.mem = malloc(key_buf.memsize);
182 value_buf.data = value_buf.mem = malloc(value_buf.memsize);
186 ref_length=
sizeof(uint32_t) + key_buf.memsize;
190 null_buf.memsize = getTable()->getRecordLength() + 1;
191 null_buf.data = null_buf.mem = malloc(null_buf.memsize);
196int WiredTigerCursor::close(
void)
200 if (wt_cursor != NULL)
202 wt_cursor->close(wt_cursor);
206 if (key_buf.mem != NULL) {
208 key_buf.data = key_buf.mem = NULL;
210 if (value_buf.mem != NULL) {
212 value_buf.data = value_buf.mem = NULL;
214 if (null_buf.mem != NULL) {
216 null_buf.data = null_buf.mem = NULL;
218 if (key_fields != NULL) {
239 Cursor *new_handler= getTable()->getMutableShare()->db_type()->getCursor(*getTable());
240 identifier::Table identifier(*getTable());
242 if (new_handler && !new_handler->
ha_open(identifier, getTable()->db_stat,
243 HA_OPEN_IGNORE_IF_LOCKED))
250const char *WiredTigerCursor::index_type(uint32_t )
257 boost::mutex::scoped_lock scopedLock(wt_share_mutex);
259 WiredTigerEngine *a_engine=
static_cast<WiredTigerEngine *
>(getEngine());
260 share= a_engine->findOpenTable(identifier);
264 share=
new WiredTigerTableShare(identifier);
269 if (getTable()->found_next_number_field)
270 share->auto_increment_value.fetch_and_store(
271 getInitialAutoIncrementValue());
273 a_engine->addOpenTable(identifier, share);
274 thr_lock_init(&share->lock);
281int WiredTigerCursor::free_share()
283 boost::mutex::scoped_lock scopedLock(wt_share_mutex);
285 if (!--share->use_count)
287 WiredTigerEngine *a_engine=
static_cast<WiredTigerEngine *
>(getEngine());
288 a_engine->deleteOpenTable(getTable()->getShare()->getTableIdentifier());
298 thr_lock_type lock_type)
300 reopen_cursor_if_needed();
302 if (lock_type != TL_UNLOCK)
310 const uint32_t sql_command = session->getSqlCommand();
312 if (sql_command == SQLCOM_DROP_TABLE) {
318 }
else if (lock_type == TL_READ_WITH_SHARED_LOCKS
319 || lock_type == TL_READ_NO_INSERT
320 || (lock_type != TL_IGNORE
321 && sql_command != SQLCOM_SELECT)) {
341 enum_tx_isolation isolation_level= session->getTxIsolation();
343 if (isolation_level != ISO_SERIALIZABLE
344 && (lock_type == TL_READ || lock_type == TL_READ_NO_INSERT)
345 && (sql_command == SQLCOM_INSERT_SELECT
346 || sql_command == SQLCOM_UPDATE
347 || sql_command == SQLCOM_CREATE_TABLE)) {
359 }
else if (sql_command == SQLCOM_CHECKSUM) {
367 }
else if (lock_type != TL_IGNORE) {
374 if (lock_type != TL_IGNORE && lock.type == TL_UNLOCK) {
382 if ((lock_type >= TL_WRITE_CONCURRENT_INSERT
383 && lock_type <= TL_WRITE)
384 && ! session->doing_tablespace_operation()
385 && sql_command != SQLCOM_TRUNCATE
386 && sql_command != SQLCOM_CREATE_TABLE) {
388 lock_type = TL_WRITE_ALLOW_WRITE;
398 if (lock_type == TL_READ_NO_INSERT) {
403 lock.type = lock_type;
428void WiredTigerCursor::set_keys_for_scanning(
void)
430 errmsg_printf(error::INSPECT,
"WiredTigerCursor::set_keys_for_scanning\n");
433void WiredTigerCursor::update_key_stats()
435 errmsg_printf(error::INSPECT,
"WiredTigerCursor::update_key_stats\n");
438int WiredTigerCursor::packIndex(
const char *format, WT_ITEM *buf,
442 WT_PACK_STREAM *packedKey;
444 if ((ret = wiredtiger_pack_start(wt_session, format,
445 buf->mem, buf->memsize, &packedKey)) != 0) {
446 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
447 return(HA_ERR_UNSUPPORTED);
452 ptrdiff_t row_offset= data->key - (getTable()->getInsertRecord() + 1);
453 for (
unsigned int offset = 0; offset < keyInfo->key_parts; offset++) {
454 KeyPartInfo &ip = keyInfo->key_part[offset];
458 ret = packField(ip.field, packedKey, row_offset);
459 row_offset += ip.store_length;
463 if ((ret = wiredtiger_pack_close(packedKey, &packed_size)) != 0) {
464 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
465 return(HA_ERR_UNSUPPORTED);
467 buf->size = packed_size;
471int WiredTigerCursor::packRecord(WT_ITEM *kBuf, WT_ITEM *vBuf,
472 const unsigned char *data)
475 WT_PACK_STREAM *packedKey, *packedValue;
478 if (!key_fields->empty()) {
479 if ((ret = wiredtiger_pack_start(wt_session, wt_cursor->key_format,
480 kBuf->mem, kBuf->memsize, &packedKey)) != 0) {
481 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
482 return(HA_ERR_UNSUPPORTED);
486 if ((ret = wiredtiger_pack_start(wt_session, wt_cursor->value_format,
487 vBuf->mem, vBuf->memsize, &packedValue)) != 0) {
488 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
489 return(HA_ERR_UNSUPPORTED);
491 return recordPacker(packedKey, packedValue, (
unsigned char *)data,
492 &(kBuf->size), &(vBuf->size),
true);
496int WiredTigerCursor::unpackRecord(WT_ITEM *kBuf, WT_ITEM *vBuf,
500 WT_PACK_STREAM *packedKey = NULL;
501 WT_PACK_STREAM *packedValue = NULL;
502 if (!key_fields->empty()) {
503 if ((ret = wiredtiger_unpack_start(wt_session, wt_cursor->key_format,
504 kBuf->data, kBuf->size, &packedKey)) != 0) {
505 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record unpack failure " SOURCE_LOCATION);
506 return(HA_ERR_UNSUPPORTED);
509 if ((ret = wiredtiger_unpack_start(wt_session, wt_cursor->value_format,
510 vBuf->data, vBuf->size, &packedValue)) != 0) {
511 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record unpack failure " SOURCE_LOCATION);
512 return(HA_ERR_UNSUPPORTED);
514 return recordPacker(packedKey, packedValue, data, NULL, NULL,
false);
519int WiredTigerCursor::recordPacker(
520 WT_PACK_STREAM *packedKey, WT_PACK_STREAM *packedValue,
521 unsigned char *data,
size_t *keySize,
size_t *valueSize,
bool packing)
525 Field **fields = getTable()->getFields();
526 ptrdiff_t row_offset= data - (*fields)->getTable()->getInsertRecord();
529 if (active_index == 0 || active_index == MAX_KEY) {
530 for (std::vector<int32_t>::iterator it = key_fields->begin();
531 it != key_fields->end(); ++it) {
533 ret = packField(fields[*it], packedKey, row_offset);
535 ret = unpackField(fields[*it], packedKey, row_offset);
540 for (Field **field= fields; *field; field++, colnr++)
542 if (find(key_fields->begin(), key_fields->end(), colnr) !=
546 ret = packField(*field, packedValue, row_offset);
548 ret = unpackField(*field, packedValue, row_offset);
554 assert(index_key_fields != NULL && index_value_fields != NULL);
555 for (std::vector<int32_t>::iterator it = index_key_fields->begin();
556 it != index_key_fields->end(); ++it) {
558 ret = packField(fields[*it], packedKey, row_offset);
560 errmsg_printf(error::INSPECT,
"wiredtiger: unpacking index key: %d\n", *it);
561 ret = unpackField(fields[*it], packedKey, row_offset);
566 for (std::vector<int32_t>::iterator it = index_value_fields->begin();
567 it != index_value_fields->end(); ++it) {
569 ret = packField(fields[*it], packedValue, row_offset);
571 ret = unpackField(fields[*it], packedValue, row_offset);
594 if (!key_fields->empty()) {
595 if ((ret = wiredtiger_pack_close(packedKey, &packed_size)) != 0) {
596 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
597 return(HA_ERR_UNSUPPORTED);
600 *keySize = packed_size;
602 if ((ret = wiredtiger_pack_close(packedValue, &packed_size)) != 0) {
603 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
604 return(HA_ERR_UNSUPPORTED);
607 *valueSize = packed_size;
612int WiredTigerCursor::getFieldEncoding(
Field *field,
char *
const type)
614 switch (field->type())
616 case DRIZZLE_TYPE_VARCHAR:
619 case DRIZZLE_TYPE_ENUM:
622 case DRIZZLE_TYPE_TIMESTAMP:
625 case DRIZZLE_TYPE_LONG:
628 case DRIZZLE_TYPE_DATE:
629 case DRIZZLE_TYPE_LONGLONG:
632 case DRIZZLE_TYPE_DOUBLE:
633 case DRIZZLE_TYPE_NULL:
634 case DRIZZLE_TYPE_DATETIME:
635 case DRIZZLE_TYPE_DECIMAL:
636 case DRIZZLE_TYPE_BLOB:
637 case DRIZZLE_TYPE_TIME:
638 case DRIZZLE_TYPE_BOOLEAN:
639 case DRIZZLE_TYPE_UUID:
640 case DRIZZLE_TYPE_MICROTIME:
641 case DRIZZLE_TYPE_IPV6:
643 my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0),
"Column Type");
644 return(HA_ERR_UNSUPPORTED);
650int WiredTigerCursor::packField(
651 Field *field, WT_PACK_STREAM *packer, ptrdiff_t row_offset)
656 field->move_field_offset(row_offset);
662 bool nullable = field->real_maybe_null();
663 WT_PACK_STREAM *real_packer = packer;
664 WT_PACK_STREAM *null_packer;
665 if (field->is_null()) {
666 ((
unsigned char *)null_buf.mem)[0] = 0;
668 if ((ret = wiredtiger_pack_item(real_packer, &null_buf)) != 0) {
669 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
670 field->move_field_offset(-row_offset);
671 return(HA_ERR_UNSUPPORTED);
678 ret = getFieldEncoding(field, &null_format[0]);
680 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
681 field->move_field_offset(-row_offset);
682 return(HA_ERR_UNSUPPORTED);
685 ((
unsigned char *)null_buf.mem)[0] = 1;
687 if ((ret = wiredtiger_pack_start(wt_session, null_format,
688 (
unsigned char *)null_buf.mem + 1, null_buf.memsize - 1,
689 &null_packer)) != 0) {
690 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
691 field->move_field_offset(-row_offset);
692 return(HA_ERR_UNSUPPORTED);
694 real_packer = null_packer;
697 switch (field->type())
699 case DRIZZLE_TYPE_VARCHAR:
704 field->val_str_internal(&str);
705 item.data = str.ptr();
706 item.size = str.length();
707 if ((ret = wiredtiger_pack_item(real_packer, &item)) != 0) {
708 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
709 return(HA_ERR_UNSUPPORTED);
712 case DRIZZLE_TYPE_ENUM:
713 if ((ret = wiredtiger_pack_uint(
714 real_packer, *(uint16_t *)field->
ptr)) != 0) {
715 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
716 return(HA_ERR_UNSUPPORTED);
719 case DRIZZLE_TYPE_TIMESTAMP:
720 if ((ret = wiredtiger_pack_uint(
721 real_packer, *(uint64_t *)field->
ptr)) != 0) {
722 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
723 return(HA_ERR_UNSUPPORTED);
726 case DRIZZLE_TYPE_LONG:
727 if ((ret = wiredtiger_pack_int(
728 real_packer, *(int32_t *)field->
ptr)) != 0) {
729 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
730 return(HA_ERR_UNSUPPORTED);
733 case DRIZZLE_TYPE_DATE:
734 case DRIZZLE_TYPE_LONGLONG:
735 if ((ret = wiredtiger_pack_int(
736 real_packer, *(int64_t *)field->
ptr)) != 0) {
737 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
738 return(HA_ERR_UNSUPPORTED);
741 case DRIZZLE_TYPE_DOUBLE:
742 case DRIZZLE_TYPE_NULL:
743 case DRIZZLE_TYPE_DATETIME:
744 case DRIZZLE_TYPE_DECIMAL:
745 case DRIZZLE_TYPE_BLOB:
746 case DRIZZLE_TYPE_TIME:
747 case DRIZZLE_TYPE_BOOLEAN:
748 case DRIZZLE_TYPE_UUID:
749 case DRIZZLE_TYPE_MICROTIME:
750 case DRIZZLE_TYPE_IPV6:
752 my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0),
"Column Type");
753 return(HA_ERR_UNSUPPORTED);
760 if ((ret = wiredtiger_pack_close(null_packer, &packedSize)) != 0) {
761 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
762 field->move_field_offset(-row_offset);
763 return(HA_ERR_UNSUPPORTED);
765 null_buf.size = packedSize + 1;
767 if ((ret = wiredtiger_pack_item(packer, &null_buf)) != 0) {
768 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
769 field->move_field_offset(-row_offset);
770 return(HA_ERR_UNSUPPORTED);
775 field->move_field_offset(-row_offset);
779int WiredTigerCursor::unpackField(
780 Field *field, WT_PACK_STREAM *unpacker, ptrdiff_t row_offset)
788 if (!field->isReadSet())
791 field->move_field_offset(row_offset);
792 field->setWriteSet();
796 bool nullable = field->real_maybe_null();
797 WT_PACK_STREAM *real_unpacker = unpacker;
798 WT_PACK_STREAM *null_unpacker;
802 ret = getFieldEncoding(field, &null_format[0]);
804 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record unpack failure " SOURCE_LOCATION);
805 return(HA_ERR_UNSUPPORTED);
810 if ((ret = wiredtiger_unpack_item(unpacker, &null_item)) != 0) {
811 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record unpack failure " SOURCE_LOCATION);
812 return(HA_ERR_UNSUPPORTED);
814 if (null_item.size == 0 ||
815 ((
const unsigned char *)null_item.data)[0] == 0) {
819 field->set_notnull();
820 if (null_item.size == 1) {
823 field->store(
"", 0, &my_charset_bin);
827 if ((ret = wiredtiger_unpack_start(wt_session, null_format,
828 (
const unsigned char *)null_item.data + 1,
829 null_item.size - 1, &null_unpacker)) != 0) {
830 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record unpack failure " SOURCE_LOCATION);
831 return(HA_ERR_UNSUPPORTED);
833 real_unpacker = null_unpacker;
836 switch (field->type())
838 case DRIZZLE_TYPE_VARCHAR:
839 if ((ret = wiredtiger_unpack_item(real_unpacker, &item)) != 0) {
840 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record unpack failure " SOURCE_LOCATION);
841 return(HA_ERR_UNSUPPORTED);
843 field->store((
const char *)item.data, item.size, &my_charset_bin);
845 case DRIZZLE_TYPE_ENUM:
846 if ((ret = wiredtiger_unpack_uint(real_unpacker, &u)) != 0) {
847 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record unpack failure " SOURCE_LOCATION);
848 return(HA_ERR_UNSUPPORTED);
850 *(uint16_t *)field->
ptr = (uint16_t)u;
852 case DRIZZLE_TYPE_TIMESTAMP:
853 if ((ret = wiredtiger_unpack_uint(real_unpacker, &u)) != 0) {
854 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record unpack failure " SOURCE_LOCATION);
855 return(HA_ERR_UNSUPPORTED);
857 *(uint64_t *)field->
ptr = u;
859 case DRIZZLE_TYPE_LONG:
860 if ((ret = wiredtiger_unpack_int(real_unpacker, &i)) != 0) {
861 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record unpack failure " SOURCE_LOCATION);
862 return(HA_ERR_UNSUPPORTED);
864 *(int32_t *)field->
ptr = (int32_t)i;
866 case DRIZZLE_TYPE_DATE:
867 case DRIZZLE_TYPE_LONGLONG:
868 if ((ret = wiredtiger_unpack_int(real_unpacker, &i)) != 0) {
869 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record unpack failure " SOURCE_LOCATION);
870 return(HA_ERR_UNSUPPORTED);
872 *(int64_t *)field->
ptr = i;
874 case DRIZZLE_TYPE_DOUBLE:
875 case DRIZZLE_TYPE_NULL:
876 case DRIZZLE_TYPE_DATETIME:
877 case DRIZZLE_TYPE_DECIMAL:
878 case DRIZZLE_TYPE_BLOB:
879 case DRIZZLE_TYPE_TIME:
880 case DRIZZLE_TYPE_BOOLEAN:
881 case DRIZZLE_TYPE_UUID:
882 case DRIZZLE_TYPE_MICROTIME:
883 case DRIZZLE_TYPE_IPV6:
885 my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0),
"Column Type");
886 return(HA_ERR_UNSUPPORTED);
891 if ((ret = wiredtiger_pack_close(null_unpacker, NULL)) != 0) {
892 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record unpack failure " SOURCE_LOCATION);
893 return(HA_ERR_UNSUPPORTED);
897 field->move_field_offset(-row_offset);
902int WiredTigerCursor::doInsertRecord(
unsigned char *buf)
906 r= open_table_cursor();
911 r= setupKeyFields(0,
true);
913 errmsg_printf(error::INSPECT,
"wiredtiger: key=%s value=%s\n", wt_cursor->key_format, wt_cursor->value_format);
915 reopen_cursor_if_needed();
917 if (getTable()->next_number_field && buf == getTable()->getInsertRecord())
919 if ((res= update_auto_increment()))
922 int ret = packRecord(&key_buf, &value_buf, buf);
926 if (!key_fields->empty())
927 wt_cursor->set_key(wt_cursor, &key_buf);
928 wt_cursor->set_value(wt_cursor, &value_buf);
929 ret = wt_cursor->insert(wt_cursor);
930 if (ret == WT_DUPLICATE_KEY) {
931 if (opt_flag & WT_WRITE_CAN_REPLACE)
932 ret = wt_cursor->update(wt_cursor);
940 return (HA_ERR_FOUND_DUPP_KEY);
949int WiredTigerCursor::doUpdateRecord(
const unsigned char *,
unsigned char * new_data)
951 int ret = packRecord(&key_buf, &value_buf, new_data);
955 if (!key_fields->empty())
956 wt_cursor->set_key(wt_cursor, &key_buf);
957 wt_cursor->set_value(wt_cursor, &value_buf);
958 if ((ret = wt_cursor->update(wt_cursor)) != 0) {
959 if (!(opt_flag & READ_CHECK_USED) && ret == WT_NOTFOUND)
960 ret = wt_cursor->insert(wt_cursor);
967int WiredTigerCursor::doDeleteRecord(
const unsigned char *)
971 ret = wt_cursor->remove(wt_cursor);
973 return wt_to_drizzle_error(ret);
985 ret= open_table_cursor();
990 reopen_cursor_if_needed();
992 ret= setupKeyFields(0,
true);
999 KeyInfo key_info = getShare()->getKeyInfo(active_index);
1001 wt_session= get_wt_session(*getTable()->getSession());
1004 if (index_key_fields != NULL)
1005 delete index_key_fields;
1006 index_key_fields =
new std::vector<int32_t>();
1007 if (index_value_fields != NULL)
1008 delete index_value_fields;
1009 index_value_fields =
new std::vector<int32_t>();
1011 unsigned int idx_colnr;
1013 idx_colnr < key_info.key_parts;
1018 errmsg_printf(error::INSPECT,
"WiredTigerCursor::doStartIndexScan adding field: %d\n",
1019 key_info.key_part[idx_colnr].field->position());
1020 index_key_fields->push_back(key_info.key_part[idx_colnr].field->position());
1023 string index_uri(
"index:");
1024 index_uri.append(share->table_identifier.getPath());
1025 index_uri.append(
":");
1026 index_uri.append(key_info.name);
1031 index_uri.append(
"(");
1034 Field **fields = getTable()->getFields();
1035 for (
Field **field= fields; *field; field++, colnr++) {
1039 skip == 0 && idx_colnr < key_info.key_parts;
1042 if (key_info.key_part[idx_colnr].field->position() == (*field)->position())
1047 errmsg_printf(error::INSPECT,
"WiredTigerCursor::doStartIndexScan adding value field: %d\n", colnr);
1048 index_value_fields->push_back(colnr);
1049 index_uri.append((*field)->field_name).append(
",");
1051 index_uri.append(
")");
1053 errmsg_printf(error::INSPECT,
"WiredTiger::doStartIndexScan %d %s\n",
1054 idx, index_uri.c_str());
1057 wt_cursor->close(wt_cursor);
1059 ret = wt_session->open_cursor(wt_session, index_uri.c_str(),
1060 NULL,
"append,raw", &wt_cursor);
1062 return wt_to_drizzle_error(ret);
1068int WiredTigerCursor::doEndIndexScan()
1070 active_index= MAX_KEY;
1071 wt_cursor->close(wt_cursor);
1072 if (index_key_fields != NULL)
1073 delete index_key_fields;
1074 if (index_value_fields != NULL)
1075 delete index_value_fields;
1078 index_key_fields = NULL;
1079 index_value_fields = NULL;
1084int WiredTigerCursor::wt_pack_from_index_buf(WT_ITEM *kBuf,
1086 const unsigned char *key_ptr,
1090 WT_PACK_STREAM *packedKey;
1093 if ((ret = wiredtiger_pack_start(wt_session, wt_cursor->key_format,
1094 kBuf->mem, kBuf->memsize, &packedKey)) != 0) {
1095 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
1096 return(HA_ERR_UNSUPPORTED);
1099 KeyPartInfo *key_part= key_info->key_part;
1100 KeyPartInfo *end= key_part + key_info->key_parts;
1101 const unsigned char *buff= key_ptr;
1103 for(; key_part != end && buff < key_ptr + key_len; key_part++)
1105 Field *field= key_part->field;
1106 bool is_null=
false;
1107 WT_PACK_STREAM *real_packer= packedKey;
1110 if (key_part->null_bit)
1123 switch (field->type())
1125 case DRIZZLE_TYPE_VARCHAR:
1128 buff+= key_part->length + 2;
1132 length= *buff + (*(buff + 1) << 8);
1137 if ((ret = wiredtiger_pack_item(real_packer, &item)) != 0) {
1138 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
1139 return(HA_ERR_UNSUPPORTED);
1142 buff+= key_part->length;
1144 case DRIZZLE_TYPE_ENUM:
1145 if ((ret = wiredtiger_pack_uint(
1146 real_packer, *(uint16_t *)buff)) != 0) {
1147 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
1148 return(HA_ERR_UNSUPPORTED);
1150 assert(key_part->length ==
sizeof(uint16_t));
1151 buff+= key_part->length;
1162 case DRIZZLE_TYPE_TIMESTAMP:
1163 if ((ret = wiredtiger_pack_uint(
1164 real_packer, *(uint64_t *)buff)) != 0) {
1165 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
1166 return(HA_ERR_UNSUPPORTED);
1168 assert(key_part->length ==
sizeof(uint64_t));
1169 buff+= key_part->length;
1171 case DRIZZLE_TYPE_LONG:
1172 if ((ret = wiredtiger_pack_int(
1173 real_packer, *(int32_t *)buff)) != 0) {
1174 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
1175 return(HA_ERR_UNSUPPORTED);
1177 assert(key_part->length ==
sizeof(int32_t));
1178 buff+= key_part->length;
1180 case DRIZZLE_TYPE_DATE:
1181 case DRIZZLE_TYPE_LONGLONG:
1182 if ((ret = wiredtiger_pack_int(
1183 real_packer, *(int64_t *)buff)) != 0) {
1184 my_error(ER_KEY_NOT_FOUND, MYF(0),
"Record pack failure");
1185 return(HA_ERR_UNSUPPORTED);
1187 assert(key_part->length ==
sizeof(int64_t));
1188 buff+= key_part->length;
1190 case DRIZZLE_TYPE_DOUBLE:
1191 case DRIZZLE_TYPE_NULL:
1192 case DRIZZLE_TYPE_DATETIME:
1193 case DRIZZLE_TYPE_DECIMAL:
1194 case DRIZZLE_TYPE_BLOB:
1195 case DRIZZLE_TYPE_TIME:
1196 case DRIZZLE_TYPE_BOOLEAN:
1197 case DRIZZLE_TYPE_UUID:
1198 case DRIZZLE_TYPE_MICROTIME:
1199 case DRIZZLE_TYPE_IPV6:
1201 my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0),
"Column Type");
1202 return(HA_ERR_UNSUPPORTED);
1206 assert(buff == key_ptr + key_len);
1211int WiredTigerCursor::index_read(
unsigned char *buf,
1212 const unsigned char *key_ptr,
1214 drizzled::ha_rkey_function find_flag)
1217 int r= wt_pack_from_index_buf(&key_buf, getTable()->key_info + active_index,
1219 WT_ITEM row_key, row_value;
1224 wt_cursor->set_key(wt_cursor, &key_buf);
1225 r= wt_cursor->search_near(wt_cursor, &exact);
1229 getTable()->status= STATUS_NOT_FOUND;
1233 getTable()->status= 0;
1235 if (exact != 0 && find_flag == HA_READ_KEY_EXACT)
1237 getTable()->status= STATUS_NOT_FOUND;
1251 if (!key_fields->empty())
1252 wt_cursor->get_key(wt_cursor, &row_key);
1253 wt_cursor->get_value(wt_cursor, &row_value);
1255 return unpackRecord(&row_key, &row_value, buf);
1258int WiredTigerCursor::index_next(
unsigned char * buf)
1260 errmsg_printf(error::INSPECT,
"WiredTigerCursor::index_next\n");
1261 return rnd_next(buf);
1264int WiredTigerCursor::index_prev(
unsigned char * buf)
1266 errmsg_printf(error::INSPECT,
"WiredTigerCursor::index_prev\n");
1268 WT_ITEM row_key, row_value;
1270 if ((ret = wt_cursor->prev(wt_cursor)) != 0) {
1271 if (ret == WT_NOTFOUND)
1272 return HA_ERR_END_OF_FILE;
1274 return wt_to_drizzle_error(ret);
1276 if (!key_fields->empty())
1277 wt_cursor->get_key(wt_cursor, &row_key);
1278 wt_cursor->get_value(wt_cursor, &row_value);
1279 return unpackRecord(&row_key, &row_value, buf);
1282int WiredTigerCursor::index_first(
unsigned char * buf)
1284 errmsg_printf(error::INSPECT,
"WiredTigerCursor::index_first\n");
1285 wt_cursor->reset(wt_cursor);
1286 return index_next(buf);
1289int WiredTigerCursor::index_last(
unsigned char * buf)
1291 errmsg_printf(error::INSPECT,
"WiredTigerCursor::index_last\n");
1292 wt_cursor->reset(wt_cursor);
1293 return index_prev(buf);
1300 r= open_table_cursor();
1301 reopen_cursor_if_needed();
1303 if (scan && wt_cursor != NULL)
1304 wt_cursor->reset(wt_cursor);
1306 r= setupKeyFields(0,
true);
1311int WiredTigerCursor::rnd_next(
unsigned char *buf)
1314 WT_ITEM row_key, row_value;
1316 if ((ret = wt_cursor->next(wt_cursor)) != 0) {
1317 if (ret == WT_NOTFOUND)
1318 return HA_ERR_END_OF_FILE;
1320 return wt_to_drizzle_error(ret);
1322 if (!key_fields->empty())
1323 wt_cursor->get_key(wt_cursor, &row_key);
1324 wt_cursor->get_value(wt_cursor, &row_value);
1325 return unpackRecord(&row_key, &row_value, buf);
1328int WiredTigerCursor::rnd_pos(
unsigned char * buf,
unsigned char *pos)
1331 WT_ITEM row_key, row_value;
1334 memcpy(&key_size, pos,
sizeof(key_size));
1335 row_key.data = pos +
sizeof(key_size);
1336 row_key.size = key_size;
1338 reopen_cursor_if_needed();
1339 wt_cursor->set_key(wt_cursor, &row_key);
1340 if ((ret = wt_cursor->search(wt_cursor)) != 0)
1341 return wt_to_drizzle_error(ret);
1343 wt_cursor->get_key(wt_cursor, &row_key);
1344 wt_cursor->get_value(wt_cursor, &row_value);
1345 return unpackRecord(&row_key, &row_value, buf);
1348void WiredTigerCursor::position(
const unsigned char *)
1351 uint32_t key_size= 0;
1353 if (wt_cursor != NULL && wt_cursor->get_key(wt_cursor, &row_key) == 0)
1355 key_size= row_key.size;
1356 memcpy(ref +
sizeof(key_size), row_key.data, key_size);
1358 memcpy(ref, &key_size,
sizeof(key_size));
1361int WiredTigerCursor::info(uint32_t flag)
1363 WT_CURSOR *stat_cursor;
1364 const char *desc, *pvalue;
1369 if (flag & HA_STATUS_VARIABLE)
1372 if (stats.records < 50000) {
1373 reopen_cursor_if_needed();
1374 string stat_uri(
"statistics:");
1375 stat_uri.append(table_uri);
1378 if (wt_session->open_cursor(wt_session, stat_uri.c_str(),
1379 NULL,
"", &stat_cursor) == 0)
1381 stat_cursor->set_key(stat_cursor, WT_STAT_DSRC_BTREE_ENTRIES);
1382 if (stat_cursor->search(stat_cursor) == 0 &&
1383 stat_cursor->get_value(stat_cursor, &desc, &pvalue, &value) == 0)
1384 stats.records= value;
1386 stat_cursor->set_key(stat_cursor, WT_STAT_DSRC_BTREE_COLUMN_DELETED);
1387 if (stat_cursor->search(stat_cursor) == 0 &&
1388 stat_cursor->get_value(stat_cursor, &desc, &pvalue, &value) == 0)
1389 stats.deleted= value;
1391 stat_cursor->close(stat_cursor);
1394 if (stats.records < 2)
1398 stats.data_file_length= stats.records * 40;
1399 stats.index_file_length= stats.records * 10;
1401 stats.mean_rec_length= stats.data_file_length / stats.records;
1405 if (flag & HA_STATUS_AUTO) {
1406 stats.auto_increment_value= 1;
1409 if (flag & HA_STATUS_ERRKEY)
1410 errmsg_printf(error::INSPECT,
"WiredTigerCursor::info(flag & HA_STATUS_ERRKEY)\n");
1413 if (flag & HA_STATUS_CONST)
1415 for (
unsigned int i = 0; i < getTable()->getShare()->sizeKeys(); i++)
1417 const char* index_name= getTable()->key_info[i].name;
1418 ha_rows rec_per_key;
1420 for (
unsigned int j=0; j < getTable()->key_info[i].key_parts; j++)
1422 string index_stat_uri(
"statistics:");
1423 index_stat_uri.append(table_uri).append(
":");
1424 index_stat_uri.append(index_name);
1426 if (wt_session->open_cursor(wt_session, index_stat_uri.c_str(),
1427 NULL,
"", &stat_cursor) == 0)
1429 stat_cursor->set_key(stat_cursor, WT_STAT_DSRC_BTREE_ENTRIES);
1430 if (stat_cursor->search(stat_cursor) == 0 &&
1431 stat_cursor->get_value(stat_cursor, &desc, &pvalue, &value) == 0)
1432 rec_per_key = value;
1433 stat_cursor->close(stat_cursor);
1440 rec_per_key= rec_per_key / 2;
1442 if (rec_per_key == 0)
1445 getTable()->key_info[i].rec_per_key[j]=
1446 rec_per_key >= ~(ulong) 0 ? ~(ulong) 0 :
1447 (ulong) rec_per_key;
1452 return wt_to_drizzle_error(ret);
1455int WiredTigerCursor::extra(
enum ha_extra_function operation)
1459 case HA_EXTRA_READCHECK:
1460 opt_flag |= READ_CHECK_USED;
1462 case HA_EXTRA_NO_READCHECK:
1463 opt_flag &= ~READ_CHECK_USED;
1465 case HA_EXTRA_FLUSH:
1467 case HA_EXTRA_IGNORE_DUP_KEY:
1468 case HA_EXTRA_INSERT_WITH_UPDATE:
1469 case HA_EXTRA_WRITE_CAN_REPLACE:
1470 opt_flag |= WT_WRITE_CAN_REPLACE;
1472 case HA_EXTRA_NO_IGNORE_DUP_KEY:
1473 case HA_EXTRA_WRITE_CANNOT_REPLACE:
1474 opt_flag &= ~WT_WRITE_CAN_REPLACE;
1476 case HA_EXTRA_CACHE:
1477 case HA_EXTRA_NO_CACHE:
1480 errmsg_printf(error::INSPECT,
"WiredTigerCursor::extra(operation=%d)\n", operation);
1489 errmsg_printf(error::INSPECT,
"WiredTigerCursor::reset\n");
1499 if (getTable()->in_use->getSqlCommand() == SQLCOM_TRUNCATE)
1501 wt_cursor->close(wt_cursor);
1503 r= wt_session->truncate(wt_session, table_uri.c_str(), NULL, NULL, NULL);
1505 wt_session->open_cursor(wt_session, table_uri.c_str(),
1506 NULL,
"append,raw", &wt_cursor);
1513 int ret = wt_session->open_cursor(wt_session, table_uri.c_str(),
1514 NULL, NULL, &start);
1516 return HA_ERR_GENERIC;
1518 int ret2 = wt_session->open_cursor(wt_session, table_uri.c_str(),
1522 start->close(start);
1523 return HA_ERR_GENERIC;
1526 ret = start->next(start);
1527 ret2 = stop->prev(stop);
1530 if (ret == WT_NOTFOUND || ret2 == WT_NOTFOUND)
1532 start->close(start);
1537 if (ret != 0 || ret2 != 0)
1539 start->close(start);
1541 return wt_to_drizzle_error(ret != 0 ? ret : ret2);
1544 r= wt_session->truncate(wt_session, NULL, start, stop, NULL);
1545 start->close(start);
1549 return wt_to_drizzle_error(r);
1576int WiredTigerCursor::disable_indexes(uint32_t mode)
1578 errmsg_printf(error::INSPECT,
"WiredTigerCursor::disable_indexes\n");
1582 if (mode == HA_KEY_SWITCH_ALL)
1584 if (!(error= wiredtiger_disable_indexes(file)))
1585 set_keys_for_scanning();
1590 error= HA_ERR_WRONG_COMMAND;
1629int WiredTigerCursor::enable_indexes(uint32_t mode)
1631 errmsg_printf(error::INSPECT,
"WiredTigerCursor::enable_indexes\n");
1635 if (mode == HA_KEY_SWITCH_ALL)
1637 if (!(error= wiredtiger_enable_indexes(file)))
1638 set_keys_for_scanning();
1643 error= HA_ERR_WRONG_COMMAND;
1666int WiredTigerCursor::indexes_are_disabled()
1668 errmsg_printf(error::INSPECT,
"WiredTigerCursor::indexes_are_disabled\n");
1672void WiredTigerCursor::drop_table()
1674 errmsg_printf(error::INSPECT,
"WiredTigerCursor::drop_table\n");
1689 errmsg_printf(error::INSPECT,
"WiredTigerCursor::records_in_range\n");
1690 ha_rows count = (ha_rows)1;
1700 reopen_cursor_if_needed();
1701 string idx_uri(table_uri);
1702 if (strncmp(keyInfo->name,
"PRIMARY", strlen(
"PRIMARY")) != 0)
1703 idx_uri.append(
":").append(keyInfo->name);
1704 WT_CURSOR *idx_cursor;
1705 wt_session->open_cursor(wt_session, idx_uri.c_str(),
1706 NULL,
"raw", &idx_cursor);
1707 WT_ITEM packedMinKey, packedMaxKey;
1708 packedMinKey.mem = packedMaxKey.mem = NULL;
1710 if (min_key != NULL) {
1711 packedMinKey.data = packedMinKey.mem = malloc(keyInfo->key_length);
1712 packedMinKey.memsize = keyInfo->key_length;
1713 packIndex(wt_cursor->key_format, &packedMinKey, min_key, keyInfo);
1714 idx_cursor->set_key(idx_cursor, &packedMinKey);
1715 ret = idx_cursor->search(idx_cursor);
1716 if (ret == WT_NOTFOUND && min_key->flag == HA_READ_KEY_EXACT)
1718 if (ret == WT_NOTFOUND && min_key->flag == HA_READ_KEY_OR_PREV)
1719 idx_cursor->prev(idx_cursor);
1721 if (max_key != NULL) {
1722 packedMaxKey.mem = malloc(keyInfo->key_length);
1723 packedMaxKey.size = keyInfo->key_length;
1724 packIndex(wt_cursor->key_format, &packedMaxKey, max_key, keyInfo);
1729 idx_cursor->next(idx_cursor);
1730 idx_cursor->get_key(idx_cursor, &currKey);
1732 }
while (memcmp(currKey.data, packedMaxKey.mem, currKey.size) < 0);
1734 idx_cursor->close(idx_cursor);
1735 if (packedMinKey.mem != NULL)
1736 free(packedMinKey.mem);
1737 if (packedMaxKey.mem != NULL)
1738 free(packedMaxKey.mem);
1743void WiredTigerCursor::get_auto_increment(uint64_t, uint64_t, uint64_t,
1744 uint64_t *first_value,
1745 uint64_t *nb_reserved_values)
1748 *first_value= share->auto_increment_value.fetch_and_increment();
1749 if (*first_value == 0)
1756 share->auto_increment_value.compare_and_swap(1, 0);
1759 *nb_reserved_values= 1;
1762int WiredTigerCursor::cmp_ref(
const unsigned char *ref1,
const unsigned char *ref2)
1764 uint32_t size1, size2;
1766 memcpy(&size1, ref1,
sizeof(size1));
1767 memcpy(&size2, ref2,
sizeof(size2));
1769 int r= memcmp(ref1 +
sizeof(size1), ref2 +
sizeof(size2),
1770 size1 < size2 ? size1 : size2);
1774 return (size1 < size2) ? -1 : (size1 > size2) ? 1 : 0;
1777uint64_t WiredTigerCursor::getInitialAutoIncrementValue()
1780 uint64_t defaultVal = getTable()->getShare()->getTableMessage()->
1781 options().auto_increment_value();
1783 setupKeyFields(0,
false);
1786 getTable()->mark_columns_used_by_index_no_reset(
1787 getTable()->getShare()->next_number_index);
1790 open_table_cursor();
1791 reopen_cursor_if_needed();
1792 if (wt_cursor->reset(wt_cursor) == 0 &&
1793 wt_cursor->prev(wt_cursor) == 0) {
1797 WT_ITEM row_key, row_value;
1798 wt_cursor->get_key(wt_cursor, &row_key);
1799 wt_cursor->get_value(wt_cursor, &row_value);
1800 unpackRecord(&row_key, &row_value, getTable()->getInsertRecord());
1801 nr= ((uint64_t) getTable()->found_next_number_field->val_int_offset(0));
1805 if (defaultVal > nr)
int delete_all_rows(void)
THR_LOCK_DATA ** store_lock(Session *, THR_LOCK_DATA **, thr_lock_type)
drizzled::ha_rows records_in_range(uint32_t inx, drizzled::key_range *min_key, drizzled::key_range *max_key)
int doStartIndexScan(uint32_t idx, bool)
int doStartTableScan(bool scan)
int ha_open(const identifier::Table &identifier, int mode, int test_if_locked)
Convert from decimal to binary representation.
TODO: Rename this file - func.h is stupid.