File indexing completed on 2022-11-29 19:02:21

0001 /* This file is part of the KDE project
0002    Copyright (C) 2016 Jarosław Staniek <staniek@kde.org>
0003 
0004    This program is free software; you can redistribute it and/or
0005    modify it under the terms of the GNU Library General Public
0006    License as published by the Free Software Foundation; either
0007    version 2 of the License, or (at your option) any later version.
0008 
0009    This program is distributed in the hope that it will be useful,
0010    but WITHOUT ANY WARRANTY; without even the implied warranty of
0011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
0012    Library General Public License for more details.
0013 
0014    You should have received a copy of the GNU Library General Public License
0015    along with this program; see the file COPYING.  If not, write to
0016    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
0017  * Boston, MA 02110-1301, USA.
0018 */
0019 
0020 #ifndef KDB_CONNECTIONPROXY_H
0021 #define KDB_CONNECTIONPROXY_H
0022 
0023 #include <KDbConnection>
0024 
0025 //! The KDbConnectionProxy class gives access to protected (low-level) API of KDbConnection
0026 /**
0027  * The connection object specified in constructor of the proxy is called a parent connection.
0028  * All inherited methods of the KDbConnection API call equivalent methods of the parent
0029  * connection. The KDbConnectionProxy class also provides non-virtual methods that are
0030  * equivalent to KDbConnection ones. These KDbConnection's equivalent methods are called
0031  * by the proxy too.
0032  *
0033  * Example use of this class is Kexi's database database migration plugins when the source
0034  * database is only accessibly using low-level routines.
0035  */
0036 class KDB_EXPORT KDbConnectionProxy : protected KDbConnection
0037 {
0038 public:
0039     //! Creates a proxy object for parent @a connection.
0040     //! @a connection must not be @c nullptr.
0041     //! It is owned by this proxy unless setConnectionIsOwned(false) is called.
0042     explicit KDbConnectionProxy(KDbConnection *connection);
0043 
0044     //! Deletes this proxy. Owned connection is closed and destroyed.
0045     ~KDbConnectionProxy() override;
0046 
0047     //! @return parent connection for this proxy
0048     KDbConnection *parentConnection();
0049 
0050     //! @overload KDbConnection *parentConnection()
0051     const KDbConnection *parentConnection() const;
0052 
0053     //! Control owhership of parent connection that is assigned to this proxy.
0054     //! Owned connection is closed and destroyed upon destruction of the KDbConnectionProxy
0055     //! object.
0056     void setParentConnectionIsOwned(bool set);
0057 
0058     KDbConnectionData data() const;
0059 
0060     KDbDriver* driver() const;
0061 
0062     bool connect();
0063 
0064     bool isConnected() const;
0065 
0066     bool isDatabaseUsed() const;
0067 
0068     KDbConnectionOptions *options();
0069 
0070     void clearResult();
0071 
0072     KDbResult result() const;
0073 
0074     KDbResultable resultable() const;
0075 
0076     bool disconnect();
0077 
0078     QStringList databaseNames(bool also_system_db = false);
0079 
0080     bool databaseExists(const QString &dbName, bool ignoreErrors = true);
0081 
0082     bool createDatabase(const QString &dbName);
0083 
0084     bool useDatabase(const QString &dbName = QString(), bool kexiCompatible = true, bool *cancelled = nullptr,
0085                      KDbMessageHandler* msgHandler = nullptr);
0086 
0087     bool closeDatabase();
0088 
0089     QString currentDatabase() const;
0090 
0091     bool dropDatabase(const QString &dbName = QString());
0092 
0093     QStringList objectNames(int objectType = KDb::AnyObjectType, bool* ok = nullptr);
0094 
0095     QStringList tableNames(bool alsoSystemTables = false, bool* ok = nullptr);
0096 
0097     tristate containsTable(const QString &tableName);
0098 
0099     KDbServerVersionInfo serverVersion() const;
0100 
0101     KDbVersionInfo databaseVersion() const;
0102 
0103     KDbProperties databaseProperties() const;
0104 
0105     QList<int> tableIds(bool* ok = nullptr);
0106 
0107     QList<int> queryIds(bool* ok = nullptr);
0108 
0109     QList<int> objectIds(int objectType, bool* ok = nullptr);
0110 
0111     KDbTransaction beginTransaction();
0112 
0113     bool commitTransaction(KDbTransaction trans = KDbTransaction(),
0114                            KDbTransaction::CommitOptions options = KDbTransaction::CommitOptions());
0115 
0116     bool rollbackTransaction(KDbTransaction trans = KDbTransaction(),
0117                              KDbTransaction::CommitOptions options = KDbTransaction::CommitOptions());
0118 
0119     KDbTransaction defaultTransaction() const;
0120 
0121     void setDefaultTransaction(const KDbTransaction& trans);
0122 
0123     QList<KDbTransaction> transactions();
0124 
0125     bool autoCommit() const;
0126 
0127     bool setAutoCommit(bool on);
0128 
0129     KDbEscapedString escapeString(const QString& str) const override;
0130 
0131     KDbCursor *prepareQuery(const KDbEscapedString &sql,
0132                             KDbCursor::Options options = KDbCursor::Option::None) override;
0133 
0134     KDbCursor *prepareQuery(KDbQuerySchema *query,
0135                             KDbCursor::Options options = KDbCursor::Option::None) override;
0136 
0137     KDbCursor *prepareQuery(KDbTableSchema *table,
0138                             KDbCursor::Options options = KDbCursor::Option::None);
0139 
0140     KDbCursor *executeQuery(const KDbEscapedString &sql,
0141                             KDbCursor::Options options = KDbCursor::Option::None);
0142 
0143     KDbCursor* executeQuery(KDbQuerySchema* query, const QList<QVariant>& params,
0144                             KDbCursor::Options options = KDbCursor::Option::None);
0145 
0146     KDbCursor* executeQuery(KDbQuerySchema* query, KDbCursor::Options options = KDbCursor::Option::None);
0147 
0148     KDbCursor* executeQuery(KDbTableSchema* table, KDbCursor::Options options = KDbCursor::Option::None);
0149 
0150     bool deleteCursor(KDbCursor *cursor);
0151 
0152     KDbTableSchema* tableSchema(int tableId);
0153 
0154     KDbTableSchema* tableSchema(const QString& tableName);
0155 
0156     KDbQuerySchema* querySchema(int queryId);
0157 
0158     KDbQuerySchema* querySchema(const QString& queryName);
0159 
0160     bool setQuerySchemaObsolete(const QString& queryName);
0161 
0162     tristate querySingleRecord(const KDbEscapedString& sql, KDbRecordData* data,
0163                                QueryRecordOptions options = QueryRecordOption::Default);
0164 
0165     tristate querySingleRecord(KDbQuerySchema* query, KDbRecordData* data,
0166                                QueryRecordOptions options = QueryRecordOption::Default);
0167 
0168     tristate querySingleRecord(KDbQuerySchema* query, KDbRecordData* data,
0169                                const QList<QVariant>& params,
0170                                QueryRecordOptions options = QueryRecordOption::Default);
0171 
0172     tristate querySingleString(const KDbEscapedString& sql, QString* value, int column = 0,
0173                                QueryRecordOptions options = QueryRecordOption::Default);
0174 
0175     tristate querySingleString(KDbQuerySchema* query, QString* value, int column = 0,
0176                                QueryRecordOptions options = QueryRecordOption::Default);
0177 
0178     tristate querySingleString(KDbQuerySchema* query, QString* value,
0179                                const QList<QVariant>& params, int column = 0,
0180                                QueryRecordOptions options = QueryRecordOption::Default);
0181 
0182     tristate querySingleNumber(const KDbEscapedString& sql, int* number, int column = 0,
0183                                QueryRecordOptions options = QueryRecordOption::Default);
0184 
0185      tristate querySingleNumber(KDbQuerySchema* query, int* number, int column = 0,
0186                                 QueryRecordOptions options = QueryRecordOption::Default);
0187 
0188     tristate querySingleNumber(KDbQuerySchema* query, int* number,
0189                                const QList<QVariant>& params, int column = 0,
0190                                QueryRecordOptions options = QueryRecordOption::Default);
0191 
0192     bool queryStringList(const KDbEscapedString& sql, QStringList* list, int column = 0);
0193 
0194     bool queryStringList(KDbQuerySchema* query, QStringList* list, int column = 0);
0195 
0196     bool queryStringList(KDbQuerySchema* query, QStringList* list,
0197                          const QList<QVariant>& params, int column = 0);
0198 
0199     tristate resultExists(const KDbEscapedString &sql, QueryRecordOptions options
0200                           = QueryRecordOption::Default);
0201 
0202     tristate isEmpty(KDbTableSchema* table);
0203 
0204     KDbEscapedString recentSqlString() const override;
0205 
0206     //PROTOTYPE:
0207 #define A , const QVariant&
0208 #define H_INS_REC(args) bool insertRecord(KDbTableSchema* tableSchema args)
0209 #define H_INS_REC_ALL \
0210     H_INS_REC(A); \
0211     H_INS_REC(A A); \
0212     H_INS_REC(A A A); \
0213     H_INS_REC(A A A A); \
0214     H_INS_REC(A A A A A); \
0215     H_INS_REC(A A A A A A); \
0216     H_INS_REC(A A A A A A A); \
0217     H_INS_REC(A A A A A A A A)
0218     H_INS_REC_ALL;
0219 
0220 #undef H_INS_REC
0221 #define H_INS_REC(args) bool insertRecord(KDbFieldList* fields args)
0222 
0223     H_INS_REC_ALL;
0224 #undef H_INS_REC_ALL
0225 #undef H_INS_REC
0226 #undef A
0227 
0228     bool insertRecord(KDbTableSchema* tableSchema, const QList<QVariant>& values);
0229 
0230     bool insertRecord(KDbFieldList* fields, const QList<QVariant>& values);
0231 
0232     bool createTable(KDbTableSchema *tableSchema,
0233                      CreateTableOptions options = CreateTableOption::Default);
0234 
0235     KDbTableSchema *copyTable(const KDbTableSchema &tableSchema, const KDbObject &newData);
0236 
0237     KDbTableSchema *copyTable(const QString& tableName, const KDbObject &newData);
0238 
0239     tristate dropTable(KDbTableSchema* tableSchema);
0240 
0241     tristate dropTable(const QString& tableName);
0242 
0243     tristate alterTable(KDbTableSchema* tableSchema, KDbTableSchema* newTableSchema);
0244 
0245     bool alterTableName(KDbTableSchema* tableSchema, const QString& newName,
0246                         AlterTableNameOptions options = AlterTableNameOption::Default);
0247 
0248     bool dropQuery(KDbQuerySchema* querySchema);
0249 
0250     bool dropQuery(const QString& queryName);
0251 
0252     bool removeObject(int objId);
0253 
0254     KDbField* findSystemFieldName(const KDbFieldList& fieldlist);
0255 
0256     QString anyAvailableDatabaseName() override;
0257 
0258     void setAvailableDatabaseName(const QString& dbName);
0259 
0260     bool useTemporaryDatabaseIfNeeded(QString* name);
0261 
0262     Q_REQUIRED_RESULT QSharedPointer<KDbSqlResult> prepareSql(const KDbEscapedString& sql);
0263 
0264     bool executeSql(const KDbEscapedString& sql);
0265 
0266     bool storeObjectData(KDbObject* object);
0267 
0268     bool storeNewObjectData(KDbObject* object);
0269 
0270     //! @since 3.1
0271     tristate loadObjectData(int type, int id, KDbObject* object);
0272 
0273     tristate loadObjectData(int type, const QString& name, KDbObject* object);
0274 
0275     tristate loadDataBlock(int objectID, QString* dataString, const QString& dataID = QString());
0276 
0277     bool storeDataBlock(int objectID, const QString &dataString,
0278                         const QString& dataID = QString());
0279 
0280     bool copyDataBlock(int sourceObjectID, int destObjectID, const QString& dataID = QString());
0281 
0282     bool removeDataBlock(int objectID, const QString& dataID = QString());
0283 
0284     KDbPreparedStatement prepareStatement(KDbPreparedStatement::Type type,
0285         KDbFieldList* fields, const QStringList& whereFieldNames = QStringList());
0286 
0287     bool isInternalTableSchema(const QString& tableName);
0288 
0289     QString escapeIdentifier(const QString& id) const override;
0290 
0291     bool drv_connect() override;
0292 
0293     bool drv_disconnect() override;
0294 
0295     bool drv_getServerVersion(KDbServerVersionInfo* version) override;
0296 
0297     /**
0298      * @since 3.2
0299      */
0300     QStringList drv_getTableNames(bool *ok) override;
0301 
0302     tristate drv_containsTable(const QString &tableName) override;
0303 
0304     bool drv_createTable(const KDbTableSchema& tableSchema) override;
0305 
0306     bool drv_alterTableName(KDbTableSchema* tableSchema, const QString& newName) override;
0307 
0308     bool drv_copyTableData(const KDbTableSchema &tableSchema,
0309                            const KDbTableSchema &destinationTableSchema) override;
0310 
0311     bool drv_dropTable(const QString& tableName) override;
0312 
0313     tristate dropTableInternal(KDbTableSchema* tableSchema, bool alsoRemoveSchema);
0314 
0315     bool setupObjectData(const KDbRecordData& data, KDbObject* object);
0316 
0317     KDbField* setupField(const KDbRecordData& data);
0318 
0319     Q_REQUIRED_RESULT KDbSqlResult *drv_prepareSql(const KDbEscapedString &sql) override;
0320 
0321     bool drv_executeSql(const KDbEscapedString& sql) override;
0322 
0323     bool drv_getDatabasesList(QStringList* list) override;
0324 
0325     bool drv_databaseExists(const QString &dbName, bool ignoreErrors = true) override;
0326 
0327     bool drv_createDatabase(const QString &dbName = QString()) override;
0328 
0329     bool drv_useDatabase(const QString &dbName = QString(), bool *cancelled = nullptr,
0330                          KDbMessageHandler* msgHandler = nullptr) override;
0331 
0332     bool drv_closeDatabase() override;
0333 
0334     bool drv_isDatabaseUsed() const override;
0335 
0336     bool drv_dropDatabase(const QString &dbName = QString()) override;
0337 
0338     bool drv_createTable(const QString& tableName) override;
0339 
0340     KDbTransactionData* drv_beginTransaction() override;
0341 
0342     bool drv_commitTransaction(KDbTransactionData* trans) override;
0343 
0344     bool drv_rollbackTransaction(KDbTransactionData* trans) override;
0345 
0346     bool drv_beforeInsert(const QString& tableName, KDbFieldList* fields) override;
0347 
0348     bool drv_afterInsert(const QString& tableName, KDbFieldList* fields) override;
0349 
0350     bool drv_beforeUpdate(const QString& tableName, KDbFieldList* fields) override;
0351 
0352     bool drv_afterUpdate(const QString& tableName, KDbFieldList* fields) override;
0353 
0354     bool drv_setAutoCommit(bool on) override;
0355 
0356     KDbPreparedStatementInterface* prepareStatementInternal() override;
0357 
0358     bool beginAutoCommitTransaction(KDbTransactionGuard* tg);
0359 
0360     bool commitAutoCommitTransaction(const KDbTransaction& trans);
0361 
0362     bool rollbackAutoCommitTransaction(const KDbTransaction& trans);
0363 
0364     bool checkConnected();
0365 
0366     bool checkIsDatabaseUsed();
0367 
0368     bool updateRecord(KDbQuerySchema* query, KDbRecordData* data, KDbRecordEditBuffer* buf, bool useRecordId = false);
0369 
0370     bool insertRecord(KDbQuerySchema* query, KDbRecordData* data, KDbRecordEditBuffer* buf, bool getRecordId = false);
0371 
0372     bool deleteRecord(KDbQuerySchema* query, KDbRecordData* data, bool useRecordId = false);
0373 
0374     bool deleteAllRecords(KDbQuerySchema* query);
0375 
0376     bool checkIfColumnExists(KDbCursor *cursor, int column);
0377 
0378     tristate querySingleRecordInternal(KDbRecordData* data, const KDbEscapedString* sql,
0379                                        KDbQuerySchema* query, const QList<QVariant>* params,
0380                                        QueryRecordOptions options);
0381 
0382     tristate querySingleStringInternal(const KDbEscapedString* sql, QString* value,
0383                                        KDbQuerySchema* query, const QList<QVariant>* params,
0384                                        int column, QueryRecordOptions options);
0385 
0386     tristate querySingleNumberInternal(const KDbEscapedString* sql, int* number,
0387                                        KDbQuerySchema* query, const QList<QVariant>* params,
0388                                        int column, QueryRecordOptions options);
0389 
0390     bool queryStringListInternal(const KDbEscapedString *sql, QStringList* list,
0391                                  KDbQuerySchema* query, const QList<QVariant>* params,
0392                                  int column, bool (*filterFunction)(const QString&));
0393 
0394     KDbCursor* executeQueryInternal(const KDbEscapedString& sql, KDbQuerySchema* query,
0395                                     const QList<QVariant>* params);
0396 
0397     bool loadExtendedTableSchemaData(KDbTableSchema* tableSchema);
0398 
0399     bool storeExtendedTableSchemaData(KDbTableSchema* tableSchema);
0400 
0401     bool storeMainFieldSchema(KDbField *field);
0402 
0403 private:
0404     Q_DISABLE_COPY(KDbConnectionProxy)
0405     class Private;
0406     Private * const d;
0407 };
0408 
0409 #endif