00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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
00105
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
00140
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
00156
00157
00158
00159
00160
00161
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())); }