kexi

kexidbconnection.cpp

00001 /***************************************************************************
00002  * kexidbconnection.cpp
00003  * This file is part of the KDE project
00004  * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
00005  *
00006  * This program is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Library General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2 of the License, or (at your option) any later version.
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013  * Library General Public License for more details.
00014  * You should have received a copy of the GNU Library General Public License
00015  * along with this program; see the file COPYING.  If not, write to
00016  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017  * Boston, MA 02110-1301, USA.
00018  ***************************************************************************/
00019 
00020 #include "kexidbconnection.h"
00021 #include "kexidbconnectiondata.h"
00022 #include "kexidbdrivermanager.h"
00023 #include "kexidbdriver.h"
00024 #include "kexidbcursor.h"
00025 #include "kexidbfieldlist.h"
00026 #include "kexidbschema.h"
00027 #include "kexidbtransaction.h"
00028 #include "kexidbparser.h"
00029 
00030 #include <api/exception.h>
00031 
00032 #include <kdebug.h>
00033 
00034 #include <kexidb/transaction.h>
00035 
00036 using namespace Kross::KexiDB;
00037 
00038 KexiDBConnection::KexiDBConnection(::KexiDB::Connection* connection, KexiDBDriver* driver, KexiDBConnectionData* connectiondata)
00039     : Kross::Api::Class<KexiDBConnection>("KexiDBConnection")
00040     , m_connection(connection)
00041     , m_connectiondata(connectiondata ? connectiondata : new KexiDBConnectionData(connection->data()))
00042     , m_driver(driver ? driver : new KexiDBDriver(connection->driver()))
00043 {
00044     this->addFunction0< Kross::Api::Variant >("hadError", this, &KexiDBConnection::hadError);
00045     this->addFunction0< Kross::Api::Variant >("lastError", this, &KexiDBConnection::lastError);
00046 
00047     this->addFunction0< KexiDBConnectionData >("data", this, &KexiDBConnection::data);
00048     this->addFunction0< KexiDBDriver >("driver", this, &KexiDBConnection::driver);
00049 
00050     this->addFunction0< Kross::Api::Variant >("connect", this, &KexiDBConnection::connect);
00051     this->addFunction0< Kross::Api::Variant >("isConnected", this, &KexiDBConnection::isConnected);
00052     this->addFunction0< Kross::Api::Variant >("disconnect", this, &KexiDBConnection::disconnect);
00053 
00054     this->addFunction1< Kross::Api::Variant, Kross::Api::Variant >("databaseExists", this, &KexiDBConnection::databaseExists);
00055     this->addFunction0< Kross::Api::Variant >("currentDatabase", this, &KexiDBConnection::currentDatabase);
00056     this->addFunction0< Kross::Api::Variant >("databaseNames", this, &KexiDBConnection::databaseNames);
00057     this->addFunction0< Kross::Api::Variant >("isDatabaseUsed", this, &KexiDBConnection::isDatabaseUsed);
00058     this->addFunction1< Kross::Api::Variant, Kross::Api::Variant >("useDatabase", this, &KexiDBConnection::useDatabase);
00059     this->addFunction0< Kross::Api::Variant >("closeDatabase", this, &KexiDBConnection::closeDatabase);
00060 
00061     this->addFunction0< Kross::Api::Variant >("tableNames", this, &KexiDBConnection::tableNames);
00062     this->addFunction0< Kross::Api::Variant >("queryNames", this, &KexiDBConnection::queryNames);
00063 
00064     this->addFunction1< KexiDBCursor, Kross::Api::Variant >("executeQueryString", this, &KexiDBConnection::executeQueryString);
00065     this->addFunction1< KexiDBCursor, KexiDBQuerySchema >("executeQuerySchema", this, &KexiDBConnection::executeQuerySchema);
00066 
00067     addFunction("insertRecord", &KexiDBConnection::insertRecord);
00068 
00069     this->addFunction1< Kross::Api::Variant, Kross::Api::Variant >("createDatabase", this, &KexiDBConnection::createDatabase);
00070     this->addFunction1< Kross::Api::Variant, Kross::Api::Variant >("dropDatabase", this, &KexiDBConnection::dropDatabase);
00071 
00072     this->addFunction1< Kross::Api::Variant, KexiDBTableSchema >("createTable", this, &KexiDBConnection::createTable);
00073     this->addFunction1< Kross::Api::Variant, Kross::Api::Variant >("dropTable", this, &KexiDBConnection::dropTable);
00074     this->addFunction2< Kross::Api::Variant, KexiDBTableSchema, KexiDBTableSchema >("alterTable", this, &KexiDBConnection::alterTable);
00075     this->addFunction2< Kross::Api::Variant, KexiDBTableSchema, Kross::Api::Variant >("alterTableName", this, &KexiDBConnection::alterTableName);
00076 
00077     this->addFunction1< KexiDBTableSchema, Kross::Api::Variant >("tableSchema", this, &KexiDBConnection::tableSchema);
00078     this->addFunction1< Kross::Api::Variant, KexiDBTableSchema >("isEmptyTable", this, &KexiDBConnection::isEmptyTable);
00079     this->addFunction1< KexiDBQuerySchema, Kross::Api::Variant >("querySchema", this, &KexiDBConnection::querySchema);
00080 
00081     this->addFunction0< Kross::Api::Variant >("autoCommit", this, &KexiDBConnection::autoCommit);
00082     this->addFunction1< Kross::Api::Variant, Kross::Api::Variant >("setAutoCommit", this, &KexiDBConnection::setAutoCommit);
00083 
00084     this->addFunction0< KexiDBTransaction >("beginTransaction", this, &KexiDBConnection::beginTransaction);
00085     this->addFunction1< Kross::Api::Variant, KexiDBTransaction >("commitTransaction", this, &KexiDBConnection::commitTransaction);
00086     this->addFunction1< Kross::Api::Variant, KexiDBTransaction >("rollbackTransaction", this, &KexiDBConnection::rollbackTransaction);
00087     this->addFunction0< KexiDBTransaction >("defaultTransaction", this, &KexiDBConnection::defaultTransaction);
00088     this->addFunction1< void, KexiDBTransaction >("setDefaultTransaction", this, &KexiDBConnection::setDefaultTransaction);
00089     this->addFunction0<Kross::Api::List>("transactions", this, &KexiDBConnection::transactions);
00090 
00091     this->addFunction0< KexiDBParser >("parser", this, &KexiDBConnection::parser);
00092 }
00093 
00094 KexiDBConnection::~KexiDBConnection() {
00095 }
00096 
00097 const QString KexiDBConnection::getClassName() const {
00098     return "Kross::KexiDB::KexiDBConnection";
00099 }
00100 
00101 ::KexiDB::Connection* KexiDBConnection::connection() const {
00102     if(! m_connection)
00103         throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("KexiDB::Connection is NULL.")) );
00104     //if(m_connection->error())
00105     //    throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("KexiDB::Connection error: %1").arg(m_connection->errorMsg())) );
00106     return m_connection;
00107 }
00108 
00109 bool KexiDBConnection::hadError() const { return connection()->error(); }
00110 const QString KexiDBConnection::lastError() const { return connection()->errorMsg(); }
00111 
00112 KexiDBConnectionData* KexiDBConnection::data() { return m_connectiondata.data(); }
00113 KexiDBDriver* KexiDBConnection::driver() { return m_driver.data(); }
00114 
00115 bool KexiDBConnection::connect() { return connection()->connect(); }
00116 bool KexiDBConnection::isConnected() { return connection()->isConnected(); }
00117 bool KexiDBConnection::disconnect() { return connection()->disconnect(); }
00118 
00119 bool KexiDBConnection::isReadOnly() const { return connection()->isReadOnly(); }
00120 
00121 bool KexiDBConnection::databaseExists(const QString& dbname) { return connection()->databaseExists(dbname); }
00122 const QString KexiDBConnection::currentDatabase() const { return connection()->currentDatabase(); }
00123 const QStringList KexiDBConnection::databaseNames() const { return connection()->databaseNames(); }
00124 bool KexiDBConnection::isDatabaseUsed() const { return connection()->isDatabaseUsed(); }
00125 bool KexiDBConnection::useDatabase(const QString& dbname) { return connection()->databaseExists(dbname) && m_connection->useDatabase(dbname); }
00126 bool KexiDBConnection::closeDatabase() { return connection()->closeDatabase(); }
00127 
00128 const QStringList KexiDBConnection::allTableNames() const { return connection()->tableNames(true); }
00129 const QStringList KexiDBConnection::tableNames() const { return connection()->tableNames(false); }
00130 
00131 const QStringList KexiDBConnection::queryNames() const {
00132     bool ok = true;
00133     QStringList queries = connection()->objectNames(::KexiDB::QueryObjectType, &ok);
00134     if(! ok) throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Failed to determinate querynames.")) );
00135     return queries;
00136 }
00137 
00138 KexiDBCursor* KexiDBConnection::executeQueryString(const QString& sqlquery) {
00139     // The ::KexiDB::Connection::executeQuery() method does not check if we pass a valid SELECT-statement
00140     // or e.g. a DROP TABLE operation. So, let's check for such dangerous operations right now.
00141     ::KexiDB::Parser parser( connection() );
00142     if(! parser.parse(sqlquery))
00143         throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Failed to parse query: %1 %2").arg(parser.error().type()).arg(parser.error().error())) );
00144     if( parser.query() == 0 || parser.operation() != ::KexiDB::Parser::OP_Select )
00145         throw Kross::Api::Exception::Ptr( new Kross::Api::Exception(QString("Invalid query operation \"%1\"").arg(parser.operationString()) ) );
00146     ::KexiDB::Cursor* cursor = connection()->executeQuery(sqlquery);
00147     return cursor ? new KexiDBCursor(cursor) : 0;
00148 }
00149 
00150 KexiDBCursor* KexiDBConnection::executeQuerySchema(KexiDBQuerySchema* queryschema) {
00151     ::KexiDB::Cursor* cursor = connection()->executeQuery( *queryschema->queryschema() );
00152     return cursor ? new KexiDBCursor(cursor) : 0;
00153 }
00154 
00155 /*TODO
00156 bool KexiDBConnection::insertRecordIntoFieldlist(KexiDBFieldList* fieldlist, QValueList<QVariant> values) {
00157     return connection()->insertRecord(*fieldlist->fieldlist(), values);
00158 }
00159 
00160 bool KexiDBConnection::insertRecordIntoTable(KexiDBTableSchema* tableschema, QValueList<QVariant> values) {
00161     return connection()->insertRecord(*tableschema->tableschema(), values);
00162 }
00163 */
00164 Kross::Api::Object::Ptr KexiDBConnection::insertRecord(Kross::Api::List::Ptr args) {
00165     QValueList<QVariant> values = Kross::Api::Variant::toList(args->item(1));
00166     Kross::Api::Object::Ptr obj = args->item(0);
00167     if(obj->getClassName() == "Kross::KexiDB::KexiDBFieldList")
00168         return new Kross::Api::Variant(
00169                    QVariant(connection()->insertRecord(
00170                        *Kross::Api::Object::fromObject<KexiDBFieldList>(obj)->fieldlist(),
00171                        values
00172                    ), 0));
00173     return new Kross::Api::Variant(
00174                QVariant(connection()->insertRecord(
00175                    *Kross::Api::Object::fromObject<KexiDBTableSchema>(obj)->tableschema(),
00176                    values
00177                ), 0));
00178 }
00179 
00180 bool KexiDBConnection::createDatabase(const QString& dbname) { return connection()->createDatabase(dbname); }
00181 bool KexiDBConnection::dropDatabase(const QString& dbname) { return connection()->dropDatabase(dbname); }
00182 
00183 bool KexiDBConnection::createTable(KexiDBTableSchema* tableschema) { return connection()->createTable(tableschema->tableschema(), false); }
00184 bool KexiDBConnection::dropTable(const QString& tablename) { return true == connection()->dropTable(tablename); }
00185 bool KexiDBConnection::alterTable(KexiDBTableSchema* fromschema, KexiDBTableSchema* toschema) { return true == connection()->alterTable(*fromschema->tableschema(), *toschema->tableschema()); }
00186 bool KexiDBConnection::alterTableName(KexiDBTableSchema* tableschema, const QString& newtablename) { return connection()->alterTableName(*tableschema->tableschema(), newtablename); }
00187 
00188 KexiDBTableSchema* KexiDBConnection::tableSchema(const QString& tablename) const {
00189     ::KexiDB::TableSchema* tableschema = connection()->tableSchema(tablename);
00190     return tableschema ? new KexiDBTableSchema(tableschema) : 0;
00191 }
00192 
00193 bool KexiDBConnection::isEmptyTable(KexiDBTableSchema* tableschema) const {
00194     bool success;
00195     bool notempty = connection()->isEmpty(*tableschema->tableschema(), success);
00196     return (! (success && notempty));
00197 }
00198 
00199 KexiDBQuerySchema* KexiDBConnection::querySchema(const QString& queryname) const {
00200     ::KexiDB::QuerySchema* queryschema = connection()->querySchema(queryname);
00201     return queryschema ? new KexiDBQuerySchema(queryschema) : 0;
00202 }
00203 
00204 bool KexiDBConnection::autoCommit() const { return connection()->autoCommit(); }
00205 bool KexiDBConnection::setAutoCommit(bool enabled) { return connection()->setAutoCommit(enabled); }
00206 
00207 KexiDBTransaction* KexiDBConnection::beginTransaction() {
00208     ::KexiDB::Transaction t = connection()->beginTransaction();
00209     return new KexiDBTransaction(t);
00210 }
00211 
00212 bool KexiDBConnection::commitTransaction(KexiDBTransaction* transaction) { return connection()->commitTransaction( transaction->transaction() ); }
00213 bool KexiDBConnection::rollbackTransaction(KexiDBTransaction* transaction) { return connection()->rollbackTransaction( transaction->transaction() ); }
00214 KexiDBTransaction* KexiDBConnection::defaultTransaction() { return new KexiDBTransaction( connection()->defaultTransaction() ); }
00215 void KexiDBConnection::setDefaultTransaction(KexiDBTransaction* transaction) { connection()->setDefaultTransaction( transaction->transaction() ); }
00216 
00217 Kross::Api::List* KexiDBConnection::transactions() {
00218     return new Kross::Api::ListT<KexiDBTransaction>( connection()->transactions() );
00219 }
00220 
00221 KexiDBParser* KexiDBConnection::parser() { return new KexiDBParser(this, new ::KexiDB::Parser(connection())); }
KDE Home | KDE Accessibility Home | Description of Access Keys