From c5846d0e19e3b5fd9d818d714fea2df3f3ef90eb Mon Sep 17 00:00:00 2001 From: jsdelfino Date: Mon, 16 Nov 2009 06:46:29 +0000 Subject: Cleaning up SVN structure, moving das trunk to das-cpp/trunk. git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@880626 13f79535-47bb-0310-9956-ffa450edef68 --- .../core/src/apache/das/rdb/DASDataObject.cpp | 259 +++++++++++++++++++++ 1 file changed, 259 insertions(+) create mode 100644 das-cpp/trunk/runtime/core/src/apache/das/rdb/DASDataObject.cpp (limited to 'das-cpp/trunk/runtime/core/src/apache/das/rdb/DASDataObject.cpp') diff --git a/das-cpp/trunk/runtime/core/src/apache/das/rdb/DASDataObject.cpp b/das-cpp/trunk/runtime/core/src/apache/das/rdb/DASDataObject.cpp new file mode 100644 index 0000000000..f04d9dd7a5 --- /dev/null +++ b/das-cpp/trunk/runtime/core/src/apache/das/rdb/DASDataObject.cpp @@ -0,0 +1,259 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#include "apache/das/rdb/ModifiedDataObject.h" + +namespace apache { + namespace das { + namespace rdb { + +DASDataObject::DASDataObject(const Table& table, commonj::sdo::DataObjectPtr dataObject, + commonj::sdo::ChangeSummaryPtr changeSummary) : PKObject(table) { + + commonj::sdo::SettingList* settingList = 0; + this->changeSummary = changeSummary; + occChecked = false; + this->dataObject = dataObject; + bool modifiedOnGraph = changeSummary->isDeleted(dataObject) || changeSummary->isModified(dataObject); + + if (modifiedOnGraph) { + settingList = &changeSummary->getOldValues(dataObject); + } + + std::map settingMap; + const std::map columns = table.getColumns(); + std::string statement; + unsigned int pkColumnCount = table.getPKColumnCount(); + unsigned int pkCount = 0; + + if (modifiedOnGraph) { + + for (int i = 0 ; i < settingList->size() ; i++) { + settingMap.insert(std::make_pair((*settingList)[i].getProperty().getName(), &(*settingList)[i])); + } + + } + + for (std::map::const_iterator columnsIterator = columns.begin() ; + columnsIterator != columns.end() && pkColumnCount > pkCount ; columnsIterator++) { + const Column& column = *columnsIterator->second; + + if (column.isPK()) { + + if (modifiedOnGraph) { + + std::map::const_iterator settingIterator = + settingMap.find(column.getPropertyName()); + + if (settingIterator != settingMap.end()) { + + if (settingIterator->second->isNull() || !settingIterator->second->isSet()) { + //throw exception + } + + ColumnData* oldPKData = new ColumnData(column, *settingIterator->second); + addPrimaryKey(column.getPropertyName(), + *(oldPKData)); + + continue; + + } + + } + + if (dataObject->isNull(column.getPropertyName()) || !dataObject->isSet(column.getPropertyName())) { + //throw exception + } + + addPrimaryKey(column.getPropertyName(), *(new ColumnData(column, dataObject))); + + } + + } + +} + +bool DASDataObject::isOCCChecked(void) const { + return occChecked; +} + +void DASDataObject::setOCCChecked(bool occChecked) { + this->occChecked = occChecked; +} + +long DASDataObject::getOldOCC(void) const { + const Column* occCol = getTable().getOCCColumn(); + + if (occCol != 0) { + + try { + const commonj::sdo::Setting& setting = changeSummary->getOldValue(dataObject, *dataObject->getInstanceProperty(occCol->getPropertyName())); + + if (!setting.isNull() && setting.isSet()) { + return setting.getIntValue(); + } + + } catch (commonj::sdo::SDOIndexOutOfRangeException&) { + return getNewOCC(); + } + + } + + return 0; + +} + +long DASDataObject::getNewOCC(void) const { + const Column* occCol = getTable().getOCCColumn(); + + if (occCol != 0) { + + if (dataObject->isSet(occCol->getPropertyName()) && !dataObject->isNull(occCol->getPropertyName())) { + return dataObject->getInt(occCol->getName()); + } + + } + + return 0; + +} + +void DASDataObject::printStmt() { + std::cout << "[" << getTable().getTableName() << "]" << std::endl; + + for (std::list::iterator it = updateStatements.begin() ; it != updateStatements.end() ; it++) { + std::cout << *it << std::endl; + } + + std::cout << std::endl; + +} + +DASDataObject::~DASDataObject(void) { + + for (std::map::iterator it = fks.begin() ; it != fks.end() ; it++) { + delete it->second; + } + +} + +const commonj::sdo::DataObjectPtr DASDataObject::getDataObject(void) const { + return dataObject; +} + +std::string DASDataObject::getWhereStmt(void) const { + std::string stmt = "where "; + const KeyDataList& pks = getPrimaryKeys(); + unsigned int i = 1; + + for (KeyDataList::const_iterator it = pks.begin() ; it != pks.end() ; it++) { + stmt.append(getTable().getTableName() + "." + it->second->getColumn().getName()).append("=").append(/*"2"*/it->second->toSQL()); + + if (i != pks.size()) { + stmt.append(" and "); + } + + i++; + + } + + if (!isOCCChecked()) { + const Column* occCol = getTable().getOCCColumn(); + + if (occCol != 0) { + stmt.append(" and ").append(occCol->getName()).append("=").append(StringWrapper::toString(getOldOCC())); + } + + } + + return stmt; + +} + +std::string DASDataObject::getStatement(void) const { + return ""; +} + +RelationshipStatement& DASDataObject::addFK(const Relationship& relationship, const KeyDataList* keyDataList) { + std::map::iterator it = fks.find(relationship.getName()); + RelationshipStatement* relatStmt; + + if (it == fks.end()) { + relatStmt = new RelationshipStatement(relationship, keyDataList); + relatStmt->setDASDataObject(*this); + fks.insert(std::make_pair(relationship.getName(), relatStmt)); + + } else if (keyDataList != 0) { + relatStmt = it->second; + relatStmt->setFKList(keyDataList); + + } + + return *relatStmt; + +} + +void DASDataObject::execute(StatementPtr stmt) { + std::string statement = getStatement(); + + if (statement != "") { + const Column* occColumn = getTable().getOCCColumn(); + bool noData = false; + ResultSetPtr rs; + + try { + rs = stmt->executeQuery(statement); + + } catch (SQLException& ex) { + + if (ex.getODBCReturnCode() == SQL_NO_DATA) { + noData = true; + } else { + throw; + } + + } + + if (occColumn != 0 && !isOCCChecked()) { + + if (noData || rs->getRowCount() == 0) { + throw DASOptimisticConcurrencyControlException(); + } else { + setOCCChecked(true); + } + + } + + } + + for (std::list::const_iterator it = dependencies.begin() ; + it != dependencies.end() ; it++) { + + (*it)->execute(stmt); + + } + +} + +void DASDataObject::addDependency(RelationshipStatement& relationshipStatement) { + dependencies.push_back(&relationshipStatement); +} + + }; + }; +}; -- cgit v1.2.3