--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/secureswitools/swisistools/source/dbmanager/dbprocessor.h Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,266 @@
+/*
+* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+* scrdatabase.h
+*
+*/
+
+
+/**
+ @file
+ @released
+ @internalTechnology
+*/
+
+#ifndef DBPROCESSOR_H
+#define DBPROCESSOR_H
+
+#pragma warning(disable: 4786)
+#pragma warning(disable: 4273)
+
+#include "./sqlite/sqlite3.h"
+#include "symbiantypes.h"
+#include <string>
+#include <windows.h>
+
+// Forward declarations
+class CStatement;
+
+typedef int (*FnPtr_sqlite3_open)(const char *filename, sqlite3 **ppDb );
+typedef int (*FnPtr_sqlite3_prepare_v2)(sqlite3 *db, const char *zSql, int nByte, sqlite3_stmt **ppStmt, const char **pzTail );
+typedef int (*FnPtr_sqlite3_step)(sqlite3_stmt*);
+typedef int (*FnPtr_sqlite3_finalize)(sqlite3_stmt *pStmt);
+typedef int (*FnPtr_sqlite3_prepare_v2)(sqlite3 *db, const char *zSql, int nByte, sqlite3_stmt **ppStmt, const char **pzTail );
+typedef int (*FnPtr_sqlite3_finalize)(sqlite3_stmt *pStmt);
+typedef int (*FnPtr_sqlite3_bind_text)(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
+typedef int (*FnPtr_sqlite3_bind_text16)(sqlite3_stmt*, int, const void*, int, void(*)(void*));
+typedef int (*FnPtr_sqlite3_bind_int)(sqlite3_stmt*, int, int);
+typedef int (*FnPtr_sqlite3_step)(sqlite3_stmt*);
+typedef int (*FnPtr_sqlite3_reset)(sqlite3_stmt*);
+typedef int (*FnPtr_sqlite3_clear_bindings)(sqlite3_stmt*);
+typedef sqlite3_int64 (*FnPtr_sqlite3_last_insert_rowid)(sqlite3*);
+typedef int (*FnPtr_sqlite3_extended_result_codes) (sqlite3*, int onoff);
+typedef int (*FnPtr_sqlite3_close) (sqlite3 *);
+typedef const char* (*FnPtr_sqlite3_errmsg) (sqlite3*);
+typedef int (*FnPtr_sqlite3_errcode) (sqlite3 *db);
+typedef int (*FnPtr_sqlite3_bind_int64) (sqlite3_stmt*, int, sqlite3_int64);
+typedef const void* (*FnPtr_sqlite3_column_text16) (sqlite3_stmt*, int iCol);
+typedef int (*FnPtr_sqlite3_column_bytes16) (sqlite3_stmt*, int iCol);
+typedef sqlite3_int64 (*FnPtr_sqlite3_column_int64) (sqlite3_stmt*, int iCol);
+typedef int (*FnPtr_sqlite3_column_int) (sqlite3_stmt*, int iCol);
+typedef int (*FnPtr_sqlite3_column_count) (sqlite3_stmt *pStmt);
+typedef int (*FnPtr_sqlite3_column_type) (sqlite3_stmt*, int iCol);
+typedef int (*FnPtr_sqlite3_prepare16_v2) (sqlite3 *db, const void *zSql,int nByte,sqlite3_stmt **ppStmt, const void **pzTail );
+typedef int (*FnPtr_sqlite3_bind_blob) (sqlite3_stmt*, int, const void*, int n, void(*)(void*));
+
+class TDbLibrary
+ {
+ public:
+ ~TDbLibrary();
+ TDbLibrary(const std::string& aDllPath);
+
+ private:
+ void LoadSqlLibrary(const std::string& aDllPath);
+ void LoadFunctions();
+ void VerifyLoadedFunction(void* aFnPtr);
+
+ public:
+ FnPtr_sqlite3_open sqlite3_open;
+ FnPtr_sqlite3_prepare_v2 sqlite3_prepare_v2;
+ FnPtr_sqlite3_step sqlite3_step;
+ FnPtr_sqlite3_finalize sqlite3_finalize;
+ FnPtr_sqlite3_bind_text sqlite3_bind_text;
+ FnPtr_sqlite3_bind_text16 sqlite3_bind_text16;
+ FnPtr_sqlite3_bind_int sqlite3_bind_int;
+ FnPtr_sqlite3_reset sqlite3_reset;
+ FnPtr_sqlite3_clear_bindings sqlite3_clear_bindings;
+ FnPtr_sqlite3_last_insert_rowid sqlite3_last_insert_rowid;
+ FnPtr_sqlite3_extended_result_codes sqlite3_extended_result_codes;
+
+ FnPtr_sqlite3_close sqlite3_close;
+ FnPtr_sqlite3_errmsg sqlite3_errmsg;
+ FnPtr_sqlite3_errcode sqlite3_errcode;
+ FnPtr_sqlite3_bind_int64 sqlite3_bind_int64;
+ FnPtr_sqlite3_column_text16 sqlite3_column_text16;
+ FnPtr_sqlite3_column_bytes16 sqlite3_column_bytes16;
+ FnPtr_sqlite3_column_int64 sqlite3_column_int64;
+ FnPtr_sqlite3_column_int sqlite3_column_int;
+ FnPtr_sqlite3_column_count sqlite3_column_count;
+ FnPtr_sqlite3_column_type sqlite3_column_type;
+ FnPtr_sqlite3_prepare16_v2 sqlite3_prepare16_v2;
+ FnPtr_sqlite3_bind_blob sqlite3_bind_blob;
+
+ private:
+ HINSTANCE sqLiteHndl;
+
+ };
+
+
+/**
+ An instance of this class is used to execute all types of SQL statements with or without
+ parameters.
+*/
+
+class CStatement
+ {
+
+ public:
+
+ /**
+ Creates a new CStatement object on the heap.
+
+ @param aStmtHandle Pointer to the statement handle.
+ @return The newly created CStatement object.
+
+ */
+ CStatement(sqlite3_stmt* aStmtHandle, const TDbLibrary& aLibraryHandler, sqlite3& aDbHandle);
+
+ ~CStatement();
+
+ /**
+ If the SQL statement being executed returns any data, this function makes
+ a new row of data ready for processing. The values may be accessed using
+ the column access functions (@see CStatement::StrColumnL and @see CStatement::IntColumnL).
+
+ When this function is called again to retrieve the next row of data, the previous row data
+ is not accessible any more.
+
+ If the caller wants to close the statement before retrieving all the rows, it needs to
+ just destroy the CStatement object.
+
+ @return Returns EFalse if no more rows are available.
+ */
+ bool ProcessNextRow();
+
+ /**
+ Eexecutes the prepared SQL statement. This function is appropriate to execute
+ SQL statements which do NOT return a result row set (e.g. INSERT and UPDATE).
+ If the SQL satetement contains parameters, the prepared statement can be bound
+ and executed many times.
+
+ @param aStatement The statement which will be executed.
+ */
+ void ExecuteStatement();
+
+ /**
+ Sets the parameter given with the index value to the specified 32-bit integer value.
+ A parameter value can be set:
+ - immediately after this object has been created
+ - after a call to @see CStatement::Reset
+ @param aParameterIndex The index value identifying the parameter; the first parameter
+ has an index of 1.
+ @param The 32-bit integer value to be assigned to the parameter.
+ */
+ void BindInt(int aParameterIndex, int aParameterValue);
+
+ /**
+ Sets the parameter given with the index value to the specified 64-bit integer value.
+ A parameter value can be set:
+ - immediately after this object has been created
+ - after a call to @see CStatement::Reset
+ @param aParameterIndex The index value identifying the parameter; the first parameter
+ has an index of 1.
+ @param The 64-bit integer value to be assigned to the parameter.
+ */
+ void BindInt64(int aParameterIndex, TInt64 aParameterValue);
+
+ /**
+ Sets the parameter given with the index value to the specified 16-bit descriptor.
+ A parameter value can be set:
+ - immediately after this object has been created
+ - after a call to @see CStatement::Reset
+ @param aParameterIndex The index value identifying the parameter; the first parameter
+ has an index of 1.
+ @param aParameterStr The 16-bit descriptor whose content is to be assigned to the parameter.
+ */
+ void BindStr(int aParameterIndex, const std::wstring& aParameterStr);
+
+ void BindBinary(int aParameterIndex, const std::string &aParameterStr);
+
+ /**
+ Resets this SQL statement object to its initial state and makes it ready to be executed again.
+ Any SQL statement parameters that had values bound to them, retain their values.
+ If this object processes a parameterised SQL statement, then the parameter values
+ can be bound after the call to Reset().
+ */
+ void Reset();
+
+ int IntColumn(int aColumnId ) const;
+
+ TInt64 Int64Column(int aColumnId ) const;
+
+ std::wstring StrColumn(int ColmnnId) const;
+
+ private:
+ void CheckSqlErrCode(int aErrorCode);
+
+ private:
+ sqlite3_stmt* iStmtHandle; //SQL statement handle
+
+ sqlite3& iDbHandle;
+ const TDbLibrary& iLibraryHandler;
+
+ };
+
+
+/**
+ This class is a wrapper over the SQLite interfaces for acessing the database.
+*/
+class CDbProcessor
+
+ {
+
+ public:
+ /**
+ Creates a new database object with an handle to the given database file.
+
+ @param aDbName The name of the database.
+ */
+ CDbProcessor(const std::string& aDllPath, const std::string& aDbName);
+
+
+ /**
+ Destructor. The handle to the database file is closed.
+ */
+ ~CDbProcessor();
+
+ /**
+ Prepares the provided SQL statement for execution and returns
+ the prepared statement object which can be executed later.
+
+ The SQL statement must contain a single statement and end with semicolon(;).
+
+ @param aStatementStr The statement which will be prepared.
+ @return A pointer to the statement object which has got a handle to the result rows set.
+ The returned object is left on the cleanup stack.
+ */
+ CStatement* PrepareStatement(const std::string& aStatementStr);
+
+ /**
+ @return The row id of the most recent successful insert into the database from this connection.
+ @leave ESqlNotFoundError If no successful inserts have ever occurred on this database connection.
+ */
+ TInt64 LastInsertedId();
+
+ public:
+ void CheckSqlErrCode(int aErrorCode);
+ void CheckSqlErrCode(int aErrorCode, const char* aErrorMessage ) ;
+ void CheckSqlErrCode(int aErrorCode, std::string& aErrorMessage ) ;
+
+ private:
+ sqlite3* iDbHandle; ///< The database handle, owned by CDatabaseImplementation.
+ TDbLibrary iLibraryHandler;
+ };
+
+#endif // DBPROCESSOR_H
\ No newline at end of file