driver.cpp

/* This file is part of the KDE project
   Copyright (C) 2003-2004 Jaroslaw Staniek <js@iidea.pl>
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this program; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#include <kexidb/driver.h>
#include <kexidb/driver_p.h>
#include <kexidb/drivermanager.h>
#include <kexidb/drivermanager_p.h>
#include "error.h"
#include "drivermanager.h"
#include "connection.h"
#include "connectiondata.h"
#include "admin.h"
 
#include <tqfileinfo.h>
 
#include <tdelocale.h>
#include <kdebug.h>
 
#include <assert.h>
 
using namespace KexiDB;
 
TQValueVector<TQString> dflt_typeNames;
 
 
//---------------------------------------------
 
 
DriverBehaviour::DriverBehaviour()
    : UNSIGNED_TYPE_KEYWORD("UNSIGNED")
    , AUTO_INCREMENT_FIELD_OPTION("AUTO_INCREMENT")
    , AUTO_INCREMENT_PK_FIELD_OPTION("AUTO_INCREMENT PRIMARY KEY")
    , SPECIAL_AUTO_INCREMENT_DEF(false)
    , AUTO_INCREMENT_REQUIRES_PK(false)
    , ROW_ID_FIELD_RETURNS_LAST_AUTOINCREMENTED_VALUE(false)
    , QUOTATION_MARKS_FOR_IDENTIFIER('"')
    , USING_DATABASE_REQUIRED_TO_CONNECT(true)
    , _1ST_ROW_READ_AHEAD_REQUIRED_TO_KNOW_IF_THE_RESULT_IS_EMPTY(false)
    , SELECT_1_SUBQUERY_SUPPORTED(false)
    , SQL_KEYWORDS(0)
{
}
 
//---------------------------------------------
 
Driver::Info::Info()
 : fileBased(false)
 , allowImportingTo(true)
{
}
 
//---------------------------------------------
 
Driver::Driver( TQObject *parent, const char *name, const TQStringList & )
    : TQObject( parent, name )
    , Object()
    , beh( new DriverBehaviour() )
    , d( new DriverPrivate() )
{
    d->connections.setAutoDelete(false);
    //TODO: reasonable size
    d->connections.resize(101);
    d->typeNames.resize(Field::LastType + 1);
 
    d->initKexiKeywords();
}
 
 
Driver::~Driver()
{
    DriverManagerInternal::self()->aboutDelete( this );
//  KexiDBDbg << "Driver::~Driver()" << endl;
    TQPtrDictIterator<Connection> it( d->connections );
    Connection *conn;
    while ( (conn = it.toFirst()) ) {
        delete conn;
    }
    delete beh;
    delete d;
//  KexiDBDbg << "Driver::~Driver() ok" << endl;
}
 
bool Driver::isValid()
{
    clearError();
    if (KexiDB::version().major != version().major
        || KexiDB::version().minor != version().minor)
    {
        setError(ERR_INCOMPAT_DRIVER_VERSION,
        i18n("Incompatible database driver's \"%1\" version: found version %2, expected version %3.")
        .arg(name())
        .arg(TQString("%1.%2").arg(version().major).arg(version().minor))
        .arg(TQString("%1.%2").arg(KexiDB::version().major).arg(KexiDB::version().minor)));
        return false;
    }
 
    TQString inv_impl = i18n("Invalid database driver's \"%1\" implementation:\n").arg(name());
    TQString not_init = i18n("Value of \"%1\" is not initialized for the driver.");
    if (beh->ROW_ID_FIELD_NAME.isEmpty()) {
        setError(ERR_INVALID_DRIVER_IMPL, inv_impl + not_init.arg("DriverBehaviour::ROW_ID_FIELD_NAME"));
        return false;
    }
 
    return true;
}
 
const TQPtrList<Connection> Driver::connectionsList() const
{
    TQPtrList<Connection> clist;
    TQPtrDictIterator<Connection> it( d->connections );
    for( ; it.current(); ++it )
        clist.append( &(*it) );
    return clist;
}
 
TQString Driver::fileDBDriverMimeType() const
{ return d->fileDBDriverMimeType; }
 
TQString Driver::defaultFileBasedDriverMimeType()
{ return TQString::fromLatin1("application/x-kexiproject-sqlite3"); }
 
TQString Driver::defaultFileBasedDriverName()
{
    DriverManager dm;
    return dm.lookupByMime(Driver::defaultFileBasedDriverMimeType()).lower();
}
 
const KService* Driver::service() const
{ return d->service; }
 
bool Driver::isFileDriver() const
{ return d->isFileDriver; }
 
int Driver::features() const
{ return d->features; }
 
bool Driver::transactionsSupported() const
{ return d->features & (SingleTransactions | MultipleTransactions); }
 
AdminTools& Driver::adminTools() const
{
    if (!d->adminTools)
        d->adminTools = drv_createAdminTools();
    return *d->adminTools;
}
 
AdminTools* Driver::drv_createAdminTools() const
{
    return new AdminTools(); //empty impl.
}
 
TQString Driver::sqlTypeName(int id_t, int /*p*/) const
{
    if (id_t > Field::InvalidType && id_t <= Field::LastType)
        return d->typeNames[(id_t>0 && id_t<=Field::LastType) ? id_t : Field::InvalidType /*sanity*/];
 
    return d->typeNames[Field::InvalidType];
}
 
Connection *Driver::createConnection( ConnectionData &conn_data, int options )
{
    clearError();
    if (!isValid())
        return 0;
 
    if (d->isFileDriver) {
        if (conn_data.fileName().isEmpty()) {
            setError(ERR_MISSING_DB_LOCATION, i18n("File name expected for file-based database driver.") );
            return 0;
        }
    }
//  Connection *conn = new Connection( this, conn_data );
    Connection *conn = drv_createConnection( conn_data );
 
    conn->setReadOnly(options & ReadOnlyConnection);
 
    conn_data.driverName = name();
    d->connections.insert( conn, conn );
    return conn;
}
 
Connection* Driver::removeConnection( Connection *conn )
{
    clearError();
    return d->connections.take( conn );
}
 
TQString Driver::defaultSQLTypeName(int id_t)
{
    if (id_t>=Field::Null)
        return "Null";
    if (dflt_typeNames.isEmpty()) {
        dflt_typeNames.resize(Field::LastType + 1);
        dflt_typeNames[Field::InvalidType]="InvalidType";
        dflt_typeNames[Field::Byte]="Byte";
        dflt_typeNames[Field::ShortInteger]="ShortInteger";
        dflt_typeNames[Field::Integer]="Integer";
        dflt_typeNames[Field::BigInteger]="BigInteger";
        dflt_typeNames[Field::Boolean]="Boolean";
        dflt_typeNames[Field::Date]="Date";
        dflt_typeNames[Field::DateTime]="DateTime";
        dflt_typeNames[Field::Time]="Time";
        dflt_typeNames[Field::Float]="Float";
        dflt_typeNames[Field::Double]="Double";
        dflt_typeNames[Field::Text]="Text";
        dflt_typeNames[Field::LongText]="LongText";
        dflt_typeNames[Field::BLOB]="BLOB";
    }
    return dflt_typeNames[id_t];
}
 
bool Driver::isSystemObjectName( const TQString& n ) const
{
    return Driver::isKexiDBSystemObjectName(n);
}
 
bool Driver::isKexiDBSystemObjectName( const TQString& n )
{
    if (!n.lower().startsWith("kexi__"))
        return false;
    const TQStringList list( Connection::kexiDBSystemTableNames() );
    return list.find(n.lower())!=list.constEnd();
}
 
bool Driver::isSystemFieldName( const TQString& n ) const
{
    if (!beh->ROW_ID_FIELD_NAME.isEmpty() && n.lower()==beh->ROW_ID_FIELD_NAME.lower())
        return true;
    return drv_isSystemFieldName(n);
}
 
TQString Driver::valueToSQL( uint ftype, const TQVariant& v ) const
{
    if (v.isNull())
        return "NULL";
    switch (ftype) {
        case Field::Text:
        case Field::LongText: {
            TQString s = v.toString();
            return escapeString(s); //TQString("'")+s.replace( '"', "\\\"" ) + "'";
        }
        case Field::Byte:
        case Field::ShortInteger:
        case Field::Integer:
        case Field::BigInteger:
            return v.toString();
        case Field::Float:
        case Field::Double: {
            if (v.type()==TQVariant::String) {
                //workaround for values stored as string that should be casted to floating-point
                TQString s(v.toString());
                return s.replace(',', ".");
            }
            return v.toString();
        }
//TODO: here special encoding method needed
        case Field::Boolean:
            return TQString::number(v.toInt()?1:0); //0 or 1
        case Field::Time:
            return TQString("\'")+v.toTime().toString(TQt::ISODate)+"\'";
        case Field::Date:
            return TQString("\'")+v.toDate().toString(TQt::ISODate)+"\'";
        case Field::DateTime:
            return dateTimeToSQL( v.toDateTime() );
        case Field::BLOB: {
            if (v.toByteArray().isEmpty())
                return TQString::fromLatin1("NULL");
            if (v.type()==TQVariant::String)
                return escapeBLOB(v.toString().utf8());
            return escapeBLOB(v.toByteArray());
        }
        case Field::InvalidType:
            return "!INVALIDTYPE!";
        default:
            KexiDBDbg << "Driver::valueToSQL(): UNKNOWN!" << endl;
            return TQString();
    }
    return TQString();
}
 
TQVariant Driver::propertyValue( const TQCString& propName ) const
{
    return d->properties[propName.lower()];
}
 
TQString Driver::propertyCaption( const TQCString& propName ) const
{
    return d->propertyCaptions[propName.lower()];
}
 
TQValueList<TQCString> Driver::propertyNames() const
{
    TQValueList<TQCString> names = d->properties.keys();
    qHeapSort(names);
    return names;
}
 
TQString Driver::escapeIdentifier(const TQString& str, int options) const
{
    TQCString cstr = str.latin1();
    return TQString(escapeIdentifier(cstr, options));
}
 
TQCString Driver::escapeIdentifier(const TQCString& str, int options) const
{
    bool needOuterQuotes = false;
 
// Need to use quotes if ...
// ... we have been told to, or ...
    if(options & EscapeAlways)
        needOuterQuotes = true;
 
// ... or if the driver does not have a list of keywords,
    else if(!d->driverSQLDict)
        needOuterQuotes = true;
 
// ... or if it's a keyword in Kexi's SQL dialect,
    else if(d->kexiSQLDict->find(str))
        needOuterQuotes = true;
 
// ... or if it's a keyword in the backends SQL dialect,
// (have already checked !d->driverSQLDict)
    else if((options & EscapeDriver) && d->driverSQLDict->find(str))
        needOuterQuotes = true;
 
// ... or if the identifier has a space in it...
  else if(str.find(' ') != -1)
        needOuterQuotes = true;
 
    if(needOuterQuotes && (options & EscapeKexi)) {
        const char quote = '"';
        return quote + TQCString(str).replace( quote, "\"\"" ) + quote;
    }
    else if (needOuterQuotes) {
        const char quote = beh->QUOTATION_MARKS_FOR_IDENTIFIER.latin1();
        return quote + drv_escapeIdentifier(str) + quote;
    } else {
        return drv_escapeIdentifier(str);
    }
}
 
void Driver::initSQLKeywords(int hashSize) {
 
    if(!d->driverSQLDict && beh->SQL_KEYWORDS != 0) {
      d->initDriverKeywords(beh->SQL_KEYWORDS, hashSize);
    }
}
 
#include "driver.moc"