class.NodeUnifiedRDBMapper.php

Go to the documentation of this file.

<?php
/**
 * wCMF - wemove Content Management Framework
 * Copyright (C) 2005-2014 wemove digital solutions GmbH
 *
 * Licensed under the terms of any of the following licenses
 * at your choice:
 *
 * - GNU Lesser General Public License (LGPL)
 *   http://www.gnu.org/licenses/lgpl.html
 * - Eclipse Public License (EPL)
 *   http://www.eclipse.org/org/documents/epl-v10.php
 *
 * See the license.txt file distributed with this work for
 * additional information.
 *
 * $Id: class.NodeUnifiedRDBMapper.php 1462 2014-02-04 23:52:27Z iherwig $
 */
require_once(BASE."wcmf/lib/util/class.Message.php");
require_once(BASE."wcmf/lib/util/class.StringUtil.php");
require_once(BASE."wcmf/lib/model/class.Node.php");
require_once(BASE."wcmf/lib/model/mapper/class.NodeRDBMapper.php");

/**
 * @class NodeUnifiedRDBMapper
 * @ingroup Mapper
 * @brief NodeUnifiedRDBMapper maps Node objects to a relational database schema where each Node
 * type has its own table.
 * In comparison to NodeRDBMapper it implements almost all template methods from the
 * base classes and defines the sql queries. The newly defined template methods make it easier
 * for application developers to implement own mapper subclasses. The wCMFGenerator uses this class
 * as base class for all mappers.
 * Besides some methods that define table/column names, the main effort lies in implementing the
 * getObjectDefinitionImpl() method wich needs the following extra definitions:
 * - extra key _refs see NodeUnifiedRDBMapper::getObjectDefinitionImpl()
 * - in _datadef array the following keys are added:
 *    - column_name The name of the database column
 * - in _parents array the following keys are added:
 *    - is_navigable True/False wether the parent is navigable from this object or not
 *    - table_name The name of the database table of the parent
 *    - pk_columns An array of the name(s) of the primary key columns of the parent table
 *    - fk_columns The name of the foreign key column that point from the object's table to the parent table (compound foreign keys are not supported yet)
 * - in _children array the following keys are added:
 *    - is_navigable True/False wether the child is navigable from this object or not
 *    - table_name The name of the database table
 *    - pk_columns An array of the name(s) of the primary key columns of the child table
 *    - fk_column The name of the foreign key column that point from the child table to the object's table (compound foreign keys are not supported yet)
 *    - order_by An array of columns to sort by default
 *
 * @author      ingo herwig <ingo@wemove.com>
 */
class NodeUnifiedRDBMapper extends NodeRDBMapper
{
  /**
   * @see PersistenceMapper::initialize()
   */
  function initialize(&$object)
  {
    // add this as ChangeListener
    if ($object != null) {
      $object->addChangeListener($this);
    }
  }

  /**
   * @see RDBMapper::prepareInsert()
   */
  function prepareInsert(&$object)
  {
    $oid = $object->getOID();
    $oidParts = PersistenceFacade::decomposeOID($oid);
    $pkValues = $this->getPKNames();
    $pkColumns = $this->getPKColumnNames();
    for($i=0; $i<sizeof($pkColumns); $i++)
    {
      // foreign keys don't get a new id
      $pkColumn = $pkColumns[$i];
      if (!$this->isForeignKey($pkColumn))
      {
        $pkValue = $oidParts['id'][$i];
        // replace dummy ids with ids provided by the database sequence
        if (PersistenceFacade::isDummyId($pkValue))
        {
          $nextId = $this->getNextId();
          $object->setValue($pkColumn, $nextId, $pkValues[pkColumn]);
        }
      }
    }
  }
  /**
   * @see NodeRDBMapper::getObjectDefinition()
   */
  function getObjectDefinition()
  {
    static $result = null;
    if ($result == null)
    {
      $nodeDef = $this->getObjectDefinitionImpl();
      $result = array();

      $result['_properties'] = $nodeDef['_properties'];
      $result['_datadef'] = $nodeDef['_datadef'];

      // add the reference definitions to the attribute definitions to be readable by the application
      foreach ($nodeDef['_ref'] as $reference)
      {
        $reference['is_editable'] = false;
        $reference['app_data_type'] = DATATYPE_ATTRIBUTE;
        array_push($result['_datadef'], $reference);
      }

      // copy only navigable relatives
      $result['_parents'] = array();
      for ($i=0; $i<sizeof($nodeDef['_parents']); $i++)
      {
        if (!isset($nodeDef['_parents'][$i]['is_navigable']) || $nodeDef['_parents'][$i]['is_navigable']) {
          array_push($result['_parents'], $nodeDef['_parents'][$i]);
        }
      }
      $result['_children'] = array();
      for ($i=0; $i<sizeof($nodeDef['_children']); $i++)
      {
        if (!isset($nodeDef['_children'][$i]['is_navigable']) || $nodeDef['_children'][$i]['is_navigable']) {
          array_push($result['_children'], $nodeDef['_children'][$i]);
        }
      }
    }
    return $result;
  }
  /**
   * @see NodeRDBMapper::getSelectSQL()
   */
  function getSelectSQL($condStr, $orderStr=null, $attribs=null, $asArray=false)
  {
    $nodeDef = $this->getObjectDefinitionImpl();

    // replace application attribute/table names with sql names
    $condStr = $this->translateAppToDatabase($condStr);
    $orderStr = $this->translateAppToDatabase($orderStr);

    // parents
    $parentStr = '';
    $i=0;
    foreach($nodeDef['_parents'] as $curParent)
    {
      if (!isset($curParent['is_navigable']) || $curParent['is_navigable'])
      {
        $parentStr .= $this->quote($curParent['type'])." AS ptype$i, ".$this->getTableName().".".$curParent['fk_columns']." AS pid$i, ";
        $i++;
      }
    }
    if (strlen($parentStr) > 0) {
      $parentStr = StringUtil::removeTrailingComma($parentStr);
    }
    else {
      $parentStr = "'' AS ptype0, null AS pid0";
    }

    // construct query parts
    $attribStr = '';
    $tableName = $this->getTableName();
    $tableStr = $tableName;

    // attributes (make sure pk columns are selected)
    if ($attribs !== null) {
      $attribs = array_merge($attribs, $this->getPKColumnNames());
    }
    foreach($nodeDef['_datadef'] as $curDef) {
      if ($attribs === null || in_array($curDef['name'], $attribs)) {
        $attribStr .= $tableName.".".$curDef['column_name']." AS ".$this->quote($curDef['name']).", ";
      }
    }

    // references
    $refStrings = $this->getSQLForRefs($nodeDef, $attribStr, $tableStr, $condStr, $orderStr, $attribs);
    $attribStr = $refStrings['attribStr'];
    $tableStr = $refStrings['tableStr'];
    $condStr = $refStrings['condStr'];
    $orderStr = $refStrings['orderStr'];

    if (strlen($attribStr) > 0) {
      $attribStr .= ",";
    }
    if (strlen($condStr) == 0) {
      $condStr = "1";
    }
    $completeOrderStr = $orderStr;
    if (strlen($orderStr) > 0)
      $completeOrderStr = " ORDER BY ".$orderStr;
    else
    {
      // use default ordering
      $orderByCols = $this->getOrderBy();
      if (is_array($orderByCols))
      {
        $completeOrderStr = '';
        foreach($orderByCols as $orderByCol) {
          if (strlen(trim($orderByCol)) > 0) {
            $completeOrderStr .= $this->getTableName().".".$this->translateAppToDatabase($orderByCol).", ";
          }
        }
        if (strlen($completeOrderStr) > 0) {
          $completeOrderStr = ' ORDER BY '.StringUtil::removeTrailingComma($completeOrderStr);
        }
      }
    }

    if ($asArray) {
      return array(
        'attributeStr' => $attribStr." ".$parentStr,
        'tableStr' => $this->_dbPrefix.$tableStr,
        'conditionStr' => $condStr,
        'orderStr' => $orderStr
      );
    }
    else {
      return "SELECT ".$attribStr." ".$parentStr." FROM ".$this->_dbPrefix.$tableStr." WHERE ".$condStr.$completeOrderStr.";";
    }
  }
  /**
   * @see NodeRDBMapper::getChildrenSelectSQL()
   */
  function getChildrenSelectSQL($oid, $compositionOnly=false)
  {
    $sqlArray = array();
    $dbid = PersistenceFacade::getOIDParameter($oid, 'id');
    $nodeDef = $this->getObjectDefinitionImpl();
    foreach($nodeDef['_children'] as $childDef)
    {
      if (!isset($childDef['is_navigable']) || $childDef['is_navigable'])
      {
        if (!$compositionOnly || ($compositionOnly && $childDef['composition'] == true))
        {
          $sqlStr = $childDef['table_name'].".".$childDef['fk_columns']."=".$this->quote($dbid[0]);
          $sqlArray[$childDef['type']] = $sqlStr;
        }
      }
    }
    return $sqlArray;
  }
  /**
   * @see NodeRDBMapper::getChildrenDisassociateSQL()
   */
  function getChildrenDisassociateSQL($oid, $sharedOnly=false)
  {
    $sqlArray = array();
    $dbid = PersistenceFacade::getOIDParameter($oid, 'id');
    $nodeDef = $this->getObjectDefinitionImpl();
    foreach($nodeDef['_children'] as $childDef) {
      if (!$sharedOnly || ($sharedOnly && $childDef['composition'] == false)) {
        array_push($sqlArray, "UPDATE ".$this->_dbPrefix.$childDef['table_name']." SET ".$childDef['fk_columns']."=NULL WHERE ".
          $childDef['fk_columns']."=".$this->quote($dbid[0]).";");
      }
    }
    return $sqlArray;
  }
  /**
   * @see NodeRDBMapper::getInsertSQL()
   */
  function getInsertSQL(&$object)
  {
    $persistenceFacade = &PersistenceFacade::getInstance();

    $insertedAttributes = array();
    $attribNameStr = '';
    $attribValueStr = '';
    $tableName = $this->getTableName();

    // primary key definition
    $oid = $object->getOID();
    $oidParts = PersistenceFacade::decomposeOID($oid);
    $pkColumns = $this->getPKColumnNames();
    for($i=0; $i<sizeof($pkColumns); $i++)
    {
      // foreign keys are handled afterwards (they don't get a new id)
      $pkColumn = $pkColumns[$i];
      if (!$this->isForeignKey($pkColumn))
      {
        $pkValue = $oidParts['id'][$i];
        $attribNameStr .= $pkColumn.", ";
        $attribValueStr .= $this->quote($pkValue).", ";
        array_push($insertedAttributes, $pkColumn);
      }
    }

    // parent definition
    $parents = &$object->getParents();
    for ($i=0; $i<sizeof($parents); $i++)
    {
      $parent = &$parents[$i];
      if ($parent != null && PersistenceFacade::isValidOID($parent->getOID()) && PersistenceFacade::isKnownType($parent->getType()))
      {
        $parentDef = PersistenceFacade::decomposeOID($parent->getOID());
        $attribName = $this->getMyFKColumnName($parent->getType());

        $attribNameStr .= $attribName.", ";
        $attribValueStr .= $this->quote($parentDef['id'][0]).", ";
        array_push($insertedAttributes, $attribName);
      }
    }

    // attribute definition
    $nodeDef = $this->getObjectDefinitionImpl();
    foreach($nodeDef['_datadef'] as $curDef)
    {
      // insert only attributes that are defined in node
      if (in_array($curDef['name'], $object->getValueNames($curDef['app_data_type'])))
      {
        $attribName = $curDef['name'];
        // don't insert the same attribute twice
        if (!in_array($attribName, $insertedAttributes))
        {
          $attribNameStr .= $tableName.".".$curDef['column_name'].", ";
          $attribValueStr .= $this->quote($object->getValue($attribName, $curDef['app_data_type'])).", ";
          array_push($insertedAttributes, $attribName);
        }
      }
    }
    $attribNameStr = StringUtil::removeTrailingComma($attribNameStr);
    $attribValueStr = StringUtil::removeTrailingComma($attribValueStr);

    // query
    $sqlArray = array
    (
      "INSERT INTO ".$this->_dbPrefix.$tableName." (".$attribNameStr.") VALUES (".$attribValueStr.");"
    );
    return $sqlArray;
  }
  /**
   * @see NodeRDBMapper::getUpdateSQL()
   */
  function getUpdateSQL(&$object)
  {
    $updatedAttributes = array();
    $attribStr = '';
    $tableName = $this->getTableName();

    // primary key definition
    $pkStr = $this->createPKCondition($object->getOID());

    // parent definition
    $parents = &$object->getParents();
    for ($i=0; $i<sizeof($parents); $i++)
    {
      $parent = &$parents[$i];
      if ($parent != null && PersistenceFacade::isValidOID($parent->getOID()) && PersistenceFacade::isKnownType($parent->getType()))
      {
        $parentDef = PersistenceFacade::decomposeOID($parent->getOID());
        $attribName = $this->getMyFKColumnName($parent->getType());
        $attribStr = $tableName.".".$attribName."=".$this->quote($parentDef['id'][0]).", ";
        array_push($updatedAttributes, $attribName);
      }
    }

    // attribute definition
    $nodeDef = $this->getObjectDefinitionImpl();
    foreach($nodeDef['_datadef'] as $curDef)
    {
      // update only attributes that are defined in node
      if (in_array($curDef['name'], $object->getValueNames($curDef['app_data_type'])))
      {
        $attribName = $curDef['name'];
        // don't insert the same attribute twice
        if (!in_array($attribName, $updatedAttributes))
        {
          $attribStr .= $tableName.".".$curDef['column_name']."=".$this->quote($object->getValue($attribName, $curDef['app_data_type'])).", ";
          array_push($updatedAttributes, $attribName);
        }
      }
    }
    $attribStr = StringUtil::removeTrailingComma($attribStr);

    // query
    if (strlen($attribStr) > 0) {
      $sqlArray = array
      (
        "UPDATE ".$this->_dbPrefix.$tableName." SET ".$attribStr." WHERE ".$pkStr.";"
      );
    }
    else {
      $sqlArray = array();
    }
    return $sqlArray;
  }
  /**
   * @see NodeRDBMapper::getDeleteSQL()
   */
  function getDeleteSQL($oid)
  {
    // primary key definition
    $pkStr = $this->createPKCondition($oid);

    $sqlArray = array
    (
      "DELETE FROM ".$this->_dbPrefix.$this->getTableName()." WHERE ".$pkStr.";"
    );
    return $sqlArray;
  }
  /**
   * @see NodeRDBMapper::createPKCondition()
   */
  function createPKCondition($oid)
  {
    $str = '';
    $tableName = $this->getTableName();
    $pkColumns = $this->getPKColumnNames();
    $ids = PersistenceFacade::getOIDParameter($oid, 'id');
    for ($i=0; $i<sizeof($pkColumns); $i++)
    {
      $pkValue = $ids[$i];
      $str .= $tableName.".".$pkColumns[$i]."=".$this->quote($pkValue).' AND ';
    }
    return substr($str, 0, -5);
  }
  /**
   * Check if a given name is the name of a value
   * @param name The name to check
   * @return True/False
   */
  function isAttribute($name)
  {
    $nodeDef = $this->getObjectDefinition();
    foreach($nodeDef['_datadef'] as $curDef) {
      if ($curDef['name'] == $name) {
        return true;
      }
    }
    return false;
  }
  /**
   * Check if a given type is a child type
   * @param type The type to check
   * @param childDef The child array as defined in the _children key (see NodeRDBMapper::getObjectDefinition())
   * @return True/False
   */
  function isChild($type, $childDef)
  {
    return NodeUnifiedRDBMapper::getChildDef($type, $childDef) != null;
  }
  /**
   * Get the definition of a given child type
   * @param type The type to get the definition for
   * @param childDef The child array as defined in the _children key (see NodeRDBMapper::getObjectDefinition())
   * @return The child definition or null if not found
   */
  function getChildDef($type, $childDef)
  {
    foreach($childDef as $curChild) {
      if ($curChild['type'] == $type) {
        return $curChild;
      }
    }
    return null;
  }
  /**
   * Check if a given column is a foreign key (used to reference a parent)
   * @param column The column name
   * @return True/False
   */
  function isForeignKey($column)
  {
    $nodeDef = $this->getObjectDefinitionImpl();
    // search in parents
    foreach($nodeDef['_parents'] as $parent)
    {
      if ($parent['fk_columns'] == $column) {
        return true;
      }
    }
    return false;
  }
  /**
   * Get the SQL strings for use for the referenced values based on the given strings
   * @param nodeDef The node definition array (see NodeRDBMapper::getObjectDefinition())
   * @param attribStr The SQL attribute string to append to
   * @param tableStr The SQL table string to append to
   * @param condStr The SQL condition string to append to
   * @param orderStr The SQL order string to append to
   * @param attribs The attributes to select or null to select all
   * @return An assoziative array with the following keys 'attribStr', 'tableStr', 'condStr', 'orderStr' which hold the updated strings
   */
  function getSQLForRefs($nodeDef, $attribStr, $tableStr, $condStr, $orderStr, $attribs=null)
  {
    // references
    $joinStr = '';
    $aliasIndex = 0;
    $tableName = $this->getTableName();
    $referencedTables = array();
    foreach($nodeDef['_ref'] as $curDef)
    {
      if ($attribs == null || in_array($curDef['name'], $attribs))
      {
        $referencedType = $curDef['ref_type'];
        $referencedTable = $curDef['ref_table'];
        $referencedValue = $curDef['ref_value'];
        $referencedIdColumn = $curDef['id_column'];
        $referencedFkColumn = $curDef['fk_columns'];
        $referencedColumn = $curDef['ref_column'];

        if (strlen($this->getMyFKColumnName($referencedType, false)) > 0)
        {
          // reference from parent
          $attribStr .= $referencedTable.".".$referencedColumn." AS ".$this->quote($curDef['name']).", ";
          if (!in_array($referencedTable, $referencedTables))
          {
            $joinStr .= " LEFT JOIN ".$this->_dbPrefix.$referencedTable." ON ".
                    $referencedTable.".".$referencedIdColumn."=".$this->_dbPrefix.$tableName.".".$this->getMyFKColumnName($referencedType);
            array_push($referencedTables, $referencedTable);
          }
          $condStr = str_replace($curDef['ref_type'].".".$curDef['name'], $referencedTable.".".$referencedColumn, $condStr);
        }
        else
        {
          $childDef = $this->getChildDef($referencedType, $nodeDef['_children']);
          if ($childDef != null)
          {
            // reference from child
            $attribStr .= $referencedTable.".".$referencedColumn." AS ".$this->quote($curDef['name']).", ";
            if (!in_array($referencedTable, $referencedTables))
            {
              $joinStr .= " LEFT JOIN ".$this->_dbPrefix.$referencedTable." ON ";
              $pkColumns = $this->getPKColumnNames();
              $joinStr .= $referencedTable.".".$referencedFkColumn."=".$this->_dbPrefix.$tableName.".".$pkColumns[0];
              $joinStr .= " AND ".$referencedTable.".".$referencedIdColumn." = (SELECT MIN(".$referencedTable.".".$referencedIdColumn.") FROM ".$referencedTable." WHERE ".$referencedTable.".".$referencedFkColumn."=".$this->_dbPrefix.$tableName.".".$pkColumns[0].")";
              array_push($referencedTables, $referencedTable);
            }
            $condStr = str_replace($curDef['ref_type'].".".$curDef['name'], $referencedTable.".".$referencedColumn, $condStr);

            // add the order string to get the first child in order
            if (sizeof($childDef['order_by']) > 0)
            {
              $tmpOrderStr = '';
              foreach($childDef['order_by'] as $orderBy) {
                if (strlen($orderBy)) {
                  $tmpOrderStr .= $referencedTable.".".$orderBy.", ";
                }
              }
              $orderStr .= $tmpOrderStr;
            }
          }
          /*
          else
            WCMFException::throwEx("Reference ".$referencedType.".".$referencedValue." could not be resolved in type ".$this->getType(), __FILE__, __LINE__);
          */
        }
      }
      $aliasIndex++;
    }
    $attribStr = StringUtil::removeTrailingComma($attribStr);
    $tableStr .= $joinStr;
    $orderStr = StringUtil::removeTrailingComma($orderStr);
    return array('attribStr' => $attribStr, 'tableStr' => $tableStr, 'condStr' => $condStr, 'orderStr' => $orderStr);
  }
  /**
   * Replace all attribute and type occurences to columns and table name
   * @param str The string to translate (e.g. an orderby clause)
   * @return The translated string
   */
  function translateAppToDatabase($str)
  {
    // replace application attribute/table names with sql names
    $nodeDef = $this->getObjectDefinitionImpl();
    foreach($nodeDef['_datadef'] as $curDef) {
      $str = preg_replace('/\b'.$curDef['name'].'\b/', $curDef['column_name'], $str);
    }
    $str = preg_replace('/\b'.$this->getType().'\b/', $this->getTableName(), $str);
    return $str;
  }
  /**
   * Get the name of a column
   * @param attributeName The name of the corresponding attribute
   * @param dataType The data type of the attribute
   * @return The name of the column or null if not existent
   */
  function getColumnName($attributeName, $dataType=null)
  {
    $nodeDef = $this->getObjectDefinitionImpl();
    // search in attributes
    foreach($nodeDef['_datadef'] as $dataItem)
    {
      if ($dataItem['name'] == $attributeName && ($dataType == null || ($dataType != null && $dataType == $dataItem['app_data_type']))) {
        return $dataItem['column_name'];
      }
    }
    // search refs
    foreach($nodeDef['_ref'] as $dataItem)
    {
      if ($dataItem['name'] == $attributeName) {
        return null;
      }
    }
    WCMFException::throwEx($this->getType()." has no attribute ".$attributeName, __FILE__, __LINE__);
  }
  /**
   * Get the name of the foreign key column defined in a given child type that connects from that type to the primary key column
   * of this type.
   * @param childType The child type
   * @param isRequired True/False wether it is required to find a fk column or not
   * @return The name of the column
   */
  function getChildFKColumnName($childType, $isRequired=true)
  {
    $nodeDef = $this->getObjectDefinitionImpl();
    foreach($nodeDef['_children'] as $childDef)
    {
      if ($childDef['type'] == $childType) {
        return $childDef['fk_columns'];
      }
    }
    if ($isRequired) {
      WCMFException::throwEx("No foreign key name found for '".$childType."' in '".$this->getType()."'", __FILE__, __LINE__);
    }
  }
  /**
   * Get the name of the foreign key column defined in this type that connects to the primary key column
   * of a parent type.
   * @param parentType The parent type
   * @param isRequired True/False wether it is required to find a fk column or not
   * @return The name of the column
   */
  function getMyFKColumnName($parentType, $isRequired=true)
  {
    // check if parent type is listed
    $fkName = $this->getMyFKColumnNameImpl($parentType);
    if (strlen($fkName) > 0) {
      return $fkName;
    }
    // if not check base classes (roles may be modelled as subclasses of a class representing the database table)
    $nextParentType = get_parent_class($parentType);
    while ($nextParentType !== false && $nextParentType != 'Node' && $nextParentType != 'node')
    {
      $fkName = $this->getMyFKColumnNameImpl($nextParentType);
      if (strlen($fkName) > 0) {
        return $fkName;
      }
      $nextParentType = get_parent_class($nextParentType);
    }
    if ($isRequired) {
      WCMFException::throwEx("No foreign key name found for '".$parentType."' in '".$this->getType()."'", __FILE__, __LINE__);
    }
  }
  /**
   * Quote a value to be inserted into the database
   * @param value The value to quote
   * @return The quoted value
   */
  function quote($value)
  {
    if ($value == null) {
      return 'null';
    }
    else {
      $conn = &$this->getConnection();
      return $conn->quote($value);
    }
  }
  /**
   * Get the names of the primary key database columns of this type
   * @return An array of the names of the columns
   */
  function getPKColumnNames()
  {
    return array_keys($this->getPkNames());
  }
  /**
   * @see PersistenceMapper::isValidOID()
   */
  function isValidOID($oid)
  {
    $oidParts = PersistenceFacade::decomposeOID($oid);

    // check the type parameter
    if ($oidParts['type'] != $this->getType()) {
      return false;
    }
    // check the id parameter
    foreach ($oidParts['id'] as $id)
    {
      if (!is_numeric($id)) {
        return false;
      }
    }
    return true;
  }

  /**
   * ChangeListener interface implementation
   */

  /**
   * @see ChangeListener::getId()
   */
  function getId()
  {
    return __CLASS__;
  }
  /**
   * @see ChangeListener::valueChanged()
   */
  function valueChanged(&$object, $name, $type, $oldValue, $newValue) {}
  /**
   * @see ChangeListener::propertyChanged()
   */
  function propertyChanged(&$object, $name, $oldValue, $newValue)
  {
    if ($name == 'parentoids')
    {
      $nodeDef = $this->getObjectDefinitionImpl();

      // update the foreign key column values
      foreach($newValue as $newOID)
      {
        $oidParts = PersistenceFacade::decomposeOID($newOID);
        foreach($nodeDef['_parents'] as $curParent)
        {
          if ($curParent['type'] == $oidParts['type']) {
            $object->setValue($curParent['fk_columns'], $oidParts['id'][0]);
          }
        }
      }
    }
  }
  /**
   * @see ChangeListener::stateChanged()
   */
  function stateChanged(&$object, $oldValue, $newValue) {}

  /**
   * TEMPLATE METHODS
   * Subclasses must implement this method to define their object type.
   */

  /**
   * Implementation of NodeRDBMapper::getObjectDefinition()
   * @note Subclasses must implement this method to define their Node type.
   * @note NodeUnifiedRDBMapper enhances the node definition array by optional references, which may be noted
   * in the following key:
   *
   * - @em _refs: An array of assoziative arrays with the keys 'name', 'ref_type', 'ref_value', 'ref_table', 'id_column',
   *              'fk_columns', 'ref_column' for every referenced data item.
   *          With these definitions it is possible to reference values (ref_value) from other types (ref_type)
   *          (e.g. array('name' => 'employee_name', 'ref_type' => 'Employee', 'ref_value' => 'name', 'ref_table' => 'Employee',
   *              'id_column' => 'id', 'fk_columns' => 'fk_company_id', 'ref_colmn' => 'employee_name'))
   *
   * @note A type can only reference values from a type to which it is directly connected!
   */
  function getObjectDefinitionImpl()
  {
    WCMFException::throwEx("getObjectDefinitionImpl() must be implemented by derived class: ".get_class($this), __FILE__, __LINE__);
  }
  /**
   * Get the name of the database table, where this type is mapped to
   * @return The name of the table
   */
  function getTableName()
  {
    WCMFException::throwEx("getTableName() must be implemented by derived class: ".get_class($this), __FILE__, __LINE__);
  }
  /**
   * Get the name of the foreign key column defined in this type that connects to the primary key column
   * of a parent type.
   * @param parentType The parent type
   * @return The name of the column
   */
  function getMyFKColumnNameImpl($parentType)
  {
    WCMFException::throwEx("getMyFKColumnNameImpl() must be implemented by derived class: ".get_class($this), __FILE__, __LINE__);
  }
}
?>