Russian Qt Forum

    db.setConnectOptions("CHARSET=WIN1251");

#define TRANSACTION(x) (QSqlDatabase::database().driver()->setProperty("Transaction",(x)))
#define TRANS_SELECT "TAM=amRead, TIL=ilReadCommitted, TLR=lrNoWait, TFF=0"
#define TRANS_UPDATE "TAM=amWrite, TIL=ilConcurrency, TLR=lrNoWait, TFF=0"
#define TRANS_REPORT "TAM=amRead, TIL=ilConcurrency, TLR=lrNoWait, TFF=0"
#define TRANS_DEFAULT "TAM=amWrite, TIL=ilConcurrency, TLR=lrWait, TFF=0"
// .............
	TRANSACTION(TRANS_SELECT);
	QSqlQuery query.prepare(".........

#include <QTextCodec>
class CTextCodecWIN1251 : public QTextCodec
{
private:
    QTextCodec *win1251Codec;

public:
    CTextCodecWIN1251();
    ~CTextCodecWIN1251();

    virtual QByteArray name() const;
    virtual QList<QByteArray> aliases() const;
    virtual int mibEnum() const;

protected:
    virtual QByteArray convertFromUnicode( const QChar * input, int number, ConverterState * state ) const;
    virtual QString convertToUnicode( const char * chars, int len, ConverterState * state ) const;
};
CTextCodecWIN1251::CTextCodecWIN1251()
{
    win1251Codec = QTextCodec::codecForName("Windows-1251");
}
CTextCodecWIN1251::~CTextCodecWIN1251()
{
}
QByteArray CTextCodecWIN1251::convertFromUnicode(const QChar * input, int number, ConverterState * state) const
{
    if(!win1251Codec)
        return QByteArray();
    return win1251Codec->fromUnicode(input, number, state);
}
QString CTextCodecWIN1251::convertToUnicode(const char * chars, int len, ConverterState * state) const
{
    if(!win1251Codec)
        return QString();
    return win1251Codec->toUnicode(chars, len, state);
}
QByteArray CTextCodecWIN1251::name() const
{
    return QByteArray("WIN1251");
}
QList<QByteArray> CTextCodecWIN1251::aliases() const
{
    QList<QByteArray> list;
    list << QByteArray("WIN-1251") // Эти алиасы не обязательны
         << QByteArray("CP1251")
         << QByteArray("CP-1251")
         << QByteArray("1251");
    return list;
}
int CTextCodecWIN1251::mibEnum() const
{
    if(!win1251Codec)
        return 0;
    return 2251;
}


...
    CTextCodecWIN1251 * p = new CTextCodecWIN1251();
...
    db.setConnectOptions("ISC_DPB_LC_CTYPE=WIN1251");

                IBPP::Blob l_Blob = IBPP::BlobFactory(rp->iDb, rp->iTr);
                rp->iSt->Get(i, l_Blob);

                QByteArray l_QBlob;

                l_Blob->Open();
                int l_Read, l_Offset = 0;
                char buffer[1024];
                while ((l_Read = l_Blob->Read(buffer, 1024)))
                {
                    l_QBlob.resize(l_QBlob.size() + l_Read);
                    memcpy(l_QBlob.data() + l_Offset, buffer, l_Read);
                    l_Offset += l_Read;
                }
                l_Blob->Close();

                row[idx] = l_QBlob;
                break; 

		IBPP::Blob blob = IBPP::BlobFactory(m_Database->getIBPPDB(),
			m_Transaction->getIBPPTransaction());				

		m_Statement->Get(FieldNum, blob);
		blob->Open();
				
		int bytesTotal;		
		int largestChunkSize;		
		int segmentsTotal;
		int chunkSize;
		int bytesRead = 0;

		blob->Info(&bytesTotal, &largestChunkSize, &segmentsTotal);
		data->resize(bytesTotal);

		do 
		{
			chunkSize = (bytesTotal - bytesRead) < largestChunkSize ?
				(bytesTotal - bytesRead) : largestChunkSize;
			bytesRead = blob->Read((void*)data->data(), chunkSize);
		} while (bytesTotal != bytesRead);

		blob->Close();

int QFBResult::numRowsAffected()
{
    int nra = -1;
    
    //if (isSelect())
     //   return nra;

    try
    {
        nra = rp->iSt->AffectedRows();
    }
    catch (IBPP::Exception& e)
    {}
    return nra;
}

int QFBResult::size()
{
    int nra = -1;
    return nra;
...

bool create_connection()
{
    QSqlDatabase db = QSqlDatabase::addDatabase("QFIREBIRD");
    db.setConnectOptions("ISC_DPB_LC_CTYPE=UTF8");
    // TODO после отладки установить пусть к бд:
    // db.setDatabaseName(qApp->applicationDirPath() + "db/IRR-AD.FDB");
    db.setDatabaseName("../db/IRR-AD.FDB");
    db.setUserName("sysdba");
    if (!db.open()) {
        QMessageBox::critical(0, qApp->applicationName(),
                              QString("Не удалось соединиться с БД:\n%1").arg(
                              db.lastError().databaseText()));
        return false;
    }
    return true;
}

Содержимое папки C:\devel\Qt\2009.05\qt\plugins\sqldrivers
...
12.02.2010  22:29             2 200 libqsqlfirebird.a
...
12.02.2010  22:29           833 536 qsqlfirebird.dll
...
              15 файлов      5 451 375 байт
               2 папок  17 727 313 408 байт свободно

svn checkout http://qtfirebirdibppsqldriver.googlecode.com/svn/trunk/ qtfirebirdibppsqldriver-read-only

Запускается D:\projects\irr-ad\debug\irr-ad.exe...
HookingD:\PROJECTS\IRR-AD\DEBUG\IRR-AD.EXE
D:\PROJECTS\IRR-AD\DEBUG\IRR-AD.EXERPH:Injecting code at start up
done...
QFBDriver::open: Unknown connection attribute 'ISC_DPB_LC_CTYPE=UTF8'
D:\projects\irr-ad\debug\irr-ad.exe завершился с кодом 0

database.setConnectOptions("ISC_DPB_LC_CTYPE=WIN1251");

database.setConnectOptions("CHARSET=WIN1251");

CREATE TABLE Cans
( CANNUM SMALLINT NOT NULL,
  DTTM TIMESTAMP NOT NULL,
  CANVALUE DOUBLE PRECISION NOT NULL);

QSqlDatabase DBStoreWrite= QSqlDatabase::addDatabase("QFIREBIRD","DBStoreWrites");
    DBStoreWrite.setConnectOptions("CHARSET=WIN1251");
    DBStoreWrite.setDatabaseName("DBStore");


    DBStoreWrite.open("SYSDBA","masterkey");

    QSqlQuery SqlTest(DBStoreWrite);
    SqlTest.prepare("INSERT INTO Cans (CANNUM,DTTM,CANVALUE) VALUES (:CANNUM,'NOW',:CANVALUE)");
    for (int i=0;i<2;i++)
    {
        SqlTest.bindValue(0,1);
        SqlTest.bindValue(1, i);

        DBStoreWrite.transaction();
        SqlTest.exec();
        DBStoreWrite.commit();
    }

    DBStoreWrite.close();

insert into .... (primary_column) values (null)

if (primary_column is null) then primary_column = gen_id(primary_generator,1)

INSERT INTO SYS$ACTIONS(ID,CAPTION) VALUES(NULL,'CAPTION') RETURNING ID

        while(q.next())
            qDebug() << "Value: " << q.value(0);

bool QFBResultPrivate::isSelect()
{
    bool iss = false;
    try
    {
        iss = (iSt->Type() == IBPP::stSelect) || ((iSt->Type() == IBPP::stExecProcedure) && (iSt->Columns()>0));
    }
    catch (IBPP::Exception& e)
    {
        setError("Unable get type of statement", e, QSqlError::StatementError);
    }
    return iss;
}

        bool mIsSingleResult;
        bool mIsSingleResultDone;

bool StatementImpl::Fetch()
{
        if((mIsSingleResult) && (!mIsSingleResultDone)) {
            IBS status;
            int code = (*gds.Call()->m_dsql_fetch)(status.Self(), &mHandle, 1, mOutRow->Self());
            if (status.Errors())
            {
                    Close();
                    throw SQLExceptionImpl(status, "Statement::Fetch",
                            _("isc_dsql_fetch failed."));
            }
            mIsSingleResultDone = true;
            return true;
        }
        else if ((mIsSingleResultDone) && (mIsSingleResult)) {
            CursorFree();
            mIsSingleResult = false;
            mIsSingleResultDone = false;
            CursorFree();
            return false;
        }

        if (! mResultSetAvailable)
		throw LogicExceptionImpl("Statement::Fetch",
			_("No statement has been executed or no result set available."));

	IBS status;
	int code = (*gds.Call()->m_dsql_fetch)(status.Self(), &mHandle, 1, mOutRow->Self());
	if (code == 100)	// This special code means "no more rows"
	{
		mResultSetAvailable = false;
		// Oddly enough, fetching rows up to the last one seems to open
		// an 'implicit' cursor that needs to be closed.
		mCursorOpened = true;
		CursorFree();	// Free the explicit or implicit cursor/result-set
		return false;
	}
	if (status.Errors())
	{
		Close();
		throw SQLExceptionImpl(status, "Statement::Fetch",
			_("isc_dsql_fetch failed."));
	}
	return true;
}

void StatementImpl::Execute(const std::string& sql)
{
	if (! sql.empty()) Prepare(sql);

	if (mHandle == 0)
		throw LogicExceptionImpl("Statement::Execute",
			_("No statement has been prepared."));

	// Check that a value has been set for each input parameter
	if (mInRow != 0 && mInRow->MissingValues())
		throw LogicExceptionImpl("Statement::Execute",
			_("All parameters must be specified."));

	CursorFree();	// Free a previous 'cursor' if any

	IBS status;
        if (mType == IBPP::stSelect)
	{
		// Could return a result set (none, single or multi rows)
		(*gds.Call()->m_dsql_execute)(status.Self(), mTransaction->GetHandlePtr(),
			&mHandle, 1, mInRow == 0 ? 0 : mInRow->Self());
		if (status.Errors())
		{
			//Close();	Commented because Execute error should not free the statement
			std::string context = "Statement::Execute( ";
			context.append(mSql).append(" )");
			throw SQLExceptionImpl(status, context.c_str(),
				_("isc_dsql_execute failed"));
		}
		if (mOutRow != 0)
		{
			mResultSetAvailable = true;
			mCursorOpened = true;
                        mIsSingleResult = false;
                        mIsSingleResultDone = false;
		}
	}
        else
            if((mType == IBPP::stExecProcedure) && (mOutRow->Columns() != 0))
        {
            (*gds.Call()->m_dsql_execute)(status.Self(), mTransaction->GetHandlePtr(),
                    &mHandle, 1, mInRow == 0 ? 0 : mInRow->Self());
            if (status.Errors())
            {
                    //Close();	Commented because Execute error should not free the statement
                    std::string context = "Statement::Execute( ";
                    context.append(mSql).append(" )");
                    throw SQLExceptionImpl(status, context.c_str(),
                            _("isc_dsql_execute failed"));
            }
            if (mOutRow != 0)
            {
                mIsSingleResult = true;
                mIsSingleResultDone = false;
            }
        }
        else
	{
		// Should return at most a single row
                (*gds.Call()->m_dsql_execute2)(status.Self(), mTransaction->GetHandlePtr(),
			&mHandle, 1, mInRow == 0 ? 0 : mInRow->Self(),
			mOutRow == 0 ? 0 : mOutRow->Self());                
		if (status.Errors())
		{
			//Close();	Commented because Execute error should not free the statement
			std::string context = "Statement::Execute( ";
			context.append(mSql).append(" )");
			throw SQLExceptionImpl(status, context.c_str(),
				_("isc_dsql_execute2 failed"));
		}
	}
}

int main(int argc, char *argv[])
{
    IBPP::Database db1;
    db1 = IBPP::DatabaseFactory("localhost", "D:\\projects\\test\\realtyad.fdb", "sysdba", "masterkey");
    db1->Connect();
    IBPP::Transaction tr1 = IBPP::TransactionFactory(db1,
                            IBPP::amWrite, IBPP::ilConcurrency, IBPP::lrWait);
    tr1->Start();
    IBPP::Statement st1 = IBPP::StatementFactory(db1, tr1);
    st1->Execute("insert into R (NAME, PHONE1) values ('John Doe', '58-29-58') returning ID");
    tr1->Commit();

    int test_id;
    st1->Get(1, test_id);
    std::cout << "returned id is " << test_id << std::endl;
    db1->Disconnect();
    return 0;
}

bool QIBaseResult::gotoNext(QSqlCachedResult::ValueCache& row, int rowIdx)
{
    ISC_STATUS stat = 0;

    // Stored Procedures are special - they populate our d->sqlda when executing,
    // so we don't have to call isc_dsql_fetch
    if (d->queryType == isc_info_sql_stmt_exec_procedure) {
        // the first "fetch" shall succeed, all consecutive ones will fail since
        // we only have one row to fetch for stored procedures

        if (rp->iSt->IsNull(i))
        {
            // null value
            QVariant v;
            v.convert(qIBPPTypeName(rp->iSt->ColumnType(i)));
            row[idx] = v;
            continue;
        }

Value:  QVariant(, )

        QSqlQuery q("INSERT INTO SYS$ACTIONS(ID,CAPTION) VALUES(NULL,'CAPTION') RETURNING ID",db);
        while(q.next())
            qDebug() << "Value: " << q.value(0);

строки 681-697

    bool stat = true;

    if (IBPP::stExecProcedure == rp->iSt->Type())
    {
    	if (0 != rowIdx)
    		stat = false;
    }
    else
        try
        {
            stat = rp->iSt->Fetch();
        }
        catch (IBPP::Exception& e)
        {
            rp->setError("Could not fetch next item", e, QSqlError::StatementError);
            return false;
        }

строка 410

        iss = (iSt->Type() == IBPP::stSelect || (iSt->Type() == IBPP::stExecProcedure && 0 < iSt->Columns()));

        QSqlQuery q("INSERT INTO SYS$ACTIONS(ID,CAPTION) VALUES(NULL,'CAPTION') RETURNING ID",db);
        QSqlQuery q("SELECT ID FROM SYS$ACTIONS",db);
        while(q.next())
            qDebug() << "Value: " << q.value(0);

SET TERM ^ ;

CREATE OR ALTER PROCEDURE SYS$UIDGENERATOR (
    UIDNAME VARCHAR(40))
RETURNS (
    UID BIGINT)
AS
DECLARE VARIABLE TEMPUID BIGINT;
begin
  SELECT VAL FROM SYS$UIDS WHERE ID = :UIDNAME INTO :TEMPUID;
  UPDATE SYS$UIDS SET VAL = :TEMPUID + 1  WHERE ID = :UIDNAME;
  UID = :TEMPUID;
  SUSPEND;
end^

SET TERM ; ^

GRANT SELECT,UPDATE ON SYS$UIDS TO PROCEDURE SYS$UIDGENERATOR;

GRANT EXECUTE ON PROCEDURE SYS$UIDGENERATOR TO SYSDBA;

CREATE TABLE SYS$UIDS (
    ID   VARCHAR(40),
    VAL  BIGINT DEFAULT 0 NOT NULL
);

as
begin
  if (new.id is null) then
    new.id = gen_id(gen_r_id,1);
end

/******************************************************************************/
/***               Generated by IBExpert 26.03.2010 21:36:59                ***/
/******************************************************************************/

SET SQL DIALECT 3;

SET NAMES NONE;



/******************************************************************************/
/***                                 Tables                                 ***/
/******************************************************************************/


CREATE GENERATOR GEN_REPORTS_ID;

CREATE TABLE REPORTS (
    REPORTID      INTEGER NOT NULL,
    REPORTNAME    INTEGER,
    REPORTSOURCE  VARCHAR(255),
    REPORTBODY    BLOB SUB_TYPE 1 SEGMENT SIZE 16384,
    REPORTPARAMS  VARCHAR(255)
);




/******************************************************************************/
/***                                Triggers                                ***/
/******************************************************************************/


SET TERM ^ ;


/******************************************************************************/
/***                          Triggers for tables                           ***/
/******************************************************************************/



/* Trigger: REPORTS_BI */
CREATE OR ALTER TRIGGER REPORTS_BI FOR REPORTS
ACTIVE BEFORE INSERT POSITION 0
AS
BEGIN
  IF (NEW.REPORTID IS NULL) THEN
    NEW.REPORTID = GEN_ID(GEN_REPORTS_ID,1);
END
^


SET TERM ; ^



/******************************************************************************/
/***                               Privileges                               ***/
/******************************************************************************/

#include "core/ibpp.h"
#include <iostream>
#include <string>
int main(int argc, char *argv[])
{
    IBPP::Database db1;
    db1 = IBPP::DatabaseFactory("localhost", "D:\\bookstore.fdb", "sysdba", "masterkey");
    db1->Connect();
    IBPP::Transaction tr1 = IBPP::TransactionFactory(db1,
                            IBPP::amWrite, IBPP::ilConcurrency, IBPP::lrWait);
    tr1->Start();
    IBPP::Statement st1 = IBPP::StatementFactory(db1, tr1);
    st1->Execute("INSERT INTO REPORTS(REPORTID,REPORTNAME) VALUES(NULL,11) RETURNING REPORTID");
    tr1->Commit();

    int test_id = -1024;
    st1->Get(1, test_id);
    std::cout << "returned id is " << test_id << std::endl;
    db1->Disconnect();
    return 0;
}

        dp->iDb->Connect();
    }
    catch (IBPP::Exception& e)
    {
        if (db.indexOf(QRegExp(QLatin1String("[\\\\/]"))) != -1
            && !QFile::exists(db)) {
            // possibly file path
            try {
                dp->iDb->Create(3);
                dp->iDb->Connect();

                setOpen(true);
                return true;
            }
            catch (IBPP::Exception& e) {
                setOpenError(true);
                dp->setError("Unable to create and connect", e, QSqlError::ConnectionError);
                return false;
            }
        }

        setOpenError(true);
        dp->setError("Unable to connect", e, QSqlError::ConnectionError);
        return false;
    }

CREATE TABLE Journal
( IDX INTEGER NOT NULL PRIMARY KEY,
  DTTM TIMESTAMP NOT NULL,
  WHOSEND VARCHAR(10) NOT NULL,
  NAME VARCHAR(50) NOT NULL,
  MESS VARCHAR(50) NOT NULL);

"INSERT INTO Journal (DTTM,WHOSEND,NAME,MESS) VALUES ('NOW',:WHOSEND,:NAME,:MESSAGE)"

"select DTTM, WHOSEND, NAME, MESS from JOURNAL ORDER BY IDX ASC"

query.value(0).toDateTime().toString("dd.MM.yy hh:mm:ss")

HEADERS += $$PWD/core/ibpp.h \
    $$PWD/core/ibpp.h \
    $$PWD/core/iberror.h \
    $$PWD/core/ibase.h \
    $$PWD/core/_ibpp.h \
    $$PWD/core/ibpp.h \
    $$PWD/core/iberror.h \
    $$PWD/core/ibase.h \
    $$PWD/core/_ibpp.h \
    $$PWD/core/ibpp.h \
    $$PWD/core/iberror.h \
    $$PWD/core/ibase.h \
    $$PWD/core/_ibpp.h
SOURCES += $$PWD/core/all_in_one.cpp \
    $$PWD/core/transaction.cpp \
    $$PWD/core/time.cpp \
    $$PWD/core/statement.cpp \
    $$PWD/core/service.cpp \
    $$PWD/core/row.cpp \
    $$PWD/core/exception.cpp \
    $$PWD/core/events.cpp \
    $$PWD/core/dbkey.cpp \
    $$PWD/core/date.cpp \
    $$PWD/core/database.cpp \
    $$PWD/core/blob.cpp \
    $$PWD/core/array.cpp \
    $$PWD/core/all_in_one.cpp \
    $$PWD/core/_tpb.cpp \
    $$PWD/core/_spb.cpp \
    $$PWD/core/_rb.cpp \
    $$PWD/core/_ibs.cpp \
    $$PWD/core/_ibpp.cpp \
    $$PWD/core/_dpb.cpp \
    $$PWD/core/user.cpp

build/debug/all_in_one.o:all_in_one.cpp::-1: error: multiple definition of `ibpp_internals::DPB::BUFFERINCR'

#include <cstring>

q.exec("execute procedure GET_AGENCY_NAME")
...
q.first();
qDebug() << q.value(0);

    // Stored Procedures are special - they populate our d->sqlda when executing,
    // so we don't have to call isc_dsql_fetch

q.exec("insert into RNAMES (NAME) values (:NAME) returning ID");

    QSqlQuery q(db);
    q.exec("select id, name from dir d");
    q.next();
    QUuid uid=q.value(0).value<QUuid>();

    QUuid id;
    QSqlQuery q(db);
    db.transaction();
    q.prepare("select dscr from dir where id=?");
    q.bindValue(0,QVariant::fromValue(id));

#define VUUID(variant) variant.value<QUuid>()

QUuid uid=VUUID(q.value(0));

QUuid uid=q.value(0).value<QUuid>();

CHAR_TO_UUID
Function:
    Converts the CHAR(32) ASCII representation of an UUID
    (XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX) to the CHAR(16) OCTETS
    representation (optimized for storage).
Format:
    CHAR_TO_UUID( <string> )
Example:
    select char_to_uuid('93519227-8D50-4E47-81AA-8F6678C096A1') from rdb$database;

#include <qsqldriverplugin.h>
#include <qstringlist.h>
#include "qsql_ibpp.h"

#include <QDebug>

class QFBDriverPlugin : public QSqlDriverPlugin
{
	Q_PLUGIN_METADATA( IID "org.qt-project.Qt.QSqlDriverFactoryInterface" )
public:
	QFBDriverPlugin();

	QSqlDriver* create(const QString &);
	QStringList keys() const;
};

QFBDriverPlugin::QFBDriverPlugin()
	: QSqlDriverPlugin()
{
	qDebug() << "111";
}

QSqlDriver* QFBDriverPlugin::create(const QString &name)
{
	qDebug() << "222";

	if (name == QLatin1String("QFIREBIRD")) {
        QFBDriver* driver = new QFBDriver();
        return driver;
    }
    return 0;
}

QStringList QFBDriverPlugin::keys() const
{
	qDebug() << "333";

	QStringList l;
	l  << QLatin1String("QFIREBIRD");
    return l;
}

static QDateTime fromIBPPTimeStamp(IBPP::Timestamp &dt)
{
    int y,m,d,h,min,s,ms;
    dt.GetDate(y,m,d);
    dt.GetTime(h,min,s,ms);
    return QDateTime(QDate(y,m,d), QTime(h,min,s,ms/10));
}

static QDateTime fromTimeStamp(char *buffer)
{
    static const QDate bd(1858, 11, 17);
    // !!!! QTime t;
    QTime t(0,0,0,0);
    QDate d;

static QTime fromTime(char *buffer)

    if (!rp->isSelect())
        rp->commit();

    if (!localTransaction)
        return true;

DEPENDPATH  += $$PWD/core
INCLUDEPATH += $$PWD/core
HEADERS     += $$PWD/core/ibpp.h
SOURCES     += $$PWD/core/all_in_one.cpp

unix{
  #LIBS    += -lfbclient  <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< вот тут
  DEFINES += IBPP_LINUX
  DEFINES += IBPP_GCC
}