Below is the list of changes that have just been committed into a local
5.1 repository of pekka. When pekka does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html
ChangeSet@stripped, 2007-01-20 13:14:30+01:00, pekka@stripped +3 -0
ndb - wl#3600 dict op<->dict object + fix trigger name
storage/ndb/include/kernel/signaldata/CreateTrig.hpp@stripped, 2007-01-20 13:13:49+01:00, pekka@stripped +2 -1
wl#3600 dict op<->dict object + fix trigger name
storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp@stripped, 2007-01-20 13:13:50+01:00, pekka@stripped +197 -39
wl#3600 dict op<->dict object + fix trigger name
storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp@stripped, 2007-01-20 13:13:50+01:00, pekka@stripped +29 -5
wl#3600 dict op<->dict object + fix trigger name
# This is a BitKeeper patch. What follows are the unified diffs for the
# set of deltas contained in the patch. The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User: pekka
# Host: clam.(none)
# Root: /export/space/pekka/ndb/version/my52-wl3600-a
--- 1.6/storage/ndb/include/kernel/signaldata/CreateTrig.hpp 2007-01-16 12:39:53 +01:00
+++ 1.7/storage/ndb/include/kernel/signaldata/CreateTrig.hpp 2007-01-20 13:13:49 +01:00
@@ -91,7 +91,8 @@
UnsupportedTriggerType = 4240,
BadRequestType = 4247,
InvalidName = 4248,
- InvalidTable = 4249
+ InvalidTable = 4249,
+ OutOfStringBuffer = 773
};
STATIC_CONST( SignalLength = 11 );
--- 1.135/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp 2007-01-18 13:18:45 +01:00
+++ 1.136/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp 2007-01-20 13:13:50 +01:00
@@ -301,7 +301,12 @@
const Uint32 size = name.size();
char buf[1024];
name.copy(buf);
- ndbout_c("%s m_ref_count: %d", buf, iter.curr.p->m_ref_count);
+ char active_op[40];
+ active_op[0] = 0;
+ if (iter.curr.p->m_op_ptr_i != RNIL)
+ sprintf(active_op, " active op: %x", iter.curr.p->m_op_ptr_i);
+ ndbout_c("%s: m_ref_count: %d%s",
+ buf, iter.curr.p->m_ref_count, active_op);
}
}
@@ -3938,11 +3943,6 @@
handleTabInfoInit(r, &parseRecord);
releaseSections(signal);
- {
- Uint32 tableId = parseRecord.tablePtr.i;
- Uint32 tableVersion = parseRecord.tablePtr.p->tableVersion;
- D("execCREATE_TABLE_REQ" << V(tableId) << V(tableVersion));
- }
if (parseRecord.errorCode != 0) {
jam();
@@ -4202,6 +4202,14 @@
tabPtr.p->tableVersion = tableVersion;
tabPtr.p->gciTableCreated = gci;
+ // link operation to object seized in handleTabInfoInit
+ {
+ DictObjectPtr obj_ptr;
+ Uint32 obj_ptr_i = tabPtr.p->m_obj_ptr_i;
+ bool ok = findDictObject(op_ptr, obj_ptr, obj_ptr_i);
+ ndbrequire(ok);
+ }
+
SchemaFile::TableEntry tabEntry;
tabEntry.m_tableVersion = tableVersion;
tabEntry.m_tableType = tabPtr.p->tableType;
@@ -6556,6 +6564,17 @@
return old_ptr.p;
}
+bool
+Dbdict::get_object(DictObjectPtr& obj_ptr, const char* name, Uint32 len, Uint32 hash)
+{
+ DictObject key;
+ key.m_key.m_name_ptr = name;
+ key.m_key.m_name_len = len;
+ key.m_key.m_pool = &c_rope_pool;
+ key.m_name.m_hash = hash;
+ return c_obj_hash.find(obj_ptr, key);
+}
+
void
Dbdict::release_object(Uint32 obj_ptr_i, DictObject* obj_ptr_p){
Rope name(c_rope_pool, obj_ptr_p->m_name);
@@ -7296,6 +7315,14 @@
return;
}
+ // link operation to object
+ {
+ DictObjectPtr obj_ptr;
+ Uint32 obj_ptr_i = tablePtr.p->m_obj_ptr_i;
+ bool ok = findDictObject(op_ptr, obj_ptr, obj_ptr_i);
+ ndbrequire(ok);
+ }
+
dropTabPtr.p->m_errorCode = 0;//
dropTabPtr.p->m_requestType = impl_req->requestType;//
dropTabPtr.p->m_coordinatorRef = impl_req->senderRef;//
@@ -8116,6 +8143,7 @@
dropTabPtr.p->m_participantData.m_gsn = GSN_DROP_TAB_CONF;
+ unlinkDictObject(op_ptr);
releaseTableObject(dropTabPtr.p->m_request.tableId);
DropTabConf * conf = (DropTabConf*)signal->getDataPtr();
@@ -8156,6 +8184,7 @@
if (removeFromHash)
{
jam();
+ // wl3600_todo have to call releaseDictObject
release_object(tablePtr.p->m_obj_ptr_i);
}
else
@@ -8196,7 +8225,7 @@
def.erase();
}
list.release();
-}//releaseTableObject()
+}
/**
* DICT receives these on index create and drop.
@@ -13338,7 +13367,7 @@
req->attributeMask = alterIndexPtr.p->m_attrMask;
char triggerName[MAX_TAB_NAME_SIZE];
- sprintf(triggerName, triggerTmpl.nameFormat, triggerNo);
+ sprintf(triggerName, triggerTmpl.nameFormat, impl_req->indexId);
// name section
Uint32 buffer[2 + ((MAX_TAB_NAME_SIZE + 3) >> 2)]; // SP string
@@ -14956,6 +14985,7 @@
// check name is unique
if (get_object(createTriggerPtr.p->m_triggerName) != 0) {
jam();
+ D("duplicate trigger name: " << createTriggerPtr.p->m_triggerName);
setError(error, CreateTrigRef::TriggerExists, __LINE__);
return;
}
@@ -15019,23 +15049,28 @@
// fill in trigger data
triggerPtr.p->triggerId = impl_req->triggerId;
triggerPtr.p->tableId = impl_req->tableId;
- triggerPtr.p->indexId = ~(Uint32)0; // caller connects to index
+ triggerPtr.p->indexId = RNIL; // caller connects to index
triggerPtr.p->triggerInfo = impl_req->triggerInfo;
triggerPtr.p->attributeMask = impl_req->attributeMask;
triggerPtr.p->triggerState = TriggerRecord::TS_OFFLINE;
+ {
+ Rope name(c_rope_pool, triggerPtr.p->triggerName);
+ if (!name.assign(createTriggerPtr.p->m_triggerName)) {
+ jam();
+ setError(error, CreateTrigRef::OutOfStringBuffer, __LINE__);
+ return;
+ }
+ }
-#ifdef wl3600_todo // do object stuff later
+ // connect to new DictObject
{
Ptr<DictObject> obj_ptr;
- ndbrequire(c_obj_hash.seize(obj_ptr));
- obj_ptr.p->m_name = triggerPtr.p->triggerName;
- obj_ptr.p->m_id = impl_req->triggerId; // XXX non-unique
- obj_ptr.p->m_type = triggerPtr.p->triggerType;
- obj_ptr.p->m_ref_count = 0;
- c_obj_hash.add(obj_ptr);
+ seizeDictObject(op_ptr, obj_ptr, triggerPtr.p->triggerName);
+
+ obj_ptr.p->m_id = impl_req->triggerId; // wl3600_todo id
+ obj_ptr.p->m_type = TriggerInfo::getTriggerType(triggerPtr.p->triggerInfo);
triggerPtr.p->m_obj_ptr_i = obj_ptr.i;
}
-#endif
}
bool
@@ -15808,11 +15843,15 @@
ndbrequire(impl_req->senderRef == numberToRef(DBDICT, c_masterNodeId));
ndbrequire(impl_req->senderData == op_ptr.p->op_key);
- // save name if any wl3600_todo use a requestType for this
- if (signal->getNoOfSections() > 0) {
+ bool reqByName = false;
+ if (signal->getNoOfSections() > 0) { // wl3600_todo use requestType
jam();
ndbrequire(signal->getNoOfSections() == 1);
+ reqByName = true;
+ }
+ if (reqByName) {
+ jam();
SegmentedSectionPtr ss_ptr;
signal->getSection(ss_ptr, DropTrigImplReq::TRIGGER_NAME_SECTION);
SimplePropertiesSectionReader r(ss_ptr, getSectionSegmentPool());
@@ -15833,35 +15872,54 @@
const Uint32 bytesize = sizeof(dropTriggerPtr.p->m_triggerName);
memcpy(dropTriggerPtr.p->m_triggerName, tableDesc.TableName, bytesize);
-#if wl3600_todo // do object stuff later
- DictObject * obj_ptr_p = get_object(triggerName);
- if (obj_ptr_p == 0){
+ // find object by name and link it to operation
+ DictObjectPtr obj_ptr;
+ if (!findDictObject(op_ptr, obj_ptr, dropTriggerPtr.p->m_triggerName)) {
jam();
- req->setTriggerId(RNIL);
- } else {
+ setError(error, DropTrigRef::TriggerNotFound, __LINE__);
+ return;
+ }
+ if (impl_req->triggerId != RNIL &&
+ impl_req->triggerId != obj_ptr.p->m_id) {
jam();
- //ndbout_c("++++++++++ Found trigger %s", triggerPtr.p->triggerName);
- TriggerRecordPtr triggerPtr;
- c_triggerRecordPool.getPtr(triggerPtr, obj_ptr_p->m_id);
- req->setTriggerId(triggerPtr.p->triggerId);
- req->setTableId(triggerPtr.p->tableId);
+ // inconsistency in request
+ setError(error, DropTrigRef::TriggerNotFound, __LINE__);
+ return;
}
-#endif
+ impl_req->triggerId = obj_ptr.p->m_id;
}
- // check the table wl3600_todo
- // check the index if any wl3600_todo
-
- // check the trigger
+ // check trigger id from user or via name
+ TriggerRecordPtr triggerPtr;
{
- const Uint32 triggerId = impl_req->triggerId;
if (! (impl_req->triggerId < c_triggerRecordPool.getSize())) {
jam();
setError(error, DropTrigImplRef::TriggerNotFound, __LINE__);
return;
}
+ c_triggerRecordPool.getPtr(triggerPtr, impl_req->triggerId);
// wl3600_todo state check
}
+
+ // connect to object in request by id
+ if (!reqByName) {
+ jam();
+ DictObjectPtr obj_ptr;
+ if (!findDictObject(op_ptr, obj_ptr, triggerPtr.p->m_obj_ptr_i)) {
+ jam();
+ // broken trigger object wl3600_todo bad error code
+ setError(error, DropTrigImplRef::TriggerNotFound, __LINE__);
+ return;
+ }
+ ndbrequire(obj_ptr.p->m_id == triggerPtr.p->triggerId);
+
+ // fill in name just to be complete
+ ConstRope name(c_rope_pool, triggerPtr.p->triggerName);
+ name.copy(dropTriggerPtr.p->m_triggerName); //wl3600_todo length check
+ }
+
+ // check the table wl3600_todo
+ // check the index if any wl3600_todo
}
bool
@@ -16008,6 +16066,17 @@
jam();
D("dropTrigger_commit");
+ DropTriggerDataPtr dropTriggerPtr;
+ getOpData(op_ptr, dropTriggerPtr);
+ const DropTrigImplReq* impl_req = &dropTriggerPtr.p->m_request;
+
+ TriggerRecordPtr triggerPtr;
+ c_triggerRecordPool.getPtr(triggerPtr, impl_req->triggerId);
+
+ // remove trigger
+ releaseDictObject(op_ptr);
+ triggerPtr.p->triggerState = TriggerRecord::TS_NOT_DEFINED;
+
schemaTrans_sendConf(signal, op_ptr.p->m_trans_ptr, 0);
}
@@ -19993,14 +20062,17 @@
Dbdict::releaseSchemaOp(SchemaOpPtr& op_ptr)
{
D("releaseSchemaOp" << V(op_ptr.i) << *op_ptr.p);
+
const OpInfo& info = getOpInfo(op_ptr);
(this->*(info.m_release))(op_ptr);
- OpDataPtr& data_ptr = op_ptr.p->m_data_ptr;
- DictObjectPtr& obj_ptr = data_ptr.p->m_obj_ptr;
- if (!obj_ptr.isNull()) {
+
+ OpDataPtr data_ptr = op_ptr.p->m_data_ptr;
+ Uint32 obj_ptr_i = data_ptr.p->m_obj_ptr_i;
+ if (obj_ptr_i != RNIL) {
jam();
- obj_ptr.p->m_op_ptr.setNull();
+ unlinkDictObject(op_ptr);
}
+
c_schemaOpHash.release(op_ptr);
op_ptr.setNull();
}
@@ -20053,6 +20125,92 @@
itAddLast(it, op_ptr);
op_ptr.p->m_trans_ptr = trans_ptr;
D("addSchemaOp" << *op_ptr.p);
+}
+
+// the link between SchemaOp and DictObject
+
+void
+Dbdict::getDictObject(SchemaOpPtr op_ptr, DictObjectPtr& obj_ptr)
+{
+ OpDataPtr data_ptr = op_ptr.p->m_data_ptr;
+ ndbrequire(data_ptr.p->m_obj_ptr_i != RNIL);
+ c_obj_pool.getPtr(obj_ptr, data_ptr.p->m_obj_ptr_i);
+}
+
+void
+Dbdict::linkDictObject(SchemaOpPtr op_ptr, DictObjectPtr obj_ptr)
+{
+ OpDataPtr data_ptr = op_ptr.p->m_data_ptr;
+ ndbrequire(data_ptr.p->m_obj_ptr_i == RNIL);
+ data_ptr.p->m_obj_ptr_i = obj_ptr.i;
+
+ obj_ptr.p->m_op_ptr_i = op_ptr.i;
+}
+
+void
+Dbdict::unlinkDictObject(SchemaOpPtr op_ptr)
+{
+ OpDataPtr data_ptr = op_ptr.p->m_data_ptr;
+
+ DictObjectPtr obj_ptr;
+ ndbrequire(data_ptr.p->m_obj_ptr_i != RNIL);
+ c_obj_pool.getPtr(obj_ptr, data_ptr.p->m_obj_ptr_i);
+
+ data_ptr.p->m_obj_ptr_i = RNIL;
+ obj_ptr.p->m_op_ptr_i = RNIL;
+}
+
+void
+Dbdict::seizeDictObject(SchemaOpPtr op_ptr, DictObjectPtr& obj_ptr,
+ const RopeHandle& name)
+{
+ bool ok = c_obj_hash.seize(obj_ptr);
+ ndbrequire(ok);
+ new (obj_ptr.p) DictObject();
+
+ obj_ptr.p->m_name = name;
+ c_obj_hash.add(obj_ptr);
+ obj_ptr.p->m_ref_count = 0;
+
+ linkDictObject(op_ptr, obj_ptr);
+}
+
+bool
+Dbdict::findDictObject(SchemaOpPtr op_ptr, DictObjectPtr& obj_ptr,
+ const char* name)
+{
+ if (get_object(obj_ptr, name)) {
+ jam();
+ linkDictObject(op_ptr, obj_ptr);
+ return true;
+ }
+ return false;
+}
+
+bool
+Dbdict::findDictObject(SchemaOpPtr op_ptr, DictObjectPtr& obj_ptr,
+ Uint32 obj_ptr_i)
+{
+ if (obj_ptr_i != RNIL) {
+ jam();
+ c_obj_pool.getPtr(obj_ptr, obj_ptr_i);
+ linkDictObject(op_ptr, obj_ptr);
+ return true;
+ }
+ return false;
+}
+
+void
+Dbdict::releaseDictObject(SchemaOpPtr op_ptr)
+{
+ DictObjectPtr obj_ptr;
+ getDictObject(op_ptr, obj_ptr);
+
+ obj_ptr.p->m_op_ptr_i = RNIL;
+ release_object(obj_ptr.i);
+
+ OpDataPtr data_ptr = op_ptr.p->m_data_ptr;
+ data_ptr.p->m_obj_ptr_i = RNIL;
}
// SchemaTrans
--- 1.63/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp 2007-01-18 13:18:45 +01:00
+++ 1.64/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp 2007-01-20 13:13:50 +01:00
@@ -634,7 +634,9 @@
RopePool c_rope_pool;
struct DictObject {
- DictObject() {}
+ DictObject() {
+ m_op_ptr_i = RNIL;
+ }
Uint32 m_id;
Uint32 m_type;
Uint32 m_ref_count;
@@ -661,13 +663,14 @@
}
// active operation on this object
- Ptr<struct SchemaOp> m_op_ptr;
+ Uint32 m_op_ptr_i;
};
typedef Ptr<DictObject> DictObjectPtr;
DLHashTable<DictObject> c_obj_hash; // Name
ArrayPool<DictObject> c_obj_pool;
-
+
+ //1
DictObject * get_object(const char * name){
return get_object(name, strlen(name) + 1);
}
@@ -678,6 +681,17 @@
DictObject * get_object(const char * name, Uint32 len, Uint32 hash);
+ //2
+ bool get_object(DictObjectPtr& obj_ptr, const char * name){
+ return get_object(obj_ptr, name, strlen(name) + 1);
+ }
+
+ bool get_object(DictObjectPtr& obj_ptr, const char * name, Uint32 len){
+ return get_object(obj_ptr, name, len, Rope::hash(name, len));
+ }
+
+ bool get_object(DictObjectPtr&, const char* name, Uint32 len, Uint32 hash);
+
void release_object(Uint32 obj_ptr_i){
release_object(obj_ptr_i, c_obj_pool.getPtr(obj_ptr_i));
}
@@ -1274,12 +1288,12 @@
const Uint32* const m_impl_req_data;
// DictObject operated on
- DictObjectPtr m_obj_ptr;
+ Uint32 m_obj_ptr_i;
OpData(const OpInfo& info, const Uint32* impl_req_data) :
m_opInfo(info),
m_impl_req_data(impl_req_data) {
- m_obj_ptr.setNull();
+ m_obj_ptr_i = RNIL;
}
};
typedef Ptr<OpData> OpDataPtr;
@@ -1477,6 +1491,16 @@
// add operation to transaction OpList
void addSchemaOp(SchemaTransPtr, SchemaOpPtr&);
+
+ // the link between SdhemaOp and DictObject
+
+ void getDictObject(SchemaOpPtr, DictObjectPtr&);
+ void linkDictObject(SchemaOpPtr op_ptr, DictObjectPtr obj_ptr);
+ void unlinkDictObject(SchemaOpPtr op_ptr);
+ void seizeDictObject(SchemaOpPtr, DictObjectPtr&, const RopeHandle& name);
+ bool findDictObject(SchemaOpPtr, DictObjectPtr&, const char* name);
+ bool findDictObject(SchemaOpPtr, DictObjectPtr&, Uint32 obj_ptr_i);
+ void releaseDictObject(SchemaOpPtr);
// list of SchemaOp (sans pool)
typedef DLFifoList<SchemaOp>::Head OpList;
| Thread |
|---|
| • bk commit into 5.1 tree (pekka:1.2393) | pekka | 20 Jan |
