Merge pnousiainen@bk-internal.mysql.com:/home/bk/mysql-5.0-ndb

into mysql.com:/export/space/pekka/ndb/version/my50-dt

ndb/examples/ndbapi_event_example/ndbapi_event.cpp

@@ -140,6 +140,7 @@ int main()
 		eventTableName,
 		eventColumnName,
 		noEventColumnName);
+
   int j= 0;
   while (j < 5) {
 
@@ -238,8 +239,10 @@ int myCreateEvent(Ndb* myNdb,
   NdbDictionary::Dictionary *myDict= myNdb->getDictionary();
   if (!myDict) APIERROR(myNdb->getNdbError());
 
-  NdbDictionary::Event myEvent(eventName);
-  myEvent.setTable(eventTableName);
+  const NdbDictionary::Table *table= myDict->getTable(eventTableName);
+  if (!table) APIERROR(myDict->getNdbError());
+
+  NdbDictionary::Event myEvent(eventName, *table);
   myEvent.addTableEvent(NdbDictionary::Event::TE_ALL); 
   //  myEvent.addTableEvent(NdbDictionary::Event::TE_INSERT); 
   //  myEvent.addTableEvent(NdbDictionary::Event::TE_UPDATE); 

ndb/include/ndbapi/NdbDictionary.hpp

@@ -937,24 +937,55 @@ public:
 #endif
     };
 
+    /*
+     *  Constructor
+     *  @param  name  Name of event
+     */
     Event(const char *name);
+    /*
+     *  Constructor
+     *  @param  name  Name of event
+     *  @param  table Reference retrieved from NdbDictionary
+     */
+    Event(const char *name, const NdbDictionary::Table& table);
     virtual ~Event();
     /**
-     * Set unique identifier for the event
+     * Set/get unique identifier for the event
      */
     void setName(const char *name);
+    const char *getName() const;
+    /**
+     * Define table on which events should be detected
+     *
+     * @note calling this method will default to detection
+     *       of events on all columns. Calling subsequent
+     *       addEventColumn calls will override this.
+     *
+     * @param table reference retrieved from NdbDictionary
+     */
+    void setTable(const NdbDictionary::Table& table);
     /**
      * Set table for which events should be detected
+     *
+     * @note preferred way is using setTable(const NdbDictionary::Table)
+     *       or constructor with table object parameter
      */
     void setTable(const char *tableName);
+    /**
+     * Get table name for events
+     *
+     * @return table name
+     */
+    const char* getTableName() const;
     /**
      * Add type of event that should be detected
      */
     void addTableEvent(const TableEvent te);
     /**
-     * Set durability of the event
+     * Get/set durability of the event
      */
-    void setDurability(const EventDurability ed);
+    void setDurability(EventDurability ed);
+    EventDurability getDurability() const;
 #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
     void addColumn(const Column &c);
 #endif
@@ -971,7 +1002,7 @@ public:
      *
      * @param columnName Column name
      *
-     * @note errors will mot be detected until createEvent() is called
+     * @note errors will not be detected until createEvent() is called
      */
     void addEventColumn(const char * columnName);
     /**
@@ -985,6 +1016,13 @@ public:
      */
     void addEventColumns(int n, const char ** columnNames);
 
+    /**
+     * Get no of columns defined in an Event
+     *
+     * @return Number of columns, -1 on error
+     */
+    int getNoOfEventColumns() const;
+
     /**
      * Get object status
      */

ndb/include/ndbapi/NdbEventOperation.hpp

@@ -14,19 +14,6 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
-/*****************************************************************************
- * Name:          NdbEventOperation.hpp
- * Include:
- * Link:
- * Author:        Tomas Ulin MySQL AB
- * Date:          2003-11-21
- * Version:       0.1
- * Description:   Event support
- * Documentation:
- * Adjust:  2003-11-21  Tomas Ulin   First version.
- * Adjust:  2003-12-11  Tomas Ulin   Alpha Release.
- ****************************************************************************/
-
 #ifndef NdbEventOperation_H
 #define NdbEventOperation_H
 

ndb/src/ndbapi/NdbDictionary.cpp

@@ -585,6 +585,13 @@ NdbDictionary::Event::Event(const char * name)
   setName(name);
 }
 
+NdbDictionary::Event::Event(const char * name, const Table& table)
+  : m_impl(* new NdbEventImpl(* this))
+{
+  setName(name);
+  setTable(table);
+}
+
 NdbDictionary::Event::Event(NdbEventImpl & impl)
   : m_impl(impl) 
 {
@@ -604,12 +611,30 @@ NdbDictionary::Event::setName(const char * name)
   m_impl.setName(name);
 }
 
+const char *
+NdbDictionary::Event::getName() const
+{
+  return m_impl.getName();
+}
+
+void 
+NdbDictionary::Event::setTable(const Table& table)
+{
+  m_impl.setTable(table);
+}
+
 void 
 NdbDictionary::Event::setTable(const char * table)
 {
   m_impl.setTable(table);
 }
 
+const char*
+NdbDictionary::Event::getTableName() const
+{
+  return m_impl.getTableName();
+}
+
 void
 NdbDictionary::Event::addTableEvent(const TableEvent t)
 {
@@ -617,11 +642,17 @@ NdbDictionary::Event::addTableEvent(const TableEvent t)
 }
 
 void
-NdbDictionary::Event::setDurability(const EventDurability d)
+NdbDictionary::Event::setDurability(EventDurability d)
 {
   m_impl.setDurability(d);
 }
 
+NdbDictionary::Event::EventDurability
+NdbDictionary::Event::getDurability() const
+{
+  return m_impl.getDurability();
+}
+
 void
 NdbDictionary::Event::addColumn(const Column & c){
   NdbColumnImpl* col = new NdbColumnImpl;
@@ -649,6 +680,11 @@ NdbDictionary::Event::addEventColumns(int n, const char ** names)
     addEventColumn(names[i]);
 }
 
+int NdbDictionary::Event::getNoOfEventColumns() const
+{
+  return m_impl.getNoOfEventColumns();
+}
+
 NdbDictionary::Object::Status
 NdbDictionary::Event::getObjectStatus() const
 {

ndb/src/ndbapi/NdbDictionaryImpl.cpp

@@ -564,22 +564,28 @@ void NdbEventImpl::setName(const char * name)
   m_externalName.assign(name);
 }
 
+const char *NdbEventImpl::getName() const
+{
+  return m_externalName.c_str();
+}
+
 void 
-NdbEventImpl::setTable(const char * table)
+NdbEventImpl::setTable(const NdbDictionary::Table& table)
 {
-  m_tableName.assign(table);
+  m_tableImpl= &NdbTableImpl::getImpl(table);
+  m_tableName.assign(m_tableImpl->getName());
 }
 
-const char * 
-NdbEventImpl::getTable() const
+void 
+NdbEventImpl::setTable(const char * table)
 {
-  return m_tableName.c_str();
+  m_tableName.assign(table);
 }
 
 const char *
-NdbEventImpl::getName() const
+NdbEventImpl::getTableName() const
 {
-  return m_externalName.c_str();
+  return m_tableName.c_str();
 }
 
 void
@@ -599,6 +605,17 @@ NdbEventImpl::setDurability(const NdbDictionary::Event::EventDurability d)
   m_dur = d;
 }
 
+NdbDictionary::Event::EventDurability
+NdbEventImpl::getDurability() const
+{
+  return m_dur;
+}
+
+int NdbEventImpl::getNoOfEventColumns() const
+{
+  return m_attrIds.size() + m_columns.size();
+}
+
 /**
  * NdbDictionaryImpl
  */
@@ -2248,12 +2265,12 @@ int
 NdbDictionaryImpl::createEvent(NdbEventImpl & evnt)
 {
   int i;
-  NdbTableImpl* tab = getTable(evnt.getTable());
+  NdbTableImpl* tab = getTable(evnt.getTableName());
 
   if(tab == 0){
 #ifdef EVENT_DEBUG
     ndbout_c("NdbDictionaryImpl::createEvent: table not found: %s",
-	     evnt.getTable());
+	     evnt.getTableName());
 #endif
     return -1;
   }
@@ -2275,7 +2292,8 @@ NdbDictionaryImpl::createEvent(NdbEventImpl & evnt)
       evnt.m_facade->addColumn(*(col_impl->m_facade));
     } else {
       ndbout_c("Attr id %u in table %s not found", evnt.m_attrIds[i],
-	       evnt.getTable());
+	       evnt.getTableName());
+      m_error.code= 4713;
       return -1;
     }
   }
@@ -2533,8 +2551,8 @@ NdbDictionaryImpl::getEvent(const char * eventName)
   }
 
   // We only have the table name with internal name
-  ev->setTable(m_ndb.externalizeTableName(ev->getTable()));
-  ev->m_tableImpl = getTable(ev->getTable());
+  ev->setTable(m_ndb.externalizeTableName(ev->getTableName()));
+  ev->m_tableImpl = getTable(ev->getTableName());
 
   // get the columns from the attrListBitmask
 

ndb/src/ndbapi/NdbDictionaryImpl.hpp

@@ -195,11 +195,14 @@ public:
 
   void setName(const char * name);
   const char * getName() const;
+  void setTable(const NdbDictionary::Table& table);
   void setTable(const char * table);
-  const char * getTable() const;
+  const char * getTableName() const;
   void addTableEvent(const NdbDictionary::Event::TableEvent t);
-  void setDurability(const NdbDictionary::Event::EventDurability d);
+  void setDurability(NdbDictionary::Event::EventDurability d);
+  NdbDictionary::Event::EventDurability  getDurability() const;
   void addEventColumn(const NdbColumnImpl &c);
+  int getNoOfEventColumns() const;
 
   void print() {
     ndbout_c("NdbEventImpl: id=%d, key=%d",

ndb/src/ndbapi/ndberror.c

@@ -299,6 +299,12 @@ ErrorBundle ErrorCodes[] = {
   { 4232, AE, "Parallelism can only be between 1 and 240" },
   { 290,  AE, "Scan not started or has been closed by kernel due to timeout" },
 
+  /** 
+   * Event schema errors
+   */
+
+  { 4713,  SE, "Column defined in event does not exist in table"},
+  
   /** 
    * Event application errors
    */