kexidb/utils.h

/* This file is part of the KDE project
   Copyright (C) 2004-2007 Jaroslaw Staniek <js@iidea.pl>
 
   This library 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 library 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 library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
 
#ifndef KEXIDB_UTILS_H
#define KEXIDB_UTILS_H
 
#include <tqvaluelist.h>
#include <tqvariant.h>
 
#include <kexidb/connection.h>
#include <kexidb/driver.h>
 
class TQDomNode;
class TQDomElement;
class TQDomDocument;
 
namespace KexiDB
{
    inline KEXI_DB_EXPORT bool deleteRow(Connection &conn, TableSchema *table, 
        const TQString &keyname, const TQString &keyval)
    {
        return table!=0 && conn.executeSQL("DELETE FROM " + table->name() + " WHERE " 
            + keyname + "=" + conn.driver()->valueToSQL( Field::Text, TQVariant(keyval) ));
    }
 
    inline KEXI_DB_EXPORT bool deleteRow(Connection &conn, const TQString &tableName, 
        const TQString &keyname, const TQString &keyval)
    {
        return conn.executeSQL("DELETE FROM " + tableName + " WHERE " 
            + keyname + "=" + conn.driver()->valueToSQL( Field::Text, TQVariant(keyval) ));
    }
 
    inline KEXI_DB_EXPORT bool deleteRow(Connection &conn, TableSchema *table, 
        const TQString &keyname, int keyval)
    {
        return table!=0 && conn.executeSQL("DELETE FROM " + table->name() + " WHERE " 
            + keyname + "=" + conn.driver()->valueToSQL( Field::Integer, TQVariant(keyval) ));
    }
 
    inline KEXI_DB_EXPORT bool deleteRow(Connection &conn, const TQString &tableName, 
        const TQString &keyname, int keyval)
    {
        return conn.executeSQL("DELETE FROM " + tableName + " WHERE " 
            + keyname + "=" + conn.driver()->valueToSQL( Field::Integer, TQVariant(keyval) ));
    }
 
    inline KEXI_DB_EXPORT bool deleteRow(Connection &conn, const TQString &tableName, 
        const TQString &keyname1, Field::Type keytype1, const TQVariant& keyval1, 
        const TQString &keyname2, Field::Type keytype2, const TQVariant& keyval2)
    {
        return conn.executeSQL("DELETE FROM " + tableName + " WHERE " 
            + keyname1 + "=" + conn.driver()->valueToSQL( keytype1, keyval1 )
            + " AND " + keyname2 + "=" + conn.driver()->valueToSQL( keytype2, keyval2 ));
    }
 
    inline KEXI_DB_EXPORT bool replaceRow(Connection &conn, TableSchema *table, 
        const TQString &keyname, const TQString &keyval, const TQString &valname, TQVariant val, int ftype)
    {
        if (!table || !KexiDB::deleteRow(conn, table, keyname, keyval))
            return false;
        return conn.executeSQL("INSERT INTO " + table->name() 
            + " (" + keyname + "," + valname + ") VALUES (" 
            + conn.driver()->valueToSQL( Field::Text, TQVariant(keyval) ) + "," 
            + conn.driver()->valueToSQL( ftype, val) + ")");
    }
 
    typedef TQValueList<uint> TypeGroupList;
 
    KEXI_DB_EXPORT const TypeGroupList typesForGroup(Field::TypeGroup typeGroup);
 
    KEXI_DB_EXPORT TQStringList typeNamesForGroup(Field::TypeGroup typeGroup);
 
    KEXI_DB_EXPORT TQStringList typeStringsForGroup(Field::TypeGroup typeGroup);
 
    KEXI_DB_EXPORT Field::Type defaultTypeForGroup(Field::TypeGroup typeGroup);
 
    KEXI_DB_EXPORT TQString simplifiedTypeName(const Field& field);
 
    inline bool isEmptyValue(Field *f, const TQVariant &v) {
        if (f->hasEmptyProperty() && v.toString().isEmpty() && !v.toString().isNull())
            return true;
        return v.isNull();
    }
 
    KEXI_DB_EXPORT void getHTMLErrorMesage(Object* obj, TQString& msg, TQString &details);
 
    KEXI_DB_EXPORT void getHTMLErrorMesage(Object* obj, TQString& msg);
 
    KEXI_DB_EXPORT void getHTMLErrorMesage(Object* obj, ResultInfo *result);
 
    inline KEXI_DB_EXPORT TQString sqlWhere(Driver *drv, Field::Type t, 
        const TQString fieldName, const TQVariant value)
    {
        if (value.isNull())
            return fieldName + " is NULL";
        return fieldName + "=" + drv->valueToSQL( t, value );
    }
 
    KEXI_DB_EXPORT int idForObjectName( Connection &conn, const TQString& objName, int objType );
 
    class KEXI_DB_EXPORT TableOrQuerySchema {
        public:
            TableOrQuerySchema(Connection *conn, const TQCString& name);
 
            TableOrQuerySchema(Connection *conn, const TQCString& name, bool table);
 
            TableOrQuerySchema(FieldList &tableOrQuery);
            
            TableOrQuerySchema(Connection *conn, int id);
 
            TableOrQuerySchema(TableSchema* table);
 
            TableOrQuerySchema(QuerySchema* query);
 
            QuerySchema* query() const { return m_query; }
 
            TableSchema* table() const { return m_table; }
 
            TQCString name() const;
 
            TQString captionOrName() const;
 
            uint fieldCount() const;
 
            const QueryColumnInfo::Vector columns(bool unique = false);
 
            Field* field(const TQString& name);
 
            QueryColumnInfo* columnInfo(const TQString& name);
 
            Connection* connection() const;
 
            TQString debugString();
 
            void debug();
 
        protected:
            TQCString m_name; 
            TableSchema* m_table;
            QuerySchema* m_query;
    };
 
 
    int rowCount(Connection &conn, const TQString& sql);
 
 
    KEXI_DB_EXPORT int rowCount(const TableSchema& tableSchema);
 
 
    KEXI_DB_EXPORT int rowCount(QuerySchema& querySchema);
 
 
    KEXI_DB_EXPORT int rowCount(TableOrQuerySchema& tableOrQuery);
 
    KEXI_DB_EXPORT int fieldCount(TableOrQuerySchema& tableOrQuery);
 
    KEXI_DB_EXPORT void connectionTestDialog(TQWidget* parent, const ConnectionData& data, 
        MessageHandler& msgHandler);
 
    KEXI_DB_EXPORT TQMap<TQString,TQString> toMap( const ConnectionData& data );
 
    KEXI_DB_EXPORT void fromMap( const TQMap<TQString,TQString>& map, ConnectionData& data );
 
    enum SplitToTableAndFieldPartsOptions {
        FailIfNoTableOrFieldName = 0, 
        SetFieldNameIfNoTableName = 1 
    };
 
    KEXI_DB_EXPORT bool splitToTableAndFieldParts(const TQString& string, 
        TQString& tableName, TQString& fieldName, 
        SplitToTableAndFieldPartsOptions option = FailIfNoTableOrFieldName);
 
    KEXI_DB_EXPORT bool supportsVisibleDecimalPlacesProperty(Field::Type type);
 
    KEXI_DB_EXPORT TQString formatNumberForVisibleDecimalPlaces(double value, int decimalPlaces);
 
    KEXI_DB_EXPORT bool isBuiltinTableFieldProperty( const TQCString& propertyName );
 
    KEXI_DB_EXPORT bool isExtendedTableFieldProperty( const TQCString& propertyName );
 
    KEXI_DB_EXPORT Field::Type intToFieldType( int type );
 
    KEXI_DB_EXPORT bool setFieldProperties( Field& field, const TQMap<TQCString, TQVariant>& values );
 
    KEXI_DB_EXPORT bool setFieldProperty(Field& field, const TQCString& propertyName, 
        const TQVariant& value);
 
    KEXI_DB_EXPORT TQVariant loadPropertyValueFromDom( const TQDomNode& node );
 
    KEXI_DB_EXPORT int loadIntPropertyValueFromDom( const TQDomNode& node, bool* ok );
 
    KEXI_DB_EXPORT TQString loadStringPropertyValueFromDom( const TQDomNode& node, bool* ok );
 
    KEXI_DB_EXPORT TQDomElement saveNumberElementToDom(TQDomDocument& doc, TQDomElement& parentEl, 
        const TQString& elementName, int value);
 
    KEXI_DB_EXPORT TQDomElement saveBooleanElementToDom(TQDomDocument& doc, TQDomElement& parentEl, 
        const TQString& elementName, bool value);
 
    KEXI_DB_EXPORT TQVariant emptyValueForType( Field::Type type );
 
    KEXI_DB_EXPORT TQVariant notEmptyValueForType( Field::Type type );
 
    enum BLOBEscapingType {
        BLOBEscapeXHex = 1,        
        BLOBEscape0xHex,           
        BLOBEscapeHex,              
        BLOBEscapeOctal           
    };
 
 
    KEXI_DB_EXPORT TQString escapeBLOB(const TQByteArray& array, BLOBEscapingType type);
 
    KEXI_DB_EXPORT TQByteArray pgsqlByteaToByteArray(const char* data, int length);
 
    KEXI_DB_EXPORT TQString variantToString( const TQVariant& v );
 
    KEXI_DB_EXPORT TQVariant stringToVariant( const TQString& s, TQVariant::Type type, bool &ok );
 
    KEXI_DB_EXPORT bool isDefaultValueAllowed( Field* field );
 
    KEXI_DB_EXPORT void getLimitsForType(Field::Type type, int &minValue, int &maxValue);
 
    KEXI_DB_EXPORT void debugRowData(const RowData& rowData);
 
    KEXI_DB_EXPORT Field::Type maximumForIntegerTypes(Field::Type t1, Field::Type t2);
 
    inline TQVariant cstringToVariant(const char* data, KexiDB::Field* f, int length = -1)
    {
        if (!data)
            return TQVariant();
        // from mo st to least frequently used types:
 
        if (!f || f->isTextType())
            return TQString::fromUtf8(data, length);
        if (f->isIntegerType()) {
            if (f->type()==KexiDB::Field::BigInteger)
                return TQVariant( TQString::fromLatin1(data, length).toLongLong() );
            return TQVariant( TQString::fromLatin1(data, length).toInt() );
        }
        if (f->isFPNumericType())
            return TQString::fromLatin1(data, length).toDouble();
        if (f->type()==KexiDB::Field::BLOB) {
            TQByteArray ba;
            ba.duplicate(data, length);
            return ba;
        }
        // the default
        TQVariant result(TQString::fromUtf8(data, length));
        if (!result.cast( KexiDB::Field::variantType(f->type()) ))
            return TQVariant();
        return result;
    }
}
 
#endif