firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-01-25 02:03:03 +01:00
Code Issues
c7bfd949f7
firebird-mirror/src/jrd/EngineInterface.h

494 lines
16 KiB
C
Raw Normal View History

1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
/*
* The contents of this file are subject to the Initial
* Developer's Public License Version 1.0 (the "License");
* you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
* http://www.ibphoenix.com/main.nfs?a=ibphoenix&page=ibp_idpl.
*
* Software distributed under the License is distributed AS IS,
* WITHOUT WARRANTY OF ANY KIND, either express or implied.
* See the License for the specific language governing rights
* and limitations under the License.
*
* The Original Code was created by Alex Peshkov
* for the Firebird Open Source RDBMS project.
*
* Copyright (c) 2011 Alex Peshkov <peshkoff@mail.ru>
* and all contributors signed below.
*
* All Rights Reserved.
* Contributor(s): ______________________________________.
*/
#ifndef JRD_ENGINE_INTERFACE_H
#define JRD_ENGINE_INTERFACE_H
Move v3 public include files to src/include/firebird.
2011-06-02 17:57:08 +02:00
#include "firebird/Provider.h"
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
#include "../common/classes/ImplementHelper.h"
#include "../common/StatementMetadata.h"
#include "../common/classes/RefCounted.h"
Added support for changing configuration (client and embedded) from API
2013-04-04 15:17:57 +02:00
#define CURRENT_ENGINE "Engine12"
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
namespace Jrd {
// Engine objects used by interface objects
class blb;
class jrd_tra;
class dsql_req;
class JrdStatement;
class Attachment;
class Service;
// forward declarations
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
class JStatement;
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
class JAttachment;
class JProvider;
Better interfaces hierarchy: all of them are derived from IVersioned
2011-05-19 18:24:46 +02:00
class JBlob : public Firebird::RefCntIface<Firebird::IBlob, FB_BLOB_VERSION>
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
public:
// IBlob implementation
virtual int FB_CARG release();
virtual void FB_CARG getInfo(Firebird::IStatus* status,
unsigned int itemsLength, const unsigned char* items,
unsigned int bufferLength, unsigned char* buffer);
virtual unsigned int FB_CARG getSegment(Firebird::IStatus* status, unsigned int length, void* buffer); // returns real length
virtual void FB_CARG putSegment(Firebird::IStatus* status, unsigned int length, const void* buffer);
virtual void FB_CARG cancel(Firebird::IStatus* status);
virtual void FB_CARG close(Firebird::IStatus* status);
virtual int FB_CARG seek(Firebird::IStatus* status, int mode, int offset); // returns position
public:
Misc; reinterpret to static casts; correction in YRequest version.
2011-04-26 03:00:33 +02:00
JBlob(blb* handle, JAttachment* ja)
: blob(handle), jAtt(ja)
{
}
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
JAttachment* getAttachment()
{
return jAtt;
}
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
blb* getHandle() throw()
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
return blob;
}
private:
blb* blob;
Firebird::RefPtr<JAttachment> jAtt;
void freeEngineData(Firebird::IStatus* status);
};
Better interfaces hierarchy: all of them are derived from IVersioned
2011-05-19 18:24:46 +02:00
class JTransaction : public Firebird::RefCntIface<Firebird::ITransaction, FB_TRANSACTION_VERSION>
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
public:
// ITransaction implementation
virtual int FB_CARG release();
virtual void FB_CARG getInfo(Firebird::IStatus* status,
unsigned int itemsLength, const unsigned char* items,
unsigned int bufferLength, unsigned char* buffer);
virtual void FB_CARG prepare(Firebird::IStatus* status,
unsigned int msg_length = 0, const unsigned char* message = 0);
virtual void FB_CARG commit(Firebird::IStatus* status);
virtual void FB_CARG commitRetaining(Firebird::IStatus* status);
virtual void FB_CARG rollback(Firebird::IStatus* status);
virtual void FB_CARG rollbackRetaining(Firebird::IStatus* status);
virtual void FB_CARG disconnect(Firebird::IStatus* status);
Interface for 2PC (distributed transactions coordinator)
2011-05-19 13:38:38 +02:00
virtual Firebird::ITransaction* FB_CARG join(Firebird::IStatus* status, Firebird::ITransaction* transaction);
virtual JTransaction* FB_CARG validate(Firebird::IStatus* status, Firebird::IAttachment* testAtt);
virtual JTransaction* FB_CARG enterDtc(Firebird::IStatus* status);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
public:
Misc; reinterpret to static casts; correction in YRequest version.
2011-04-26 03:00:33 +02:00
JTransaction(jrd_tra* handle, JAttachment* ja)
: transaction(handle), jAtt(ja)
{
}
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
jrd_tra* getHandle() throw()
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
return transaction;
}
void setHandle(jrd_tra* handle)
{
transaction = handle;
}
JAttachment* getAttachment()
{
return jAtt;
}
void clear()
{
transaction = NULL;
release();
}
private:
jrd_tra* transaction;
Firebird::RefPtr<JAttachment> jAtt;
Interface for 2PC (distributed transactions coordinator)
2011-05-19 13:38:38 +02:00
JTransaction(JTransaction* from)
: transaction(from->transaction), jAtt(from->jAtt)
{
}
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
void freeEngineData(Firebird::IStatus* status);
};
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
class JResultSet : public Firebird::RefCntIface<Firebird::IResultSet, FB_RESULTSET_VERSION>
{
public:
// IResultSet implementation
virtual int FB_CARG release();
Add interface support for scrollable DSQL cursors. Implementation will follow later.
2013-04-13 09:11:58 +02:00
virtual FB_BOOLEAN FB_CARG fetchNext(Firebird::IStatus* status, void* message);
virtual FB_BOOLEAN FB_CARG fetchPrior(Firebird::IStatus* status, void* message);
virtual FB_BOOLEAN FB_CARG fetchFirst(Firebird::IStatus* status, void* message);
virtual FB_BOOLEAN FB_CARG fetchLast(Firebird::IStatus* status, void* message);
virtual FB_BOOLEAN FB_CARG fetchAbsolute(Firebird::IStatus* status, unsigned int position, void* message);
virtual FB_BOOLEAN FB_CARG fetchRelative(Firebird::IStatus* status, int offset, void* message);
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
virtual FB_BOOLEAN FB_CARG isEof(Firebird::IStatus* status);
Add interface support for scrollable DSQL cursors. Implementation will follow later.
2013-04-13 09:11:58 +02:00
virtual FB_BOOLEAN FB_CARG isBof(Firebird::IStatus* status);
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
virtual Firebird::IMessageMetadata* FB_CARG getMetadata(Firebird::IStatus* status);
virtual void FB_CARG close(Firebird::IStatus* status);
public:
JResultSet(JStatement* aStatement)
: statement(aStatement), eof(false)
{
}
JStatement* getStatement()
{
return statement;
}
JAttachment* getAttachment();
// Change after adding separate handle for cursor in dsql
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
dsql_req* getHandle() throw();
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
private:
Firebird::RefPtr<JStatement> statement;
bool eof;
void freeEngineData(Firebird::IStatus* status);
};
Better interfaces hierarchy: all of them are derived from IVersioned
2011-05-19 18:24:46 +02:00
class JStatement : public Firebird::RefCntIface<Firebird::IStatement, FB_STATEMENT_VERSION>
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
public:
// IStatement implementation
virtual int FB_CARG release();
virtual void FB_CARG getInfo(Firebird::IStatus* status,
unsigned int itemsLength, const unsigned char* items,
unsigned int bufferLength, unsigned char* buffer);
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
virtual void FB_CARG free(Firebird::IStatus* status);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
virtual ISC_UINT64 FB_CARG getAffectedRecords(Firebird::IStatus* userStatus);
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
virtual Firebird::IMessageMetadata* FB_CARG getOutputMetadata(Firebird::IStatus* userStatus);
virtual Firebird::IMessageMetadata* FB_CARG getInputMetadata(Firebird::IStatus* userStatus);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
virtual unsigned FB_CARG getType(Firebird::IStatus* status);
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
virtual const char* FB_CARG getPlan(Firebird::IStatus* status, FB_BOOLEAN detailed);
virtual JTransaction* FB_CARG execute(Firebird::IStatus* status,
Remove FbMessage struct from the API. This struct lost its main value (group various blr-related properties in a single parameter). And since openCursor/fetch already split the message/buffer, it does not make sense anymore to have it.
2013-02-26 04:42:19 +01:00
Firebird::ITransaction* transaction, Firebird::IMessageMetadata* inMetadata, void* inBuffer,
Firebird::IMessageMetadata* outMetadata, void* outBuffer);
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
virtual JResultSet* FB_CARG openCursor(Firebird::IStatus* status,
Remove FbMessage struct from the API. This struct lost its main value (group various blr-related properties in a single parameter). And since openCursor/fetch already split the message/buffer, it does not make sense anymore to have it.
2013-02-26 04:42:19 +01:00
Firebird::ITransaction* transaction, Firebird::IMessageMetadata* inMetadata, void* inBuffer,
Firebird::IMessageMetadata* outMetadata);
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
virtual void FB_CARG setCursorName(Firebird::IStatus* status, const char* name);
Add IStatement::getFlags() to help user make a solution what to do with SQL statement
2013-02-19 12:20:49 +01:00
virtual unsigned FB_CARG getFlags(Firebird::IStatus* status);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
public:
Fixed segfault when releasing IMessageMetadata, reported by Dmitry privately. It was bad idea to return to the user interface created by plugin.
2013-07-19 15:51:54 +02:00
JStatement(dsql_req* handle, JAttachment* ja, Firebird::Array<UCHAR>& meta);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
JAttachment* getAttachment()
{
return jAtt;
}
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
dsql_req* getHandle() throw()
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
return statement;
}
private:
dsql_req* statement;
Firebird::RefPtr<JAttachment> jAtt;
Firebird::StatementMetadata metadata;
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
void freeEngineData(Firebird::IStatus* status);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
};
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
inline JAttachment* JResultSet::getAttachment()
{
return statement->getAttachment();
}
// Change after adding separate handle for cursor in dsql
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
inline dsql_req* JResultSet::getHandle() throw()
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
{
return statement->getHandle();
}
Better interfaces hierarchy: all of them are derived from IVersioned
2011-05-19 18:24:46 +02:00
class JRequest : public Firebird::RefCntIface<Firebird::IRequest, FB_REQUEST_VERSION>
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
public:
// IRequest implementation
virtual int FB_CARG release();
virtual void FB_CARG receive(Firebird::IStatus* status, int level, unsigned int msg_type,
unsigned int length, unsigned char* message);
virtual void FB_CARG send(Firebird::IStatus* status, int level, unsigned int msg_type,
unsigned int length, const unsigned char* message);
virtual void FB_CARG getInfo(Firebird::IStatus* status, int level,
unsigned int itemsLength, const unsigned char* items,
unsigned int bufferLength, unsigned char* buffer);
virtual void FB_CARG start(Firebird::IStatus* status, Firebird::ITransaction* tra, int level);
virtual void FB_CARG startAndSend(Firebird::IStatus* status, Firebird::ITransaction* tra, int level, unsigned int msg_type,
unsigned int length, const unsigned char* message);
virtual void FB_CARG unwind(Firebird::IStatus* status, int level);
virtual void FB_CARG free(Firebird::IStatus* status);
public:
Misc; reinterpret to static casts; correction in YRequest version.
2011-04-26 03:00:33 +02:00
JRequest(JrdStatement* handle, JAttachment* ja)
: rq(handle), jAtt(ja)
{
}
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
JAttachment* getAttachment()
{
return jAtt;
}
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
JrdStatement* getHandle() throw()
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
return rq;
}
private:
JrdStatement* rq;
Firebird::RefPtr<JAttachment> jAtt;
void freeEngineData(Firebird::IStatus* status);
};
Better interfaces hierarchy: all of them are derived from IVersioned
2011-05-19 18:24:46 +02:00
class JEvents : public Firebird::RefCntIface<Firebird::IEvents, FB_EVENTS_VERSION>
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
public:
// IEvents implementation
virtual int FB_CARG release();
virtual void FB_CARG cancel(Firebird::IStatus* status);
public:
Misc; reinterpret to static casts; correction in YRequest version.
2011-04-26 03:00:33 +02:00
JEvents(int aId, JAttachment* ja)
: id(aId), jAtt(ja)
{
}
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
JEvents* getHandle() throw()
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
return this;
}
JAttachment* getAttachment()
{
return jAtt;
}
private:
int id;
Firebird::RefPtr<JAttachment> jAtt;
void freeEngineData(Firebird::IStatus* status);
};
Better interfaces hierarchy: all of them are derived from IVersioned
2011-05-19 18:24:46 +02:00
class JAttachment : public Firebird::RefCntIface<Firebird::IAttachment, FB_ATTACHMENT_VERSION>
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
public:
// IAttachment implementation
virtual int FB_CARG release();
virtual void FB_CARG getInfo(Firebird::IStatus* status,
unsigned int itemsLength, const unsigned char* items,
unsigned int bufferLength, unsigned char* buffer);
Integrate IAttachment and ITransaction in the external engines API.
2011-05-07 21:52:44 +02:00
virtual JTransaction* FB_CARG startTransaction(Firebird::IStatus* status,
unsigned int tpbLength, const unsigned char* tpb);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
virtual JTransaction* FB_CARG reconnectTransaction(Firebird::IStatus* status, unsigned int length, const unsigned char* id);
virtual JRequest* FB_CARG compileRequest(Firebird::IStatus* status, unsigned int blr_length, const unsigned char* blr);
virtual void FB_CARG transactRequest(Firebird::IStatus* status, Firebird::ITransaction* transaction,
unsigned int blr_length, const unsigned char* blr,
unsigned int in_msg_length, const unsigned char* in_msg,
unsigned int out_msg_length, unsigned char* out_msg);
virtual JBlob* FB_CARG createBlob(Firebird::IStatus* status, Firebird::ITransaction* transaction,
ISC_QUAD* id, unsigned int bpbLength = 0, const unsigned char* bpb = 0);
virtual JBlob* FB_CARG openBlob(Firebird::IStatus* status, Firebird::ITransaction* transaction,
ISC_QUAD* id, unsigned int bpbLength = 0, const unsigned char* bpb = 0);
virtual int FB_CARG getSlice(Firebird::IStatus* status, Firebird::ITransaction* transaction, ISC_QUAD* id,
unsigned int sdl_length, const unsigned char* sdl,
unsigned int param_length, const unsigned char* param,
int sliceLength, unsigned char* slice);
virtual void FB_CARG putSlice(Firebird::IStatus* status, Firebird::ITransaction* transaction, ISC_QUAD* id,
unsigned int sdl_length, const unsigned char* sdl,
unsigned int param_length, const unsigned char* param,
int sliceLength, unsigned char* slice);
Better names for API functions
2012-06-26 15:43:26 +02:00
virtual void FB_CARG executeDyn(Firebird::IStatus* status, Firebird::ITransaction* transaction, unsigned int length,
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
const unsigned char* dyn);
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
virtual JStatement* FB_CARG prepare(Firebird::IStatus* status, Firebird::ITransaction* tra,
unsigned int stmtLength, const char* sqlStmt, unsigned int dialect, unsigned int flags);
virtual Firebird::ITransaction* FB_CARG execute(Firebird::IStatus* status,
Firebird::ITransaction* transaction, unsigned int stmtLength, const char* sqlStmt,
Remove FbMessage struct from the API. This struct lost its main value (group various blr-related properties in a single parameter). And since openCursor/fetch already split the message/buffer, it does not make sense anymore to have it.
2013-02-26 04:42:19 +01:00
unsigned int dialect, Firebird::IMessageMetadata* inMetadata, void* inBuffer,
Firebird::IMessageMetadata* outMetadata, void* outBuffer);
Modified IStatement interface in our API: 1. Never allocate empty statement - always use att->prepare() to create statement interface 2. Separated IStatement into 2 parts - statement itself and resultset. 3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet. 4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client, therefore avoiding need in BLR generation in client applications.
2013-02-17 13:08:53 +01:00
virtual Firebird::IResultSet* FB_CARG openCursor(Firebird::IStatus* status,
Firebird::ITransaction* transaction, unsigned int stmtLength, const char* sqlStmt,
Remove FbMessage struct from the API. This struct lost its main value (group various blr-related properties in a single parameter). And since openCursor/fetch already split the message/buffer, it does not make sense anymore to have it.
2013-02-26 04:42:19 +01:00
unsigned int dialect, Firebird::IMessageMetadata* inMetadata, void* inBuffer,
Firebird::IMessageMetadata* outMetadata);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
virtual JEvents* FB_CARG queEvents(Firebird::IStatus* status, Firebird::IEventCallback* callback,
unsigned int length, const unsigned char* events);
virtual void FB_CARG cancelOperation(Firebird::IStatus* status, int option);
virtual void FB_CARG ping(Firebird::IStatus* status);
virtual void FB_CARG detach(Firebird::IStatus* status);
Better names for API functions
2012-06-26 15:43:26 +02:00
virtual void FB_CARG dropDatabase(Firebird::IStatus* status);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
public:
Misc.
2011-06-24 08:34:16 +02:00
explicit JAttachment(Attachment* handle);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
Attachment* getHandle() throw()
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
return att;
}
JAttachment* getAttachment()
{
return this;
}
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
Firebird::Mutex* getMutex(bool useAsync = false, bool forceAsync = false)
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
Misc.
2013-08-18 20:53:41 +02:00
if (useAsync && !forceAsync)
Work in progress (committed due to SF upgrade). Checked only on SS. 1. Frontported fix for CORE-3935 and CORE-3993. 2. Added debugging support for mutexes and rwlocks in Vulcan style. Unfortunately after last 'svn up' build asserts in JrdStatement:71.
2012-12-14 18:59:02 +01:00
{
fb_assert(!mainMutex.locked());
}
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
return useAsync ? &asyncMutex : &mainMutex;
}
void cancel()
{
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
fb_assert(asyncMutex.locked());
fb_assert(mainMutex.locked());
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
att = NULL;
}
Interface for 2PC (distributed transactions coordinator)
2011-05-19 13:38:38 +02:00
JTransaction* getTransactionInterface(Firebird::IStatus* status, Firebird::ITransaction* tra);
jrd_tra* getEngineTransaction(Firebird::IStatus* status, Firebird::ITransaction* tra);
Work in progress (committed due to SF upgrade). Checked only on SS. 1. Frontported fix for CORE-3935 and CORE-3993. 2. Added debugging support for mutexes and rwlocks in Vulcan style. Unfortunately after last 'svn up' build asserts in JrdStatement:71.
2012-12-14 18:59:02 +01:00
void manualLock(ULONG& flags);
void manualUnlock(ULONG& flags);
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
void manualAsyncUnlock(ULONG& flags);
Work in progress (committed due to SF upgrade). Checked only on SS. 1. Frontported fix for CORE-3935 and CORE-3993. 2. Added debugging support for mutexes and rwlocks in Vulcan style. Unfortunately after last 'svn up' build asserts in JrdStatement:71.
2012-12-14 18:59:02 +01:00
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
private:
Attachment* att;
Postfix for CORE-3935 & CORE-3944: helps avoid segfaults/deadlocks when shutting down firebird
2013-08-16 14:44:10 +02:00
// This mutexes guarantee attachment existence. After releasing both of them with possibly
// zero att_use_count one should check does attachment still exists calling getHandle().
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
Firebird::Mutex mainMutex, asyncMutex;
void freeEngineData(Firebird::IStatus* status);
};
Enabled background threads (garbage collector and cache writer). Introduced special kind of system attachments used in this threads and show its activity in monitoring.
2011-05-27 09:57:16 +02:00
// internal class used in system background threads
class SysAttachment : public JAttachment
{
public:
Misc.
2011-06-24 08:34:16 +02:00
explicit SysAttachment(Attachment* handle)
Misc.
2011-05-28 04:05:45 +02:00
: JAttachment(handle)
Enabled background threads (garbage collector and cache writer). Introduced special kind of system attachments used in this threads and show its activity in monitoring.
2011-05-27 09:57:16 +02:00
{
}
Protect system attachments list with dedicated sync object. It prevents deadlocks with common sync object on process shutdown.
2011-10-02 12:19:06 +02:00
void initDone();
Enabled background threads (garbage collector and cache writer). Introduced special kind of system attachments used in this threads and show its activity in monitoring.
2011-05-27 09:57:16 +02:00
virtual int FB_CARG release()
{
if (--refCounter != 0)
return 1;
Attachment* attachment = getHandle();
if (attachment)
{
destroy(attachment);
}
Fixed leak of SysAttachment instance. Noted by Claudio.
2011-06-13 13:09:19 +02:00
delete this;
Enabled background threads (garbage collector and cache writer). Introduced special kind of system attachments used in this threads and show its activity in monitoring.
2011-05-27 09:57:16 +02:00
return 0;
}
private:
void destroy(Attachment* attachment);
};
Better interfaces hierarchy: all of them are derived from IVersioned
2011-05-19 18:24:46 +02:00
class JService : public Firebird::RefCntIface<Firebird::IService, FB_SERVICE_VERSION>
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
public:
// IService implementation
virtual int FB_CARG release();
virtual void FB_CARG detach(Firebird::IStatus* status);
virtual void FB_CARG query(Firebird::IStatus* status,
unsigned int sendLength, const unsigned char* sendItems,
unsigned int receiveLength, const unsigned char* receiveItems,
unsigned int bufferLength, unsigned char* buffer);
virtual void FB_CARG start(Firebird::IStatus* status,
unsigned int spbLength, const unsigned char* spb);
public:
Misc.
2011-06-24 08:34:16 +02:00
explicit JService(Service* handle);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
private:
Service* svc;
void freeEngineData(Firebird::IStatus* status);
};
Better interfaces hierarchy: all of them are derived from IVersioned
2011-05-19 18:24:46 +02:00
class JProvider : public Firebird::StdPlugin<Firebird::IProvider, FB_PROVIDER_VERSION>
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
{
public:
Implemented CORE-4263: Database linger
2013-11-14 17:16:24 +01:00
explicit JProvider(Firebird::IPluginConfig* pConf)
: cryptCallback(NULL), pluginConfig(pConf)
Misc; reinterpret to static casts; correction in YRequest version.
2011-04-26 03:00:33 +02:00
{
}
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
Lets try to avoid global functions using name with mixed new (functionName) and old SUBSYS_name name style.
2011-05-11 19:42:44 +02:00
static Firebird::RefPtr<JProvider> getInstance()
{
Firebird::RefPtr<JProvider> p(new JProvider(NULL));
return p;
}
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
// IProvider implementation
Integrate IAttachment and ITransaction in the external engines API.
2011-05-07 21:52:44 +02:00
virtual JAttachment* FB_CARG attachDatabase(Firebird::IStatus* status, const char* fileName,
unsigned int dpbLength, const unsigned char* dpb);
virtual JAttachment* FB_CARG createDatabase(Firebird::IStatus* status, const char* fileName,
unsigned int dpbLength, const unsigned char* dpb);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
virtual JService* FB_CARG attachServiceManager(Firebird::IStatus* status, const char* service,
Misc; reinterpret to static casts; correction in YRequest version.
2011-04-26 03:00:33 +02:00
unsigned int spbLength, const unsigned char* spb);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
virtual void FB_CARG shutdown(Firebird::IStatus* status, unsigned int timeout, const int reason);
Implemented CORE-3861: Make it possible to encrypt database Also some cleanups, the most important are: - meaningful ctor on Jrd::Lock, helping to avoid code dup - avoid unneeded h-file dependencies, making boot build engine dependent
2012-05-31 18:53:42 +02:00
virtual void FB_CARG setDbCryptCallback(Firebird::IStatus* status,
Firebird::ICryptKeyCallback* cryptCallback);
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
virtual int FB_CARG release();
Implemented CORE-3861: Make it possible to encrypt database Also some cleanups, the most important are: - meaningful ctor on Jrd::Lock, helping to avoid code dup - avoid unneeded h-file dependencies, making boot build engine dependent
2012-05-31 18:53:42 +02:00
private:
Firebird::ICryptKeyCallback* cryptCallback;
Implemented CORE-4263: Database linger
2013-11-14 17:16:24 +01:00
Firebird::IPluginConfig* pluginConfig;
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
};
Fixed segfault when releasing IMessageMetadata, reported by Dmitry privately. It was bad idea to return to the user interface created by plugin.
2013-07-19 15:51:54 +02:00
inline JStatement::JStatement(dsql_req* handle, JAttachment* ja, Firebird::Array<UCHAR>& meta)
: statement(handle), jAtt(ja), metadata(getPool(), this, ja)
{
metadata.parse(meta.getCount(), meta.begin());
}
1. Use reference counted stable in global pool objects instead PublicHandle's validation. 2. Avoid massive segfaults when closing heavily loaded server. 3. Restored logic in YValve required for correct shutdown. 4. Do not change externally visible request body when preparing it.
2011-04-25 19:47:56 +02:00
} // namespace Jrd
#endif // JRD_ENGINE_INTERFACE_H
Copy Permalink