You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tuscany.apache.org by ad...@apache.org on 2007/11/12 23:03:24 UTC
svn commit: r594314 [6/9] - in
/incubator/tuscany/sandbox/crestani/das_distribution_example: ./ bin/
bin/antscripts/ bin/bin/ bin/include/ bin/include/apache/
bin/include/apache/das/ bin/include/apache/das/rdb/ bin/lib/ bin/samples/
bin/samples/Company...
Added: incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/RefCountingPointer.cpp
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/RefCountingPointer.cpp?rev=594314&view=auto
==============================================================================
--- incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/RefCountingPointer.cpp (added)
+++ incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/RefCountingPointer.cpp Mon Nov 12 14:02:46 2007
@@ -0,0 +1,261 @@
+/*
+ * 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/RefCountingPointer.h"
+#include "apache/das/rdb/Statement.h"
+#include "apache/das/rdb/Connection.h"
+#include "apache/das/rdb/ReadCommandImpl.h"
+#include "apache/das/Command.h"
+#include "apache/das/CommandPtr.h"
+
+namespace apache {
+ namespace das {
+
+template<class T>
+void RefCountingPointer<T>::init()
+{
+ if (pointee == 0) return;
+ pointee->addRef(this);
+}
+
+template<class T>
+/*SDO_API*/ RefCountingPointer<T>::RefCountingPointer(T* realPtr, bool objectOwner)
+:pointee(realPtr)
+{
+ this->objectOwner = objectOwner;
+ init();
+}
+
+template<class T>
+/*SDO_API*/ RefCountingPointer<T>::RefCountingPointer(T& realPtr, bool objectOwner)
+:pointee(&realPtr)
+{
+ this->objectOwner = objectOwner;
+ init();
+}
+
+template<class T>
+RefCountingPointer<T>::RefCountingPointer(const RefCountingPointer<T>& rhs, bool objectOwner)
+: pointee(rhs.pointee)
+{
+ this->objectOwner = objectOwner;
+ init();
+}
+
+template<class T>
+/*SDO_API*/ RefCountingPointer<T>::~RefCountingPointer(void)
+{
+ if (pointee)pointee->releaseRef(this);
+}
+
+template<class T>
+/*SDO_API*/ RefCountingPointer<T>& RefCountingPointer<T>::operator=(const RefCountingPointer<T>& rhs)
+{
+ if (pointee != rhs.pointee)
+ {
+ T *oldP = pointee;
+ pointee = rhs.pointee;
+ init();
+ if (oldP) oldP->releaseRef(this);
+ }
+ return *this;
+}
+
+//RefCountingPointer& operator=(const RefCountingObject<T>& rhs)
+//{
+// if (pointee != &rhs)
+// {
+// T *oldP = pointee;
+// pointee = &pointee;
+// init();
+// if (oldP) oldP->releaseRef(this);
+// }
+// return *this;
+//}
+//
+//RefCountingPointer& operator=(const RefCountingObject<T>* rhs)
+//{
+// if (pointee != rhs)
+// {
+// T *oldP = pointee;
+// pointee = rhs;
+// init();
+// if (oldP) oldP->releaseRef(this);
+// }
+// return *this;
+//}
+
+template<class T>
+/*SDO_API*/ bool RefCountingPointer<T>::operator!() const
+{
+ return (pointee == 0);
+}
+
+template<class T>
+/*SDO_API*/ bool RefCountingPointer<T>::operator==(RefCountingPointer<T>& test) const
+{
+ return (pointee == test.pointee);
+}
+
+template<class T>
+/*SDO_API*/ T* RefCountingPointer<T>::operator->() const
+{
+ if (pointee == 0)
+ throw DASNullPointerException();
+ return pointee;
+}
+
+template<class T>
+/*SDO_API*/ T& RefCountingPointer<T>::operator*() const
+{
+ return *pointee;
+}
+
+template<class T>
+bool RefCountingPointer<T>::isObjectOwner(void) const {
+ return objectOwner;
+}
+
+
+ // officially, there is nothing here- but if I dont use the overrides in
+ // the templates, then they dont get generated.
+ void Test2()
+ {
+
+#if defined(WIN32) || defined (_WINDOWS)
+ {
+ /* 1) construct */
+ rdb::Connection* conn = new rdb::Connection("","","");
+ rdb::StatementPtr fptr = conn->createStatement();
+ rdb::StatementPtr a(new rdb::Statement(*conn, 0));
+ rdb::Statement& st = *(new rdb::Statement(*conn, 0));
+ rdb::StatementPtr* c = new rdb::StatementPtr(st);
+ c->isObjectOwner();
+
+ /* 2) use the & operator= */
+ fptr = conn->createStatement();
+
+ /* 3) copy */
+ rdb::StatementPtr fptr2 = fptr;
+
+ /* 4) use the == and ! */
+ if (fptr2 == fptr || !fptr){}
+
+ /* 5) Use the T* and * */
+ rdb::Statement* dmsf = fptr;
+ rdb::Statement& dmsr = *fptr;
+
+ /* 1) construct */
+ rdb::StatementPtr dfptr(fptr);
+
+ /* 3) copy */
+ rdb::StatementPtr dfptr2 = dfptr;
+
+ /* 2) use the & operator= */
+ dfptr = dfptr2;
+
+ /* 4) use the == and ! */
+ if (dfptr2 == dfptr || !dfptr){}
+
+ /* 5) Use the T* and * */
+ rdb::Statement* ddmsf = dfptr;
+ rdb::Statement& ddmsr = *dfptr;
+
+ /* 6) Use the -> */
+ dfptr->close();
+
+ /* and again to catch the = */
+ fptr = conn->createStatement();
+ delete fptr2;
+
+ }
+ {
+ /* 1) construct */
+ rdb::Connection* conn = new rdb::Connection("","","");
+ rdb::StatementPtr fptr = conn->createStatement();
+ rdb::ResultSetPtr a(new rdb::ResultSet(fptr));
+ rdb::ResultSetPtr b(new rdb::ResultSet(fptr));
+ rdb::ResultSet& st = *(new rdb::ResultSet(fptr));
+ rdb::ResultSetPtr* c = new rdb::ResultSetPtr(st);
+ c->isObjectOwner();
+ /* 2) use the & operator= */
+ a = b;
+
+ /* 3) copy */
+ rdb::ResultSetPtr d = a;
+
+ a = new rdb::ResultSet(fptr);
+ a = *(new rdb::ResultSet(fptr));
+
+ /* 4) use the == and ! */
+ if (a == b || !b){}
+
+ /* 5) Use the T* and * */
+ rdb::ResultSet* dmsf = a;
+ rdb::ResultSet& dmsr = *b;
+
+ /* 6) Use the -> */
+ a->getStatement();
+
+ /* and again to catch the = */
+ delete c;
+
+
+ }
+
+ {
+ /* 1) construct */
+ rdb::Connection* conn = new rdb::Connection("","","");
+ CommandPtr fptr = *(new CommandPtr());
+ CommandPtr a(*(new rdb::ReadCommandImpl(*(new rdb::DASImpl(*conn)), "")));
+ CommandPtr b(*(new rdb::ReadCommandImpl(*(new rdb::DASImpl(*conn)), "")));
+ Command& st = *(new rdb::ReadCommandImpl(*(new rdb::DASImpl(*conn)), ""));
+ CommandPtr* c = new CommandPtr(st);
+ c->isObjectOwner();
+ /* 2) use the & operator= */
+ a = b;
+
+ /* 3) copy */
+ CommandPtr d = a;
+
+ a = new rdb::ReadCommandImpl(*(new rdb::DASImpl(*conn)), "");
+ a = *(new rdb::ReadCommandImpl(*(new rdb::DASImpl(*conn)), ""));
+
+ /* 4) use the == and ! */
+ if (a == b || !b){}
+
+ /* 5) Use the T* and * */
+ CommandObject* dmsf = a;
+ CommandObject& dmsr = *b;
+
+ /* 6) Use the -> */
+ a->executeQuery();
+
+ /* and again to catch the = */
+ delete c;
+
+
+ }
+
+#endif
+
+ }
+
+ };
+};
Added: incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/SDODataObjectWrapper.cpp
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/SDODataObjectWrapper.cpp?rev=594314&view=auto
==============================================================================
--- incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/SDODataObjectWrapper.cpp (added)
+++ incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/SDODataObjectWrapper.cpp Mon Nov 12 14:02:46 2007
@@ -0,0 +1,44 @@
+/*
+ * 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/SDODataObjectWrapper.h"
+
+namespace apache {
+ namespace das {
+
+SDODataObjectWrapper::SDODataObjectWrapper(commonj::sdo::DataObjectPtr dataObject) {
+ this->dataObject = dataObject;
+}
+
+SDODataObjectWrapper::~SDODataObjectWrapper(void) {}
+
+std::string SDODataObjectWrapper::getString(std::string propertyName) const {
+ wchar_t* buff = new wchar_t[dataObject->getLength(propertyName.c_str())];
+ int copied = dataObject->getString(propertyName.c_str(), buff, 200);
+ std::wstring wstr(buff, copied);
+ std::string str(wstr.begin(), wstr.end());
+ str.assign(wstr.begin(), wstr.end());
+
+ delete [] buff;
+
+ return str;
+
+}
+
+ };
+};
Added: incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/StringWrapper.cpp
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/StringWrapper.cpp?rev=594314&view=auto
==============================================================================
--- incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/StringWrapper.cpp (added)
+++ incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/StringWrapper.cpp Mon Nov 12 14:02:46 2007
@@ -0,0 +1,148 @@
+/*
+ * 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/StringWrapper.h"
+
+namespace apache {
+ namespace das {
+
+StringWrapper::StringWrapper(std::string str) : str(str) {}
+
+StringWrapper::StringWrapper(commonj::sdo::DataObjectPtr dataObject, std::string propertyName) {
+ unsigned int length = dataObject->getLength(propertyName);
+ wchar_t* buffer = new wchar_t[length];
+ dataObject->getString(propertyName, buffer, length);
+
+ std::wstring wstr(buffer, 0, length);
+ this->str = std::string(wstr.begin(), wstr.end());
+ delete buffer;
+
+}
+
+std::string StringWrapper::toLower(void) const {
+ std::string str = this->str;
+ unsigned int length = str.length();
+
+ for(int i=0; i != length; i++) {
+ str[i] = tolower(str[i]);
+ }
+
+ return str;
+
+}
+
+std::string StringWrapper::toUpper(void) const {
+ std::string str = this->str;
+ unsigned int length = str.length();
+
+ for(int i=0; i != length; i++) {
+ str[i] = toupper(str[i]);
+ }
+
+ return str;
+
+}
+
+bool StringWrapper::isValidRDBName(void) const {
+
+ if (str.find(' ') != -1 || str.find('\t') != -1 || str.find('\n') != -1 || str.find('\r') != -1) {
+ return false;
+ } else {
+ return true;
+ }
+
+}
+
+std::string StringWrapper::toString(const double& t) {
+ std::stringstream ss;
+ ss << t;
+
+ return ss.str();
+
+}
+
+std::string StringWrapper::toString(const float& t) {
+ std::stringstream ss;
+ ss << t;
+
+ return ss.str();
+
+}
+
+std::string StringWrapper::toString(const long double& t) {
+ std::stringstream ss;
+ ss << t;
+
+ return ss.str();
+
+}
+
+std::string StringWrapper::toString(const unsigned char& t) {
+ std::stringstream ss;
+ ss << t;
+
+ return ss.str();
+
+}
+
+std::string StringWrapper::toString(const wchar_t& t) {
+ std::stringstream ss;
+ ss << t;
+
+ return ss.str();
+
+}
+
+std::string StringWrapper::toString(const int& t) {
+ std::stringstream ss;
+ ss << t;
+
+ return ss.str();
+
+}
+
+std::string StringWrapper::toString(const long& t) {
+ std::stringstream ss;
+ ss << t;
+
+ return ss.str();
+
+}
+
+std::string StringWrapper::getString(void) const {
+ return str;
+}
+
+
+std::string StringWrapper::toString(const unsigned int& t) {
+ std::stringstream ss;
+ ss << t;
+
+ return ss.str();
+
+}
+
+void StringWrapper::defineOnDataObject(commonj::sdo::DataObjectPtr dataObject, std::string propertyName) const {
+ std::wstring wstr(str.begin(), str.end());
+ dataObject->setString(propertyName, wstr.c_str(), wstr.size());
+
+}
+
+
+ };
+};
Added: incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ApplyChanges.cpp
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ApplyChanges.cpp?rev=594314&view=auto
==============================================================================
--- incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ApplyChanges.cpp (added)
+++ incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ApplyChanges.cpp Mon Nov 12 14:02:46 2007
@@ -0,0 +1,568 @@
+/*
+ * 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/ApplyChanges.h"
+
+namespace apache {
+ namespace das {
+ namespace rdb {
+
+ApplyChanges::ApplyChanges(DASImpl& das, commonj::sdo::DataObjectPtr root) : summary(root->getChangeSummary()) {
+ this->config = (const ConfigImpl*) &das.getConfig();
+ this->root = root;
+ processRootDataObject(root);
+ StatementPtr stmt = *das.getConnection()->createStatement();
+
+ try {
+
+ for (std::list<DASDataObject*>::iterator it = updateOrderList.begin() ;
+ it != updateOrderList.end() ; it++) {
+
+ (*it)->execute(stmt);
+
+ }
+
+ stmt->executeQuery("commit");
+
+ } catch (...) {
+ stmt->executeQuery("rollback");
+ throw;
+
+ }
+
+}
+
+ApplyChanges::~ApplyChanges(void) {
+
+ for (std::map<std::string, const Relationship*>::iterator relationshipsIterator = relationships.begin() ;
+ relationshipsIterator != relationships.end() ; relationshipsIterator++) {
+
+ delete relationshipsIterator->second;
+
+ }
+
+ for (std::map<std::string, const Table*>::iterator tablesIterator = tables.begin() ;
+ tablesIterator != tables.end() ; tablesIterator++) {
+
+ delete tablesIterator->second;
+
+ }
+
+ for (std::map<std::string, std::list<DASDataObject*>*>::iterator dasDataObjectsIterator = dasDataObjects.begin() ;
+ dasDataObjectsIterator != dasDataObjects.end() ; dasDataObjectsIterator++) {
+
+ std::list<DASDataObject*>* list = dasDataObjectsIterator->second;
+
+ for (std::list<DASDataObject*>::iterator listIterator = list->begin() ;
+ listIterator != list->end() ; listIterator++) {
+
+ delete *listIterator;
+
+ }
+
+ delete list;
+
+ }
+
+}
+
+void ApplyChanges::processRootDataObject(commonj::sdo::DataObjectPtr dataObject) {
+ commonj::sdo::ChangedDataObjectList& changedObjects = summary->getChangedDataObjects();
+ std::list<commonj::sdo::DataObjectPtr> createdObjects;
+ std::list<commonj::sdo::DataObjectPtr> deletedObjects;
+ std::list<commonj::sdo::DataObjectPtr> modifiedObjects;
+
+ for (unsigned int i = 0 ; i < changedObjects.size() ; i++) {
+
+ if (changedObjects[i] == root) {
+ continue;
+ }
+
+ processMetadata(changedObjects[i]);
+
+ if (summary->isCreated(changedObjects[i])) {
+ createdObjects.push_back(changedObjects[i]);
+
+ } else if (summary->isDeleted(changedObjects[i])) {
+ deletedObjects.push_back(changedObjects[i]);
+
+ } else {
+ modifiedObjects.push_back(changedObjects[i]);
+ }
+
+ //const commonj::sdo::SettingList& setting = summary->getOldValues(changedObjects[i]);
+
+ }
+
+ std::list<commonj::sdo::DataObjectPtr>::iterator deletedIterator;
+ for (deletedIterator = deletedObjects.begin() ; deletedIterator != deletedObjects.end() ; deletedIterator++) {
+ processDeletedDataObject(*deletedIterator);
+ }
+
+ std::list<commonj::sdo::DataObjectPtr>::iterator createdIterator;
+ for (createdIterator = createdObjects.begin() ; createdIterator != createdObjects.end() ; createdIterator++) {
+ processCreatedDataObject(*createdIterator);
+ }
+
+ std::list<commonj::sdo::DataObjectPtr>::iterator modifiedIterator;
+ for (modifiedIterator = modifiedObjects.begin() ; modifiedIterator != modifiedObjects.end() ; modifiedIterator++) {
+ processModifiedDataObject(*modifiedIterator);
+ }
+
+}
+
+DASDataObject& ApplyChanges::processDataObject(commonj::sdo::DataObjectPtr dataObject) {
+
+ if (summary->isCreated(dataObject)) {
+ return processCreatedDataObject(dataObject);
+ } else if (summary->isDeleted(dataObject)) {
+ return processDeletedDataObject(dataObject);
+ } else {
+ return processModifiedDataObject(dataObject);
+ }
+
+}
+
+void ApplyChanges::processMetadata(commonj::sdo::DataObjectPtr dataObject) {
+ const commonj::sdo::Type& type = dataObject->getType();
+ std::map<std::string, const Table*>::iterator it = tables.find((std::string) type.getName());
+
+ if (it != tables.end()) {
+ return;
+ }
+
+ const Table* configTable = config->getTableByTypeName((std::string) type.getName());
+ commonj::sdo::PropertyList properties = type.getProperties();
+ const std::map<std::string, const Column*>* configTableColumns;
+ std::map<std::string, const Column*>* configTableColumnsByPropertyName = 0;
+ Table* table;
+ unsigned int pkColumnCount = 0;
+ unsigned int pkFoundCount = 0;
+
+ if (configTable != 0) {
+ table = new Table(configTable->getTableName(), configTable->getTypeName());
+ configTableColumns = &configTable->getColumns();
+ configTableColumnsByPropertyName = new std::map<std::string, const Column*>();
+ pkColumnCount = configTable->getPKColumnCount();
+
+ for (std::map<std::string, const Column*>::const_iterator configTableColumnsIterator = configTableColumns->begin() ;
+ configTableColumnsIterator != configTableColumns->end() ; configTableColumnsIterator++) {
+
+ configTableColumnsByPropertyName->insert(
+ std::make_pair(configTableColumnsIterator->second->getPropertyName(),
+ configTableColumnsIterator->second));
+
+ }
+
+ } else {
+ table = new Table((std::string) type.getName());
+ }
+
+ for (unsigned int j = 0 ; j < properties.size() ; j++) {
+
+ if (properties[j].getType().isDataType()) {
+
+ if (configTable != 0) {
+ std::map<std::string, const Column*>::const_iterator configTableColumnsIterator =
+ configTableColumnsByPropertyName->find(properties[j].getName());
+
+ if (configTableColumnsIterator != configTableColumnsByPropertyName->end()) {
+ const Column& column = *configTableColumnsIterator->second;
+
+ if (column.isPK()) {
+ pkFoundCount++;
+ }
+
+ table->addColumn(column);
+
+ } else {
+ table->addColumn(properties[j].getName(), ODBCTypeHelper::getSQLType(properties[j].getType()));
+ }
+
+ } else {
+ table->addColumn(properties[j].getName(), ODBCTypeHelper::getSQLType(properties[j].getType()));
+ }
+
+ } else {
+ const Table* fkTable = config->getTableByTypeName(properties[j].getType().getName());
+ std::string fkTableName;
+
+ if (fkTable == 0) {
+ fkTableName = properties[j].getType().getName();
+ } else {
+ fkTableName = fkTable->getTableName();
+ }
+
+ const Relationship* relationship = config->getRelationship(table->getTableName(), fkTableName);
+
+ if (relationship == 0) {
+ Relationship* aux = new Relationship(table->getTableName(), fkTableName);
+ aux->addKeyPair("ID", table->getTableName() + "_ID");
+ relationships.insert(std::make_pair(table->getTableName() + "." + fkTableName, aux));
+
+ } else {
+ relationships.insert(std::make_pair(table->getTableName() + "." + fkTableName, new Relationship(*relationship)));
+ }
+
+ }
+
+ }
+
+ if (pkColumnCount == 0 || pkColumnCount > pkFoundCount) {
+ Column* column = table->getColumn("ID");
+
+ if (column == 0) {
+ throw DASPrimaryKeyNotFoundException((std::string) "No PK found on Type " + type.getURI() + "." + type.getName());
+ }
+
+ column->setPK(true);
+
+ }
+
+ if (configTableColumnsByPropertyName != 0) {
+ delete configTableColumnsByPropertyName;
+ }
+
+ tables.insert(std::make_pair(type.getName(), table));
+
+}
+
+bool ApplyChanges::isInStack(const DASDataObject& dasDataObject) {
+
+ for (std::list<DASDataObject*>::const_iterator it = stack.begin() ; stack.end() != it ; it++) {
+
+ if ((*it)->getDataObject() == dasDataObject.getDataObject()) {
+ return true;
+ }
+
+ }
+
+ return false;
+
+}
+
+const Table& ApplyChanges::getTable(commonj::sdo::DataObjectPtr dataObject) {
+ std::string typeName = dataObject->getType().getName();
+ std::map<std::string, const Table*>::const_iterator it = tables.find(typeName);
+
+ if (it == tables.end()) {
+ processMetadata(dataObject);
+ }
+
+ it = tables.find(typeName);
+
+ return *it->second;
+
+}
+
+CreatedDataObject& ApplyChanges::processCreatedDataObject(commonj::sdo::DataObjectPtr dataObject) {
+ DASDataObject* dasDB = getDASDataObject(dataObject);
+ //dataObject->printSelf(std::cout);
+
+ if (dasDB != 0) {
+ return (CreatedDataObject&) *dasDB;
+ }
+
+ CreatedDataObject* createdDataObject = new CreatedDataObject(
+ getTable(dataObject), dataObject, summary);
+
+ updateOrderList.push_back(createdDataObject);
+ addDataObject(*createdDataObject);
+ commonj::sdo::PropertyList properties = dataObject->getInstanceProperties();
+
+ for (unsigned int i = 0 ; i < properties.size() ; i++) {
+
+ if (properties[i].getType().isDataObjectType()) {
+
+ if (properties[i].isMany()) {
+ commonj::sdo::DataObjectList& dataObjectList = dataObject->getList(properties[i]);
+
+ for (unsigned int j = 0 ; j < dataObjectList.size() ; j++) {
+ DASDataObject& dob = processDataObject(dataObjectList[j]);
+ RelationshipStatement& rs = dob.addFK(getRelationship(*createdDataObject, dob), &createdDataObject->getPrimaryKeys());
+ dob.addDependency(rs);
+
+ }
+
+ } else {
+ commonj::sdo::DataObjectPtr dao = dataObject->getDataObject(properties[i]);
+ DASDataObject& dob = processDataObject(dao);
+ dob.addFK(getRelationship(*createdDataObject, dob), &createdDataObject->getPrimaryKeys());
+ RelationshipStatement& rs = dob.addFK(getRelationship(*createdDataObject, dob), &createdDataObject->getPrimaryKeys());
+ dob.addDependency(rs);
+
+ }
+
+ }
+
+ }
+
+ return *createdDataObject;
+
+}
+
+const Relationship& ApplyChanges::getRelationship(DASDataObject& parentDataObject, DASDataObject& dataObject) const {
+ std::map<std::string, const Relationship*>::const_iterator relatIt = relationships.
+ find(parentDataObject.getTable().getTableName() + "." + dataObject.getTable().getTableName());
+
+ return *relatIt->second;
+
+}
+
+DeletedDataObject& ApplyChanges::processDeletedDataObject(commonj::sdo::DataObjectPtr dataObject) {
+ DASDataObject* dasDB = getDASDataObject(dataObject);
+ //dataObject->printSelf(std::cout);
+
+ if (dasDB != 0) {
+ return (DeletedDataObject&) *dasDB;
+ }
+
+ DeletedDataObject* deletedDataObject = new DeletedDataObject(
+ getTable(dataObject), dataObject, summary);
+
+ const commonj::sdo::SettingList& setting = summary->getOldValues(dataObject);
+
+ for (int i = 0 ; i < setting.size() ; i++) {
+
+ if (setting[i].isSet() && setting[i].getProperty().getType().isDataObjectType()) {
+ commonj::sdo::DataObjectPtr containedDataObject = setting[i].getDataObjectValue();
+
+ if (!summary->isDeleted(containedDataObject)) {
+ DASDataObject& modDO = processDataObject(containedDataObject);
+ RelationshipStatement& rs = modDO.addFK(getRelationship(*deletedDataObject, modDO), 0);
+ deletedDataObject->addDependency(rs);
+
+ }
+
+ }
+
+ }
+
+ addDataObject(*deletedDataObject);
+ updateOrderList.push_back(deletedDataObject);
+
+ return *deletedDataObject;
+
+}
+
+DASDataObject* ApplyChanges::getDASDataObject(commonj::sdo::DataObjectPtr dataObject) const {
+ std::map<std::string, std::list<DASDataObject*>*>::const_iterator it = dasDataObjects.find((std::string) dataObject->getType().getName());
+
+ if (it != dasDataObjects.end()) {
+ std::list<DASDataObject*>& list = *it->second;
+ std::list<DASDataObject*>::iterator it2;
+
+ for (it2 = list.begin() ; it2 != list.end() ; it2++) {
+
+ if ((*it2)->getDataObject() == dataObject) {
+ return *it2;
+ }
+
+ }
+
+ }
+
+ return 0;
+
+}
+
+ModifiedDataObject& ApplyChanges::processModifiedDataObject(commonj::sdo::DataObjectPtr dataObject) {
+ DASDataObject* dasDB = getDASDataObject(dataObject);
+ //dataObject->printSelf(std::cout);
+
+ if (dasDB != 0) {
+ return (ModifiedDataObject&) *dasDB;
+ }
+
+ ModifiedDataObject* modifiedDataObject = new ModifiedDataObject(
+ getTable(dataObject), dataObject, summary);
+
+ updateOrderList.push_back(modifiedDataObject);
+ addDataObject(*modifiedDataObject);
+
+ if (summary->isModified(dataObject)) {
+ std::map<const commonj::sdo::Property*, std::list<commonj::sdo::DataObjectPtr>*> manyOldValuedProperties;
+ std::map<const commonj::sdo::Property*, commonj::sdo::DataObjectPtr> singleOldValuedProperties;
+ commonj::sdo::PropertyList props = dataObject->getInstanceProperties();
+ const commonj::sdo::SettingList& setting = summary->getOldValues(dataObject);
+
+ for (int i = 0 ; i < setting.size() ; i++) {
+ const commonj::sdo::Property& prop = setting[i].getProperty();
+
+ if (prop.getType().isDataObjectType()) {
+
+ if (!setting[i].isNull() && setting[i].isSet()) {
+ commonj::sdo::DataObjectPtr oldDO = setting[i].getDataObjectValue();
+ //oldDO->printSelf(std::cout);
+ //std::cout << std::endl;
+
+ if (prop.isMany()) {
+ std::map<const commonj::sdo::Property*, std::list<commonj::sdo::DataObjectPtr>*>::iterator manyIt =
+ manyOldValuedProperties.find(&prop);
+
+ std::list<commonj::sdo::DataObjectPtr>* list;
+
+ if (manyIt == manyOldValuedProperties.end()) {
+ list = new std::list<commonj::sdo::DataObjectPtr>();
+ manyOldValuedProperties.insert(std::make_pair(&prop, list));
+
+ } else {
+ list = manyIt->second;
+ }
+
+ list->push_back(oldDO);
+
+ } else {
+ singleOldValuedProperties.insert(std::make_pair(&prop, oldDO));
+ }
+
+ }
+
+ }
+ }
+
+ for (unsigned int i = 0 ; i < props.size() ; i++) {
+
+ if (props[i].getType().isDataObjectType()) {
+
+ if (props[i].isMany()) {
+
+ if (!dataObject->isSet(props[i]) || !dataObject->isNull(props[i])) {
+ commonj::sdo::DataObjectList& doList = dataObject->getList(props[i]);
+
+ for (unsigned int j = 0 ; j < doList.size() ; j++) {
+ commonj::sdo::DataObjectPtr dob = doList[j];
+
+ if (summary->isCreated(dob)) {
+ CreatedDataObject& createdDO = processCreatedDataObject(dob);
+ RelationshipStatement& rs = createdDO.addFK(getRelationship(*modifiedDataObject, createdDO), &modifiedDataObject->getPrimaryKeys());
+ modifiedDataObject->addDependency(rs);
+
+ } else {
+ std::map<const commonj::sdo::Property*, std::list<commonj::sdo::DataObjectPtr>*>::iterator manyIt =
+ manyOldValuedProperties.find(&props[i]);
+
+ bool existsOldDO = false;
+
+ if (manyIt != manyOldValuedProperties.end()) {
+ std::list<commonj::sdo::DataObjectPtr>& list = *manyIt->second;
+
+ for (std::list<commonj::sdo::DataObjectPtr>::iterator listIt = list.begin() ;
+ listIt != list.end() ; listIt++) {
+
+ if (*listIt == dob) {
+ existsOldDO = true;
+ list.erase(listIt);
+ break;
+
+ }
+
+ }
+
+ }
+
+ if (!existsOldDO) {
+ ModifiedDataObject& modDO = processModifiedDataObject(dob);
+ RelationshipStatement& rs = modDO.addFK(getRelationship(*modifiedDataObject, modDO), &modifiedDataObject->getPrimaryKeys());
+ modifiedDataObject->addDependency(rs);
+
+ }
+
+ }
+
+ }
+
+ }
+
+ } else {
+
+ if (!dataObject->isSet(props[i]) || !dataObject->isNull(props[i])) {
+ commonj::sdo::DataObjectPtr dob = dataObject->getDataObject(props[i]);
+
+ if (summary->isCreated(dob)) {
+ CreatedDataObject& createdDO = processCreatedDataObject(dob);
+ RelationshipStatement& rs = createdDO.addFK(getRelationship(*modifiedDataObject, createdDO), &modifiedDataObject->getPrimaryKeys());
+ modifiedDataObject->addDependency(rs);
+
+ } else {
+ std::map<const commonj::sdo::Property*, commonj::sdo::DataObjectPtr>::iterator singleIt =
+ singleOldValuedProperties.find(&props[i]);
+
+ if (singleIt == singleOldValuedProperties.end() || singleIt->second != dob) {
+ ModifiedDataObject& modDO = processModifiedDataObject(dob);
+ RelationshipStatement& rs = modDO.addFK(getRelationship(*modifiedDataObject, modDO), &modifiedDataObject->getPrimaryKeys());
+ modifiedDataObject->addDependency(rs);
+
+
+ }
+
+ }
+
+ }
+
+ }
+
+ }
+
+ }
+
+ for (std::map<const commonj::sdo::Property*, std::list<commonj::sdo::DataObjectPtr>*>::iterator manyIt = manyOldValuedProperties.begin() ;
+ manyIt != manyOldValuedProperties.end() ; manyIt++) {
+
+ std::list<commonj::sdo::DataObjectPtr>* list = manyIt->second;
+
+ for (std::list<commonj::sdo::DataObjectPtr>::const_iterator listIt = list->begin() ;
+ listIt != list->end() ; listIt++) {
+
+ ModifiedDataObject& modDO = processModifiedDataObject(*listIt);
+ RelationshipStatement& rs = modDO.addFK(getRelationship(*modifiedDataObject, modDO), 0);
+ modDO.addDependency(rs);
+
+ }
+
+ delete list;
+
+ }
+
+ }
+
+ return *modifiedDataObject;
+
+}
+
+void ApplyChanges::addDataObject(DASDataObject& dataObject) {
+ std::list<DASDataObject*>* list;
+ std::string typeName = dataObject.getDataObject()->getType().getName();
+ std::map<std::string, std::list<DASDataObject*>*>::iterator it =
+ dasDataObjects.find(typeName);
+
+ if (it == dasDataObjects.end()) {
+ list = new std::list<DASDataObject*>();
+ dasDataObjects.insert(std::make_pair(typeName, list));
+
+ } else {
+ list = it->second;
+ }
+
+ list->push_back(&dataObject);
+
+}
+
+ };
+ };
+};
Added: incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/Column.cpp
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/Column.cpp?rev=594314&view=auto
==============================================================================
--- incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/Column.cpp (added)
+++ incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/Column.cpp Mon Nov 12 14:02:46 2007
@@ -0,0 +1,114 @@
+/*
+ * 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/Column.h"
+
+namespace apache {
+ namespace das {
+ namespace rdb {
+
+Column::Column(const Column& column) {
+ this->columnName = column.columnName;
+ this->propertyName = column.propertyName;
+ this->sqlType = column.sqlType;
+ this->containerTable = column.containerTable;
+ this->pk = column.pk;
+ managed = column.managed;
+ collision = column.collision;
+
+}
+
+Column::Column(std::string columnName, SQLSMALLINT sqlType) {
+ StringWrapper columnNameWrapper(columnName);
+ columnName = columnNameWrapper.toUpper();
+ managed = true;
+ collision = false;
+
+ if (!columnNameWrapper.isValidRDBName()) {
+ throw DASInvalidColumnNameException("Column name must not contain whitespace characters!");
+ }
+
+ this->columnName = columnName;
+ this->propertyName = columnName;
+ this->sqlType = sqlType;
+ containerTable = 0;
+ pk = false;
+
+}
+
+Column::~Column(void) {}
+
+void Column::setCollision(bool collision) {
+ this->collision = collision;
+}
+
+void Column::setManaged(bool managed) {
+ this->managed = managed;
+}
+
+bool Column::isCollision(void) const {
+ return collision;
+}
+
+bool Column::isManaged(void) const {
+ return managed;
+}
+
+void Column::setContainerTable(Table* containerTable) {
+ this->containerTable = containerTable;
+}
+
+Table* Column::getContainerTable(void) const {
+ return containerTable;
+}
+
+std::string Column::getName(void) const {
+ return columnName;
+}
+
+SQLSMALLINT Column::getSQLType(void) const {
+ return sqlType;
+}
+
+void Column::setPropertyName(std::string propertyName) {
+ StringWrapper propertyNameWrapper(propertyName);
+ propertyName = propertyNameWrapper.toUpper();
+
+ if (!propertyNameWrapper.isValidRDBName()) {
+ throw DASInvalidPropertyNameException("Property name must not contain whitespace characters!");
+ }
+
+ this->propertyName = propertyName;
+
+}
+
+std::string Column::getPropertyName(void) const {
+ return propertyName;
+}
+
+void Column::setPK(bool pk) {
+ this->pk = pk;
+}
+
+bool Column::isPK(void) const {
+ return pk;
+}
+
+ };
+ };
+};
Added: incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ColumnData.cpp
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ColumnData.cpp?rev=594314&view=auto
==============================================================================
--- incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ColumnData.cpp (added)
+++ incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ColumnData.cpp Mon Nov 12 14:02:46 2007
@@ -0,0 +1,849 @@
+/*
+ * 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/ColumnData.h"
+
+namespace apache {
+ namespace das {
+ namespace rdb {
+
+ColumnData::ColumnData(const Column& column, ResultSetPtr resultSet) {
+ this->column = &column;
+
+ if (column.getContainerTable() == 0) {
+ throw std::invalid_argument("Column table not set");
+ }
+
+ /*if (resultSet->isNull(column.getContainerTable()->getTableName(), column.getName())) {
+ data = 0;
+
+ } else {*/
+
+ switch (column.getSQLType()) {
+
+ case SQL_INTEGER :
+ {
+ SQLINTEGER sqlInteger = resultSet->getSQLInteger(
+ column.getContainerTable()->getTableName(), column.getName());
+
+ data = new SQLINTEGER;
+ SQLINTEGER* aux = (SQLINTEGER*) data;
+ *aux = sqlInteger;
+
+ }
+
+ break;
+
+ case SQL_SMALLINT :
+ {
+ SQLSMALLINT sqlSmallInt = resultSet->getSQLSmallInt(
+ column.getContainerTable()->getTableName(), column.getName());
+
+ data = new SQLSMALLINT;
+ SQLSMALLINT* aux = (SQLSMALLINT*) data;
+ *aux = sqlSmallInt;
+
+ }
+
+ break;
+
+ /*case SQL_BIGINT :
+ {
+ SQL_BIGINT sqlInteger = resultSet->getSQLInteger(
+ column.getContainerTable()->getTableName(), column.getName());
+
+ data = new SQL_BIGINT;
+ SQL_BIGINT* aux = (SQL_BIGINT*) data;
+ *aux = sqlInteger;
+
+ }
+
+ break;*/
+
+ case SQL_CHAR :
+ {
+ SQLCHAR sqlChar = resultSet->getSQLChar(column.getContainerTable()->getTableName(),
+ column.getName());
+
+ data = new SQLCHAR;
+ SQLCHAR* aux = (SQLCHAR*) data;
+ *aux= sqlChar;
+ }
+
+ break;
+
+ case SQL_WCHAR :
+ {
+ SQLWCHAR sqlWChar = resultSet->getSQLWChar(column.getContainerTable()->getTableName(),
+ column.getName());
+
+ data = new SQLWCHAR;
+ SQLWCHAR* aux = (SQLWCHAR*) data;
+ *aux= sqlWChar;
+ }
+
+ break;
+
+ case SQL_DOUBLE :
+ {
+ SQLDOUBLE sqlDouble = resultSet->getSQLDouble(column.getContainerTable()->getTableName(),
+ column.getName());
+
+ data = new SQLDOUBLE;
+ SQLDOUBLE* aux = (SQLDOUBLE*) data;
+ *aux = sqlDouble;
+ }
+
+ break;
+
+ case SQL_FLOAT :
+ {
+ SQLFLOAT sqlFloat = resultSet->getSQLFloat(column.getContainerTable()->getTableName(),
+ column.getName());
+
+ data = new SQLFLOAT;
+ SQLFLOAT* aux = (SQLFLOAT*) data;
+ *aux = sqlFloat;
+ }
+
+ break;
+
+ case SQL_REAL :
+ {
+ SQLREAL sqlReal = resultSet->getSQLReal(column.getContainerTable()->getTableName(),
+ column.getName());
+
+ data = new SQLREAL;
+ SQLREAL* aux = (SQLREAL*) data;
+ *aux = sqlReal;
+ }
+
+ break;
+
+ case SQL_VARCHAR :
+ {
+ std::string varchar = resultSet->getSQLVarchar(column.getContainerTable()->getTableName(),
+ column.getName());
+
+ data = new std::string(varchar.begin(), varchar.end());
+ std::string* aux = (std::string*) data;
+ (*aux).assign(varchar.begin(), varchar.end());
+ }
+
+ break;
+
+ case SQL_WVARCHAR :
+ {
+ std::wstring wvarchar = resultSet->getSQLWVarchar(column.getContainerTable()->getTableName(),
+ column.getName());
+
+ std::wstring* aux = new std::wstring();
+ *aux = wvarchar;
+ data = aux;
+
+ }
+
+ break;
+
+ default :
+ throw DASInvalidSQLTypeException();
+
+ }
+
+ //}
+
+}
+
+ColumnData::ColumnData(const Column& column, const commonj::sdo::Setting& setting) {
+ this->column = &column;
+
+ if (column.getContainerTable() == 0) {
+ throw std::invalid_argument("Column table not set");
+ }
+
+ if (!setting.isSet() || setting.isNull()) {
+ data = 0;
+ } else {
+
+ switch (column.getSQLType()) {
+
+ case SQL_INTEGER :
+ {
+ SQLINTEGER sqlInteger = setting.getIntValue();
+
+ data = new SQLINTEGER;
+ SQLINTEGER* aux = (SQLINTEGER*) data;
+ *aux = sqlInteger;
+
+ }
+
+ break;
+
+ case SQL_SMALLINT :
+ {
+ SQLSMALLINT sqlSmallInt = setting.getIntValue();
+
+ data = new SQLSMALLINT;
+ SQLSMALLINT* aux = (SQLSMALLINT*) data;
+ *aux = sqlSmallInt;
+
+ }
+
+ break;
+
+ case SQL_CHAR :
+ {
+ SQLCHAR sqlChar = setting.getCharacterValue();
+
+ data = new SQLCHAR;
+ SQLCHAR* aux = (SQLCHAR*) data;
+ *aux= sqlChar;
+ }
+
+ break;
+
+ case SQL_WCHAR :
+ {
+ SQLWCHAR sqlWChar = setting.getCharacterValue();
+
+ data = new SQLWCHAR;
+ SQLWCHAR* aux = (SQLWCHAR*) data;
+ *aux= sqlWChar;
+ }
+
+ break;
+
+ case SQL_DOUBLE :
+ {
+ SQLDOUBLE sqlDouble = setting.getDoubleValue();
+
+ data = new SQLDOUBLE;
+ SQLDOUBLE* aux = (SQLDOUBLE*) data;
+ *aux = sqlDouble;
+ }
+
+ break;
+
+ case SQL_FLOAT :
+ {
+ SQLFLOAT sqlFloat = setting.getDoubleValue();
+
+ data = new SQLFLOAT;
+ SQLFLOAT* aux = (SQLFLOAT*) data;
+ *aux = sqlFloat;
+ }
+
+ break;
+
+ case SQL_REAL :
+ {
+ SQLREAL sqlReal = setting.getFloatValue();
+
+ data = new SQLREAL;
+ SQLREAL* aux = (SQLREAL*) data;
+ *aux = sqlReal;
+ }
+
+ break;
+
+ case SQL_VARCHAR :
+ {
+ unsigned int length = setting.getLength();
+ wchar_t* buffer = new wchar_t[length];
+ setting.getStringValue(buffer, length);
+ //buffer[length] = 0;
+
+ std::wstring wstr(buffer, 0, length);
+ std::string* str = new std::string(wstr.begin(), wstr.end());
+ str->assign(wstr.begin(), wstr.end());
+
+ data = str;
+
+ delete [] buffer;
+
+ }
+
+ break;
+
+ case SQL_WVARCHAR :
+ {
+ unsigned int length = setting.getLength();
+ wchar_t* buffer = new wchar_t[length];
+ setting.getStringValue(buffer, length);
+ //buffer[length] = 0;
+
+ data = new std::wstring(buffer, 0, length);
+
+ delete [] buffer;
+
+ }
+
+ break;
+
+ default :
+ throw DASInvalidSQLTypeException();
+
+ }
+
+ }
+
+}
+
+ColumnData::ColumnData(const Column& column, commonj::sdo::DataObjectPtr dataObject) {
+ this->column = &column;
+
+ if (column.getContainerTable() == 0) {
+ throw std::invalid_argument("Column table not set");
+ }
+
+ if (!dataObject->isSet(column.getPropertyName().c_str()) || dataObject->isNull(column.getPropertyName().c_str())) {
+ data = 0;
+
+ } else {
+
+ switch (column.getSQLType()) {
+
+ case SQL_INTEGER :
+ {
+ SQLINTEGER sqlInteger = dataObject->getInt(column.getPropertyName().c_str());
+
+ data = new SQLINTEGER;
+ SQLINTEGER* aux = (SQLINTEGER*) data;
+ *aux = sqlInteger;
+
+ }
+
+ break;
+
+ case SQL_SMALLINT :
+ {
+ SQLSMALLINT sqlSmallInt = dataObject->getInt(column.getPropertyName().c_str());
+
+ data = new SQLSMALLINT;
+ SQLSMALLINT* aux = (SQLSMALLINT*) data;
+ *aux = sqlSmallInt;
+
+ }
+
+ break;
+
+ case SQL_CHAR :
+ {
+ SQLCHAR sqlChar = dataObject->getCharacter(column.getPropertyName().c_str());
+
+ data = new SQLCHAR;
+ SQLCHAR* aux = (SQLCHAR*) data;
+ *aux= sqlChar;
+ }
+
+ break;
+
+ case SQL_WCHAR :
+ {
+ SQLWCHAR sqlWChar = dataObject->getCharacter(column.getPropertyName().c_str());
+
+ data = new SQLWCHAR;
+ SQLWCHAR* aux = (SQLWCHAR*) data;
+ *aux= sqlWChar;
+ }
+
+ break;
+
+ case SQL_DOUBLE :
+ {
+ SQLDOUBLE sqlDouble = dataObject->getDouble(column.getPropertyName().c_str());
+
+ data = new SQLDOUBLE;
+ SQLDOUBLE* aux = (SQLDOUBLE*) data;
+ *aux = sqlDouble;
+ }
+
+ break;
+
+ case SQL_FLOAT :
+ {
+ SQLFLOAT sqlFloat = dataObject->getDouble(column.getPropertyName().c_str());
+
+ data = new SQLFLOAT;
+ SQLFLOAT* aux = (SQLFLOAT*) data;
+ *aux = sqlFloat;
+ }
+
+ break;
+
+ case SQL_REAL :
+ {
+ SQLREAL sqlReal = dataObject->getFloat(column.getPropertyName().c_str());
+
+ data = new SQLREAL;
+ SQLREAL* aux = (SQLREAL*) data;
+ *aux = sqlReal;
+ }
+
+ break;
+
+ case SQL_VARCHAR :
+ {
+ unsigned int length = dataObject->getLength(column.getPropertyName().c_str());
+ wchar_t* buffer = new wchar_t[length];
+ dataObject->getString(column.getPropertyName().c_str(), buffer, length);
+
+ std::wstring wstr(buffer, 0, length);
+ std::string* str = new std::string(wstr.begin(), wstr.end());
+ str->assign(wstr.begin(), wstr.end());
+
+ data = str;
+
+ delete [] buffer;
+
+ }
+
+ break;
+
+ case SQL_WVARCHAR :
+ {
+ unsigned int length = dataObject->getLength(column.getPropertyName().c_str());
+ wchar_t* buffer = new wchar_t[length];
+ dataObject->getString(column.getPropertyName().c_str(), buffer, length);
+
+ data = new std::wstring(buffer, 0, length);
+
+ delete [] buffer;
+
+ }
+
+ break;
+
+ default :
+ throw DASInvalidSQLTypeException();
+
+ }
+
+ }
+
+}
+
+ColumnData::~ColumnData(void) {
+ delete data;
+}
+
+std::string ColumnData::toSQL(void) const {
+
+ if (data == 0) {
+ return "NULL";
+ } else {
+
+ switch (column->getSQLType()) {
+
+ case SQL_INTEGER :
+ return StringWrapper::toString(*((SQLINTEGER*) data));
+
+ case SQL_SMALLINT :
+ return StringWrapper::toString(*((SQLSMALLINT*) data));
+
+ case SQL_CHAR :
+ return '\'' + StringWrapper::toString(*((SQLCHAR*) data)) + '\'';
+
+ case SQL_WCHAR :
+ return '\'' + StringWrapper::toString(*((SQLWCHAR*) data)) + '\'';
+
+ case SQL_DOUBLE :
+ return StringWrapper::toString(*((SQLDOUBLE*) data));
+
+ case SQL_FLOAT :
+ return StringWrapper::toString(*((SQLFLOAT*) data));
+
+ case SQL_REAL :
+ return StringWrapper::toString(*((SQLREAL*) data));
+
+ case SQL_VARCHAR :
+ {
+ std::string str = *((std::string*) data);
+ return '\'' + str + '\'';
+
+ }
+
+ case SQL_WVARCHAR :
+ {
+ std::wstring wstr = *((std::wstring*) data);
+ std::string str(wstr.begin(), wstr.end());
+ str.assign(wstr.begin(), wstr.end());
+ return '\'' + str + '\'';
+
+ }
+
+ default :
+ throw DASInvalidSQLTypeException();
+
+ }
+
+ }
+
+}
+
+void ColumnData::populateDataGraph(TableData& tableData) const {
+ try {
+ tableData.getGraphObject()->getType().getPropertyIndex(column->getPropertyName().c_str());
+
+ } catch (commonj::sdo::SDOPropertyNotFoundException&) {
+ return;
+ }
+
+ if (data == 0) {
+ tableData.getGraphObject()->setNull(column->getPropertyName().c_str());
+
+ } else {
+
+ switch (column->getSQLType()) {
+
+ case SQL_INTEGER :
+ tableData.getGraphObject()->setInt(column->getPropertyName().c_str(), (long) *((SQLINTEGER*) data));
+
+ break;
+
+ case SQL_SMALLINT :
+ tableData.getGraphObject()->setInt(column->getPropertyName().c_str(), (long) *((SQLSMALLINT*) data));
+
+ break;
+
+ case SQL_CHAR :
+ tableData.getGraphObject()->setCharacter(column->getPropertyName().c_str(), (wchar_t) *((SQLCHAR*) data));
+
+ break;
+
+ case SQL_WCHAR :
+ tableData.getGraphObject()->setCharacter(column->getPropertyName().c_str(), (wchar_t) *((SQLWCHAR*) data));
+
+ break;
+
+ case SQL_FLOAT :
+ tableData.getGraphObject()->setDouble(column->getPropertyName().c_str(), (long double) *((SQLFLOAT*) data));
+
+ case SQL_DOUBLE :
+ tableData.getGraphObject()->setDouble(column->getPropertyName().c_str(), (long double) *((SQLDOUBLE*) data));
+
+ break;
+
+ case SQL_REAL :
+ tableData.getGraphObject()->setFloat(column->getPropertyName().c_str(), (float) *((SQLREAL*) data));
+
+ break;
+
+ case SQL_VARCHAR :
+ {
+ std::string* varchar = (std::string*) data;
+ std::wstring wstr(varchar->begin(), varchar->end());
+ wstr.assign(varchar->begin(), varchar->end());
+
+ tableData.getGraphObject()->setString(column->getPropertyName().c_str(),
+ wstr.c_str(), wstr.size());
+ }
+
+ break;
+
+ case SQL_WVARCHAR :
+ {
+ std::wstring* wvarchar = (std::wstring*) data;
+
+ tableData.getGraphObject()->setString(column->getPropertyName().c_str(),
+ (*wvarchar).c_str(), (*wvarchar).size());
+ }
+
+ break;
+
+ default :
+ throw DASInvalidSQLTypeException();
+
+ }
+
+ }
+
+}
+
+bool ColumnData::operator==(const ColumnData& columnData) const {
+
+ if (column->getSQLType() != columnData.column->getSQLType()) {
+ throw DASInvalidSQLTypeException("Different sql types!");
+ }
+
+ if (data == 0) {
+ return false;
+ }
+
+ switch (column->getSQLType()) {
+
+ case SQL_INTEGER :
+
+ if (*((SQLINTEGER*) columnData.data) == *((SQLINTEGER*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_SMALLINT :
+
+ if (*((SQLSMALLINT*) columnData.data) == *((SQLSMALLINT*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_CHAR :
+
+ if (*((SQLCHAR*) columnData.data) == *((SQLCHAR*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_WCHAR :
+
+ if (*((SQLWCHAR*) columnData.data) == *((SQLWCHAR*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_DOUBLE :
+ if (*((SQLDOUBLE*) columnData.data) == *((SQLDOUBLE*) data)) {
+ return true;
+ }
+
+ case SQL_FLOAT :
+ if (*((SQLFLOAT*) columnData.data) == *((SQLFLOAT*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_REAL :
+
+ if (*((SQLREAL*) columnData.data) == *((SQLREAL*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_VARCHAR :
+ if (*((std::string*) columnData.data) == *((std::string*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_WVARCHAR :
+ if (*((std::wstring*) columnData.data) == *((std::wstring*) data)) {
+ return true;
+ }
+
+ break;
+
+ default :
+ throw DASInvalidSQLTypeException();
+
+ }
+
+ return false;
+
+}
+
+bool ColumnData::operator!=(const ColumnData& columnData) const {
+ return !(*this == columnData);
+}
+
+const Column& ColumnData::getColumn(void) const {
+ return *column;
+}
+
+bool ColumnData::operator<(const ColumnData& columnData) const {
+
+ if (column->getSQLType() != columnData.column->getSQLType()) {
+ throw DASInvalidSQLTypeException("Different sql types!");
+ }
+
+ if (data == 0) {
+ return false;
+ }
+
+ switch (column->getSQLType()) {
+
+ case SQL_SMALLINT :
+
+ if (*((SQLSMALLINT*) columnData.data) > *((SQLSMALLINT*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_INTEGER :
+
+ if (*((SQLINTEGER*) columnData.data) > *((SQLINTEGER*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_CHAR :
+
+ if (*((SQLCHAR*) columnData.data) > *((SQLCHAR*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_WCHAR :
+
+ if (*((SQLWCHAR*) columnData.data) > *((SQLWCHAR*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_DOUBLE :
+ if (*((SQLDOUBLE*) columnData.data) > *((SQLDOUBLE*) data)) {
+ return true;
+ }
+
+ case SQL_FLOAT :
+ if (*((SQLFLOAT*) columnData.data) > *((SQLFLOAT*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_REAL :
+
+ if (*((SQLREAL*) columnData.data) > *((SQLREAL*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_VARCHAR :
+ if (*((std::string*) columnData.data) > *((std::string*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_WVARCHAR :
+ if (*((std::wstring*) columnData.data) > *((std::wstring*) data)) {
+ return true;
+ }
+
+ break;
+
+ default :
+ throw DASInvalidSQLTypeException();
+
+ }
+
+ return false;
+
+}
+
+bool ColumnData::operator>(const ColumnData& columnData) const {
+
+ if (column->getSQLType() != columnData.column->getSQLType()) {
+ throw DASInvalidSQLTypeException("Different sql types!");
+ }
+
+ if (data == 0) {
+ return false;
+ }
+
+ switch (column->getSQLType()) {
+
+ case SQL_INTEGER :
+
+ if (*((SQLINTEGER*) columnData.data) < *((SQLINTEGER*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_SMALLINT :
+
+ if (*((SQLSMALLINT*) columnData.data) < *((SQLSMALLINT*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_CHAR :
+
+ if (*((SQLCHAR*) columnData.data) < *((SQLCHAR*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_WCHAR :
+
+ if (*((SQLWCHAR*) columnData.data) < *((SQLWCHAR*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_DOUBLE :
+ if (*((SQLDOUBLE*) columnData.data) < *((SQLDOUBLE*) data)) {
+ return true;
+ }
+
+ case SQL_FLOAT :
+ if (*((SQLFLOAT*) columnData.data) < *((SQLFLOAT*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_REAL :
+
+ if (*((SQLREAL*) columnData.data) < *((SQLREAL*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_VARCHAR :
+ if (*((std::string*) columnData.data) < *((std::string*) data)) {
+ return true;
+ }
+
+ break;
+
+ case SQL_WVARCHAR :
+ if (*((std::wstring*) columnData.data) < *((std::wstring*) data)) {
+ return true;
+ }
+
+ break;
+
+ default :
+ throw DASInvalidSQLTypeException();
+
+ }
+
+ return false;
+
+}
+
+ };
+ };
+};
Added: incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/CommandImpl.cpp
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/CommandImpl.cpp?rev=594314&view=auto
==============================================================================
--- incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/CommandImpl.cpp (added)
+++ incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/CommandImpl.cpp Mon Nov 12 14:02:46 2007
@@ -0,0 +1,67 @@
+/*
+ * 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/CommandImpl.h"
+#include "apache/das/rdb/DASImpl.h"
+
+namespace apache {
+ namespace das {
+ namespace rdb {
+
+CommandImpl::CommandImpl(DASImpl& das, std::string sqlString) {
+ this->das = &das;
+ statement = das.getConnection()->createStatement();
+ sql = sqlString;
+
+ //statement = new Statement();
+
+ //try {
+ /*URL url = getClass().getResource("/xml/sdoJava.xsd");
+ if (url == null) {
+ //throw new RuntimeException("Could not find resource: xml/sdoJava.xsd");
+ }
+
+ InputStream inputStream = url.openStream();
+ XSDHelper.INSTANCE.define(inputStream, url.toString());
+ inputStream.close();*/
+ //} catch (IOException ex) {
+ // throw new RuntimeException(ex);
+ //}
+
+}
+
+CommandImpl::~CommandImpl() {}
+
+DASImpl& CommandImpl::getDAS(void) {
+ return *das;
+}
+
+commonj::sdo::DataObjectPtr CommandImpl::executeQuery(void) {
+ statement->executeQuery(sql);
+
+ return commonj::sdo::DataObjectPtr(0);
+
+}
+
+void CommandImpl::close(void) {
+ statement->close();
+}
+
+ };
+ };
+};
Added: incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ConfigImpl.cpp
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ConfigImpl.cpp?rev=594314&view=auto
==============================================================================
--- incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ConfigImpl.cpp (added)
+++ incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/ConfigImpl.cpp Mon Nov 12 14:02:46 2007
@@ -0,0 +1,334 @@
+/*
+ * 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/ConfigImpl.h"
+
+namespace apache {
+ namespace das {
+ namespace rdb {
+
+ConfigImpl::ConfigImpl(void) {
+ relationships = new std::map<std::string, const Relationship*>();
+ tables = new std::map<std::string, const Table*>();
+ commands = new std::map<std::string, std::string>();
+
+ convOverConfig = false;
+
+}
+
+ConfigImpl::ConfigImpl(const Config& config) : Config(config) {
+ ConfigImpl& thisConfig = (ConfigImpl&) config;
+ tables = new std::map<std::string, const Table*>();
+ relationships = new std::map<std::string, const Relationship*>();
+ commands = new std::map<std::string, std::string>(*thisConfig.commands);
+
+ std::map<std::string, const Table*>::iterator tableIterator;
+ std::map<std::string, const Relationship*>::iterator relationshipIterator;
+ std::map<std::string, std::string>::iterator commandIterator;
+
+ this->convOverConfig = thisConfig.convOverConfig;
+
+ for (tableIterator = thisConfig.tables->begin() ; tableIterator != thisConfig.tables->end() ;
+ tableIterator++) {
+
+ tables->insert(std::make_pair(tableIterator->first, new Table(*tableIterator->second)));
+
+ }
+
+ for (relationshipIterator = thisConfig.relationships->begin() ;
+ relationshipIterator != thisConfig.relationships->end() ; relationshipIterator++) {
+
+ relationships->insert(std::make_pair(relationshipIterator->first,
+ new Relationship(*relationshipIterator->second)));
+
+ }
+
+}
+
+ConfigImpl::ConfigImpl(std::string xmlFile) {
+ relationships = new std::map<std::string, const Relationship*>();
+ tables = new std::map<std::string, const Table*>();
+ commands = new std::map<std::string, std::string>();
+
+ convOverConfig = false;
+
+ commonj::sdo::DataFactoryPtr dataFactory = commonj::sdo::DataFactory::getDataFactory();
+ dataFactory->addType(DAS_NAMESPACE, "RootType");
+ dataFactory->addType(DAS_NAMESPACE, "Table");
+ dataFactory->addType(DAS_NAMESPACE, "Relationship");
+ dataFactory->addType(DAS_NAMESPACE, "KeyPair");
+ dataFactory->addType(DAS_NAMESPACE, "Column");
+ dataFactory->addType(DAS_NAMESPACE, "Config");
+ dataFactory->addType(DAS_NAMESPACE, "Command");
+
+ const commonj::sdo::Type& rootType = dataFactory->getType(DAS_NAMESPACE, "RootType");
+ const commonj::sdo::Type& table = dataFactory->getType(DAS_NAMESPACE, "Table");
+ const commonj::sdo::Type& relationship = dataFactory->getType(DAS_NAMESPACE, "Relationship");
+ const commonj::sdo::Type& keyPair = dataFactory->getType(DAS_NAMESPACE, "KeyPair");
+ const commonj::sdo::Type& column = dataFactory->getType(DAS_NAMESPACE, "Column");
+ const commonj::sdo::Type& config = dataFactory->getType(DAS_NAMESPACE, "Config");
+ const commonj::sdo::Type& command = dataFactory->getType(DAS_NAMESPACE, "Command");
+
+ dataFactory->addPropertyToType(rootType, "Config", config);
+
+ dataFactory->addPropertyToType(table, "Column", column, true, false, true);
+ dataFactory->addPropertyToType(table, "tableName", SDO_NAMESPACE, "String", false, false, true);
+ dataFactory->addPropertyToType(table, "typeName", SDO_NAMESPACE, "String", false, false, true);
+
+ dataFactory->addPropertyToType(config, "Table", table, true, false, true);
+ dataFactory->addPropertyToType(config, "Relationship", relationship, true, false, true);
+ dataFactory->addPropertyToType(config, "Command", command, true, false, true);
+ dataFactory->addPropertyToType(config, "uri", SDO_NAMESPACE, "String", false, false, true);
+ dataFactory->setDefault(SDO_NAMESPACE, "String", "uri", "");
+
+ dataFactory->addPropertyToType(command, "name", SDO_NAMESPACE, "String", false, false, true);
+ dataFactory->addPropertyToType(command, "SQL", SDO_NAMESPACE, "String", false, false, true);
+
+ dataFactory->addPropertyToType(relationship, "KeyPair", keyPair, true, false, true);
+ dataFactory->addPropertyToType(relationship, "name", SDO_NAMESPACE, "String", false, false, true);
+ dataFactory->addPropertyToType(relationship, "primaryKeyTable", SDO_NAMESPACE, "String", false, false, true);
+ dataFactory->addPropertyToType(relationship, "foreignKeyTable", SDO_NAMESPACE, "String", false, false, true);
+ dataFactory->addPropertyToType(relationship, "many", SDO_NAMESPACE, "Boolean", false, false, true);
+ dataFactory->setDefault(relationship, "many", true);
+
+ dataFactory->addPropertyToType(keyPair, "primaryKeyColumn", SDO_NAMESPACE, "String", false, false, true);
+ dataFactory->addPropertyToType(keyPair, "foreignKeyColumn", SDO_NAMESPACE, "String", false, false, true);
+
+ dataFactory->addPropertyToType(column, "columnName", SDO_NAMESPACE, "String", false, false, true);
+ dataFactory->addPropertyToType(column, "sqlType", SDO_NAMESPACE, "String", false, false, true);
+ dataFactory->addPropertyToType(column, "propertyName", SDO_NAMESPACE, "String", false, false, true);
+ dataFactory->addPropertyToType(column, "primaryKey", SDO_NAMESPACE, "Boolean", false, false, true);
+ dataFactory->addPropertyToType(column, "primaryKey", SDO_NAMESPACE, "Boolean", false, false, true);
+ dataFactory->addPropertyToType(column, "collision", SDO_NAMESPACE, "Boolean", false, false, true);
+ dataFactory->addPropertyToType(column, "managed", SDO_NAMESPACE, "Boolean", false, false, true);
+ dataFactory->setDefault(column, "primaryKey", false);
+ dataFactory->setDefault(column, "collision", false);
+ dataFactory->setDefault(column, "managed", true);
+
+ dataFactory->resolve();
+
+ commonj::sdo::XMLHelperPtr xmlh = commonj::sdo::HelperProvider::getXMLHelper(dataFactory);
+ commonj::sdo::XMLDocumentPtr doc = xmlh->loadFile(xmlFile.c_str(), DAS_NAMESPACE);
+ commonj::sdo::DataObjectPtr root = doc->getRootDataObject();
+
+ commonj::sdo::DataObjectList& tableList = root->getList("Table");
+
+ for (unsigned int i = 0 ; i < tableList.size() ; i++) {
+ std::string tableName = SDODataObjectWrapper(tableList[i]).getString("tableName");
+
+ if (tableName != "") {
+ Table& table = addTable(tableName);
+ std::string typeName = SDODataObjectWrapper(tableList[i]).getString("typeName");
+
+ if (typeName != "") {
+ table.setTypeName(typeName);
+ }
+
+ commonj::sdo::DataObjectList& columnList = tableList[i]->getList("Column");
+
+ for (unsigned int j = 0 ; j < columnList.size() ; j++) {
+ std::string columnName = SDODataObjectWrapper(columnList[j]).getString("columnName");
+ std::string sqlType = SDODataObjectWrapper(columnList[j]).getString("sqlType");
+
+ if (columnName != "" && sqlType != "") {
+ Column& column = table.addColumn(columnName, ODBCTypeHelper::getSQLType(sqlType));
+ std::string propertyName = SDODataObjectWrapper(columnList[j]).getString("propertyName");
+
+ if (propertyName != "") {
+ column.setPropertyName(propertyName);
+ }
+
+ column.setPK(columnList[j]->getBoolean("primaryKey"));
+ column.setManaged(columnList[j]->getBoolean("managed"));
+ column.setCollision(columnList[j]->getBoolean("collision"));
+
+ }
+
+
+ }
+
+ }
+
+ }
+
+ commonj::sdo::DataObjectList& relationshipList = root->getList("Relationship");
+
+ for (unsigned int i = 0 ; i < relationshipList.size() ; i++) {
+ std::string primaryKeyTable = SDODataObjectWrapper(relationshipList[i]).getString("primaryKeyTable");
+ std::string foreignKeyTable = SDODataObjectWrapper(relationshipList[i]).getString("foreignKeyTable");
+ std::string name = SDODataObjectWrapper(relationshipList[i]).getString("name");;
+
+ Relationship& relationship = addRelationship(primaryKeyTable, foreignKeyTable);
+ relationship.setMany(relationshipList[i]->getBoolean("many"));
+
+ commonj::sdo::DataObjectList& keyPairList = relationshipList[i]->getList("KeyPair");
+
+ for (unsigned int i = 0 ; i < keyPairList.size() ; i++) {
+ std::string primaryKeyColumn = SDODataObjectWrapper(keyPairList[i]).getString("primaryKeyColumn");
+ std::string foreignKeyColumn = SDODataObjectWrapper(keyPairList[i]).getString("foreignKeyColumn");
+ relationship.addKeyPair(primaryKeyColumn, foreignKeyColumn);
+
+ }
+
+ }
+
+ commonj::sdo::DataObjectList& commandList = root->getList("Command");
+
+ for (unsigned int i = 0 ; i < commandList.size() ; i++) {
+ std::string name = SDODataObjectWrapper(commandList[i]).getString("name");
+ std::string sql = SDODataObjectWrapper(commandList[i]).getString("SQL");
+
+ commands->insert(std::make_pair(name, sql));
+
+ }
+
+ setURI(StringWrapper(root, "uri").getString());
+
+}
+
+ConfigImpl::~ConfigImpl(void) {
+ std::map<std::string, const Table*>::const_iterator tableIterator;
+ std::map<std::string, const Relationship*>::const_iterator relationshipIterator;
+
+ tableIterator = tables->begin();
+ for ( ; tableIterator != tables->end() ;
+ tableIterator++) {
+ delete tableIterator->second;
+ }
+
+ for (relationshipIterator = relationships->begin() ;
+ relationshipIterator != relationships->end() ; relationshipIterator++) {
+ delete relationshipIterator->second;
+ }
+
+ delete relationships;
+ delete tables;
+ delete commands;
+
+}
+
+std::string ConfigImpl::getCommand(std::string commandName) const {
+ std::map<std::string, std::string>::const_iterator it = commands->find(commandName);
+
+ if (it == commands->end()) {
+ throw DASCommandNotFoundException();
+ }
+
+ return it->second;
+
+}
+
+const Table* ConfigImpl::getTableByTypeName(std::string typeName) const {
+ std::map<std::string, const Table*>::const_iterator it;
+
+ for (it = tables->begin() ;
+ it != tables->end() ; it++) {
+
+ if (it->second->getTypeName() == typeName) {
+ return it->second;
+ }
+
+ }
+
+ return 0;
+
+}
+
+Table& ConfigImpl::addTable(std::string tableName) {
+ return newTable(*(new Table(tableName)));
+}
+
+Table& ConfigImpl::addTable(const Table& table) {
+ return newTable(*(new Table(table)));
+}
+
+Table& ConfigImpl::newTable(Table& table) {
+ std::string tableName = table.getTableName();
+ std::map<std::string, const Table*>::iterator tableIterator = tables->find(tableName);
+
+ if (tableIterator == tables->end()) {
+ tables->insert(std::make_pair(tableName, &table));
+
+ return table;
+
+ }
+
+ return (Table&) *tableIterator->second;
+
+}
+
+const std::map<std::string, Relationship*>& ConfigImpl::getRelationships(void) const {
+ return (const std::map<std::string, Relationship*>&) *relationships;
+}
+
+Relationship& ConfigImpl::addRelationship(std::string pkTableName, std::string fkTableName, std::string name) {
+ return newRelationship(*(new Relationship(pkTableName, fkTableName, name)));
+}
+
+Relationship& ConfigImpl::addRelationship(const Relationship& relationship) {
+ return newRelationship(*(new Relationship(relationship)));
+}
+
+Relationship& ConfigImpl::newRelationship(Relationship& relationship) {
+ std::string pkXfk = relationship.getPKTableName() + "." + relationship.getFKTableName();
+ std::map<std::string, const Relationship*>::iterator it = relationships->find(pkXfk);
+
+ if (it == relationships->end()) {
+ relationships->insert(std::make_pair(pkXfk, &relationship));
+
+ return relationship;
+
+ }
+
+ return (Relationship&) *it->second;
+
+}
+
+const Relationship* ConfigImpl::getRelationship(std::string pkTableName, std::string fkTableName) const {
+ std::map<std::string, const Relationship*>::iterator it = relationships->find(pkTableName + "." + fkTableName);
+
+ if (it == relationships->end()) {
+ return 0;
+ }
+
+ return it->second;
+
+}
+
+const std::map<std::string, Table*>& ConfigImpl::getTables(void) const {
+ return (const std::map<std::string, Table*>&) *tables;
+}
+
+bool ConfigImpl::isConvOverConfig(void) const {
+ return convOverConfig;
+}
+
+const Table* ConfigImpl::getTable(std::string tableName) const {
+ std::map<std::string, const Table*>::iterator tableIterator = tables->find(tableName);
+
+ if (tableIterator == tables->end()) {
+ return 0;
+ }
+
+ return tableIterator->second;
+
+}
+
+ };
+ };
+};
Added: incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/Connection.cpp
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/Connection.cpp?rev=594314&view=auto
==============================================================================
--- incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/Connection.cpp (added)
+++ incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/Connection.cpp Mon Nov 12 14:02:46 2007
@@ -0,0 +1,214 @@
+/*
+ * 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/Connection.h"
+
+namespace apache {
+ namespace das {
+ namespace rdb {
+
+Connection::Connection(string dsn, string user, string password) {
+ SQLRETURN result;
+
+ SQLINTEGER error;
+ SQLCHAR sqlStat;
+ SQLCHAR * message = 0;
+ SQLSMALLINT messageLength;
+
+ //Alloc environment handle
+ result = SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&environment);
+
+ if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
+ throw SQLException(result, "Error to alloc the environment handle - SQLHENV");
+
+ //Set the environment
+ result = SQLSetEnvAttr(environment, SQL_ATTR_ODBC_VERSION,(void*)SQL_OV_ODBC3, 0);
+
+ if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)){
+ SQLFreeHandle(SQL_HANDLE_ENV, environment);
+ throw SQLException(result, "Error to set the environment handle - SQLHENV");
+ }
+
+ //Allocate connection handle
+ result = SQLAllocHandle(SQL_HANDLE_DBC, environment, &connection);
+
+ if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)){
+ SQLFreeHandle(SQL_HANDLE_ENV, environment);
+ throw SQLException(result, "Error to alloc the connection handle - SQLHDBC");
+ }
+
+ setAutoCommit(false);
+
+ //Connect to the datasource
+ result = SQLConnect(connection, reinterpret_cast<SQLCHAR *>(const_cast<char *> (dsn.c_str())), SQL_NTS,
+ reinterpret_cast<SQLCHAR *>(const_cast<char *> (user.c_str())), SQL_NTS,
+ reinterpret_cast<SQLCHAR *>(const_cast<char *> (password.c_str())), SQL_NTS);
+
+ if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)){
+
+ SQLGetDiagRec(SQL_HANDLE_DBC, connection,1,
+ &sqlStat, &error,message,100,&messageLength);
+
+ SQLFreeHandle(SQL_HANDLE_DBC, connection);
+ SQLFreeHandle(SQL_HANDLE_ENV, environment);
+
+ string error("Error to establish the connection.\nSQLSTATE: ");
+ error += reinterpret_cast<char*>(&sqlStat);
+ throw SQLException(result, error);
+ }
+
+}
+
+Connection::Connection(string connectString) {
+ SQLRETURN result;
+
+ SQLINTEGER error;
+ SQLCHAR sqlStat;
+ SQLCHAR * message = 0;
+ SQLSMALLINT messageLength;
+ SQLCHAR outConnectString[1024];
+
+ //Alloc environment handle
+ result = SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&environment);
+
+ if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
+ throw SQLException(result, "Error to alloc the environment handle - SQLHENV");
+
+ //Set the environment
+ result = SQLSetEnvAttr(environment, SQL_ATTR_ODBC_VERSION,(void*)SQL_OV_ODBC3, 0);
+
+ if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)){
+ SQLFreeHandle(SQL_HANDLE_ENV, environment);
+ throw SQLException(result, "Error to set the environment handle - SQLHENV");
+ }
+
+ //Allocate connection handle
+ result = SQLAllocHandle(SQL_HANDLE_DBC, environment, &connection);
+
+ if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)){
+ SQLFreeHandle(SQL_HANDLE_ENV, environment);
+ throw SQLException(result, "Error to alloc the connection handle - SQLHDBC");
+ }
+
+ setAutoCommit(false);
+
+ //Connect to the datasource
+ result = SQLDriverConnect( connection, 0, (SQLCHAR*) (char*) connectString.c_str(), SQL_NTS,
+ (SQLCHAR*)outConnectString, sizeof(outConnectString),
+ &messageLength, SQL_DRIVER_COMPLETE );
+
+ if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)){
+
+ SQLGetDiagRec(SQL_HANDLE_DBC, connection,1,
+ &sqlStat, &error,message,100,&messageLength);
+
+ SQLFreeHandle(SQL_HANDLE_DBC, connection);
+ SQLFreeHandle(SQL_HANDLE_ENV, environment);
+
+ string outC = (char*) outConnectString;
+
+ string error("Error to establish the connection.\nSQLSTATE: ");
+ error += reinterpret_cast<char*>(&sqlStat);
+ throw SQLException(result, error);
+ }
+
+}
+
+Connection::~Connection(void){
+ std::list<StatementPtr*>::iterator it;
+
+ for (it = statements.begin() ; it != statements.end() ; it++) {
+
+ if (**it) {
+ delete **it;
+ delete *it;
+
+ }
+
+ }
+
+ SQLDisconnect(connection);
+ SQLFreeHandle(SQL_HANDLE_DBC,connection);
+ SQLFreeHandle(SQL_HANDLE_ENV, environment);
+
+}
+
+SQLHDBC Connection::getODBCConnection(void) const{
+ return connection;
+}
+
+void Connection::commit(void){
+ SQLRETURN result = SQLEndTran(SQL_HANDLE_DBC, connection, SQL_COMMIT);
+
+ if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)){
+ throw SQLException(result, "Commit error");
+ }
+
+}
+
+void Connection::rollback(void){
+ SQLRETURN result = SQLEndTran(SQL_HANDLE_DBC, connection, SQL_ROLLBACK);
+
+ if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)){
+ throw SQLException(result, "Rollback error");
+ }
+
+}
+
+void Connection::setAutoCommit(bool autoCommit){
+ if(autoCommit)
+ SQLSetConnectAttr(connection,SQL_ATTR_AUTOCOMMIT,reinterpret_cast<SQLPOINTER>(SQL_AUTOCOMMIT_ON), SQL_IS_INTEGER );
+ else
+ SQLSetConnectAttr(connection,SQL_ATTR_AUTOCOMMIT,SQL_AUTOCOMMIT_OFF, SQL_IS_INTEGER );
+}
+
+StatementPtr Connection::createStatement(void) {
+ SQLHSTMT statementHandle;
+ SQLRETURN result = SQLAllocHandle(SQL_HANDLE_STMT, connection, &statementHandle);
+
+ if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)){
+ throw SQLException(result, "Error to alloc the statement handle - SQLSTMT");
+ }
+
+ std::list<StatementPtr*>::iterator it;
+
+ for (it = statements.begin() ; it != statements.end() ; ) {
+
+ if (**it) {
+ it++;
+
+ } else {
+ std::list<StatementPtr*>::iterator aux = it;
+ it++;
+ statements.erase(aux);
+
+ }
+
+ }
+
+ Statement* stmt = new Statement(*this, statementHandle);
+ StatementPtr ret(stmt);
+ statements.push_back(new StatementPtr(stmt, false));
+
+ return ret;
+
+}
+
+ };
+ };
+};
Added: incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/CreatedDataObject.cpp
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/CreatedDataObject.cpp?rev=594314&view=auto
==============================================================================
--- incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/CreatedDataObject.cpp (added)
+++ incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/CreatedDataObject.cpp Mon Nov 12 14:02:46 2007
@@ -0,0 +1,107 @@
+/*
+ * 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/CreatedDataObject.h"
+
+namespace apache {
+ namespace das {
+ namespace rdb {
+
+CreatedDataObject::CreatedDataObject(const Table& table, commonj::sdo::DataObjectPtr dataObject,
+ commonj::sdo::ChangeSummaryPtr changeSummary)
+ : DASDataObject(table, dataObject, changeSummary) {
+
+
+ commonj::sdo::PropertyList properties = dataObject->getInstanceProperties();
+ statement.append("insert into ").append(table.getTableName()).append("(");
+ bool containsDataType = false;
+ std::string columns;
+ std::string values;
+
+ for (unsigned int i = 0 ; i < properties.size() ; i++) {
+
+ if (properties[i].getType().isDataType()) {
+
+ if (containsDataType) {
+ columns.append(",");
+ values.append(",");
+
+ }
+
+ containsDataType = true;
+ const Column* column = table.getColumnByProperty(properties[i].getName());
+ ColumnData columnData(*column, dataObject);
+
+ columns.append(column->getName());
+ values.append(columnData.toSQL());
+
+ }
+
+ }
+
+ statement.append(columns).append(") values(").append(values).append(");");
+
+}
+
+CreatedDataObject::~CreatedDataObject(void) {}
+
+std::string CreatedDataObject::getStatement(void) const {
+ return statement;
+}
+
+//void CreatedDataObject::execute(StatementPtr stmt) const {
+// DASDataObject::execute(stmt);
+//
+// std::string statement;
+// statement = statement.append("insert into ").append(getDataObject()->getType().getName()).append("(");
+//
+// stmt->executeQuery(statement);
+//
+//
+//}
+//
+//void CreatedDataObject::execute(StatementPtr stmt) const {
+//
+// for (std::list<RelationshipStatement*>::const_iterator it = dependencies.begin() ;
+// it != dependencies.end() ; it++) {
+//
+// (*it)->execute(stmt);
+//
+// }
+//
+// std::cout << statement << std::endl;
+//
+// if (statement != "") {
+// stmt->executeQuery(statement);
+// }
+//
+//}
+
+void CreatedDataObject::printStmt(void) {
+ /*DASDataObject::printStmt();
+
+ std::string statement;
+ statement = statement.append("insert into ").append(getDataObject()->getType().getName()).append("(").append(columns).append(") values(").append(values).append(");");
+
+ std::cout << statement << std::endl;*/
+
+}
+
+ };
+ };
+};
Added: incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/DASColumnNotFoundException.cpp
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/DASColumnNotFoundException.cpp?rev=594314&view=auto
==============================================================================
--- incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/DASColumnNotFoundException.cpp (added)
+++ incubator/tuscany/sandbox/crestani/das_distribution_example/src/runtime/core/src/apache/das/rdb/DASColumnNotFoundException.cpp Mon Nov 12 14:02:46 2007
@@ -0,0 +1,32 @@
+/*
+ * 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/DASColumnNotFoundException.h"
+
+namespace apache {
+ namespace das {
+ namespace rdb {
+
+DASColumnNotFoundException::DASColumnNotFoundException(std::string message) : std::exception(message.c_str()) {}
+
+DASColumnNotFoundException::~DASColumnNotFoundException(void) {}
+
+ };
+ };
+};
---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-commits-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-commits-help@ws.apache.org