1 files changed, 499 insertions, 0 deletions
diff --git a/src/dpl/db/include/cchecker/dpl/db/sql_connection.h b/src/dpl/db/include/cchecker/dpl/db/sql_connection.h
new file mode 100644
index 0000000..8af5a58
--- /dev/null
+++ b/src/dpl/db/include/cchecker/dpl/db/sql_connection.h
@@ -0,0 +1,499 @@
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ *    Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+/*
+ * @file        sql_connection.h
+ * @author      Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version     1.0
+ * @brief       This file is the implementation file of SQL connection
+ */
+#ifndef CCHECKER_SQL_CONNECTION_H
+#define CCHECKER_SQL_CONNECTION_H
+
+#include <memory>
+#include <sqlite3.h>
+#include <string>
+#include <memory>
+#include <stdint.h>
+
+#include <cchecker/dpl/string.h>
+#include <cchecker/dpl/assert.h>
+#include <cchecker/dpl/noncopyable.h>
+#include <cchecker/dpl/exception.h>
+#include <cchecker/dpl/optional.h>
+#include <cchecker/log.h>
+
+namespace CCHECKER {
+namespace DB {
+/**
+ * SQL connection class
+ */
+class SqlConnection
+{
+  public:
+    /**
+     * SQL Exception classes
+     */
+    class Exception
+    {
+      public:
+        DECLARE_EXCEPTION_TYPE(CCHECKER::Exception, Base)
+        DECLARE_EXCEPTION_TYPE(Base, SyntaxError)
+        DECLARE_EXCEPTION_TYPE(Base, ConnectionBroken)
+        DECLARE_EXCEPTION_TYPE(Base, InternalError)
+        DECLARE_EXCEPTION_TYPE(Base, InvalidColumn)
+    };
+
+    typedef int ColumnIndex;
+    typedef int ArgumentIndex;
+
+    /*
+     * SQL processed data command
+     */
+    class DataCommand :
+        private Noncopyable
+    {
+      private:
+        SqlConnection *m_masterConnection;
+        sqlite3_stmt *m_stmt;
+
+        void CheckBindResult(int result);
+        void CheckColumnIndex(SqlConnection::ColumnIndex column);
+
+        DataCommand(SqlConnection *connection, const char *buffer);
+
+        friend class SqlConnection;
+
+      public:
+        virtual ~DataCommand();
+
+        /**
+         * Bind null to the prepared statement argument
+         *
+         * @param position Index of argument to bind value to
+         */
+        void BindNull(ArgumentIndex position);
+
+        /**
+         * Bind int to the prepared statement argument
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindInteger(ArgumentIndex position, int value);
+
+        /**
+         * Bind int8_t to the prepared statement argument
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindInt8(ArgumentIndex position, int8_t value);
+
+        /**
+         * Bind int16 to the prepared statement argument
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindInt16(ArgumentIndex position, int16_t value);
+
+        /**
+         * Bind int32 to the prepared statement argument
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindInt32(ArgumentIndex position, int32_t value);
+
+        /**
+         * Bind int64 to the prepared statement argument
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindInt64(ArgumentIndex position, int64_t value);
+
+        /**
+         * Bind float to the prepared statement argument
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindFloat(ArgumentIndex position, float value);
+
+        /**
+         * Bind double to the prepared statement argument
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindDouble(ArgumentIndex position, double value);
+
+        /**
+         * Bind string to the prepared statement argument
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindString(ArgumentIndex position, const char *value);
+
+        /**
+         * Bind string to the prepared statement argument
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindString(ArgumentIndex position, const String& value);
+
+        /**
+         * Bind optional int to the prepared statement argument.
+         * If optional is not set null will be bound
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindInteger(ArgumentIndex position, const Optional<int> &value);
+
+        /**
+         * Bind optional int8 to the prepared statement argument.
+         * If optional is not set null will be bound
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindInt8(ArgumentIndex position, const Optional<int8_t> &value);
+
+        /**
+         * Bind optional int16 to the prepared statement argument.
+         * If optional is not set null will be bound
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindInt16(ArgumentIndex position, const Optional<int16_t> &value);
+
+        /**
+         * Bind optional int32 to the prepared statement argument.
+         * If optional is not set null will be bound
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindInt32(ArgumentIndex position, const Optional<int32_t> &value);
+
+        /**
+         * Bind optional int64 to the prepared statement argument.
+         * If optional is not set null will be bound
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindInt64(ArgumentIndex position, const Optional<int64_t> &value);
+
+        /**
+         * Bind optional float to the prepared statement argument.
+         * If optional is not set null will be bound
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindFloat(ArgumentIndex position, const Optional<float> &value);
+
+        /**
+         * Bind optional double to the prepared statement argument.
+         * If optional is not set null will be bound
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindDouble(ArgumentIndex position, const Optional<double> &value);
+
+        /**
+         * Bind optional string to the prepared statement argument.
+         * If optional is not set null will be bound
+         *
+         * @param position Index of argument to bind value to
+         * @param value Value to bind
+         */
+        void BindString(ArgumentIndex position, const Optional<String> &value);
+
+        /**
+         * Execute the prepared statement and/or move
+         * to the next row of the result
+         *
+         * @return True when there was a row returned
+         */
+        bool Step();
+
+        /**
+         * Reset prepared statement's arguments
+         * All parameters will become null
+         */
+        void Reset();
+
+        /**
+         * Checks whether column value is null
+         *
+         * @throw Exception::InvalidColumn
+         */
+        bool IsColumnNull(ColumnIndex column);
+
+        /**
+         * Get integer value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        int GetColumnInteger(ColumnIndex column);
+
+        /**
+         * Get int8 value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        int8_t GetColumnInt8(ColumnIndex column);
+
+        /**
+         * Get int16 value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        int16_t GetColumnInt16(ColumnIndex column);
+        /**
+         * Get int32 value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        int32_t GetColumnInt32(ColumnIndex column);
+
+        /**
+         * Get int64 value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        int64_t GetColumnInt64(ColumnIndex column);
+
+        /**
+         * Get float value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        float GetColumnFloat(ColumnIndex column);
+
+        /**
+         * Get double value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        double GetColumnDouble(ColumnIndex column);
+
+        /**
+         * Get string value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        std::string GetColumnString(ColumnIndex column);
+
+        /**
+         * Get optional integer value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        Optional<int> GetColumnOptionalInteger(ColumnIndex column);
+
+        /**
+         * Get optional int8 value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        Optional<int8_t> GetColumnOptionalInt8(ColumnIndex column);
+
+        /**
+         * Get optional int16value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        Optional<int16_t> GetColumnOptionalInt16(ColumnIndex column);
+
+        /**
+         * Get optional int32 value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        Optional<int32_t> GetColumnOptionalInt32(ColumnIndex column);
+
+        /**
+         * Get optional int64 value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        Optional<int64_t> GetColumnOptionalInt64(ColumnIndex column);
+
+        /**
+         * Get optional float value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        Optional<float> GetColumnOptionalFloat(ColumnIndex column);
+
+        /**
+         * Get optional double value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        Optional<double> GetColumnOptionalDouble(ColumnIndex column);
+
+        /**
+         * Get optional string value from column in current row.
+         *
+         * @throw Exception::InvalidColumn
+         */
+        Optional<String> GetColumnOptionalString(ColumnIndex column);
+    };
+
+    // Move on copy semantics
+    typedef std::auto_ptr<DataCommand> DataCommandAutoPtr;
+
+    // Open flags
+    class Flag
+    {
+      public:
+        enum Type
+        {
+            None = 1 << 0,
+            UseLucene = 1 << 1
+        };
+
+        enum Option
+        {
+            RO = SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_READONLY,
+            /**
+             * *TODO: please remove CREATE option from RW flag when all places
+             *      that need that switched do CRW
+             */
+            RW = SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_READWRITE |
+                SQLITE_OPEN_CREATE,
+            CRW = RW | SQLITE_OPEN_CREATE
+        };
+    };
+
+    // RowID
+    typedef sqlite3_int64 RowID;
+
+    /**
+     * Synchronization object used to synchronize SQL connection
+     * to the same database across different threads and processes
+     */
+    class SynchronizationObject
+    {
+      public:
+        virtual ~SynchronizationObject() {}
+
+        /**
+         * Synchronizes SQL connection for multiple clients.
+         */
+        virtual void Synchronize() = 0;
+
+        /**
+         * Notify all waiting clients that the connection is no longer locked.
+         */
+        virtual void NotifyAll() = 0;
+    };
+
+  protected:
+    sqlite3 *m_connection;
+
+    // Options
+    bool m_usingLucene;
+
+    // Stored data procedures
+    int m_dataCommandsCount;
+
+    // Synchronization object
+    std::unique_ptr<SynchronizationObject> m_synchronizationObject;
+
+    virtual void Connect(const std::string &address,
+                         Flag::Type = Flag::None, Flag::Option = Flag::RO);
+    virtual void Disconnect();
+
+    void TurnOnForeignKeys();
+
+    static SynchronizationObject *AllocDefaultSynchronizationObject();
+
+  public:
+    /**
+     * Open SQL connection
+     *
+     * Synchronization is archieved by using provided asynchronization object.
+     * If synchronizationObject is set to NULL, so synchronization is performed.
+     * Ownership of the synchronization object is transfered to sql connection
+     * object.
+     *
+     * @param address Database file name
+     * @param flags Open flags
+     * @param synchronizationObject A synchronization object to use.
+     */
+    explicit SqlConnection(const std::string &address = std::string(),
+                           Flag::Type flags = Flag::None,
+                           Flag::Option options = Flag::RO,
+                           SynchronizationObject *synchronizationObject =
+                               AllocDefaultSynchronizationObject());
+
+    /**
+     * Destructor
+     */
+    virtual ~SqlConnection();
+
+    /**
+     * Execute SQL command without result
+     *
+     * @param format
+     * @param ...
+     */
+    void ExecCommand(const char *format, ...);
+
+    /**
+     * Prepare stored procedure
+     *
+     * @param format SQL statement
+     * @return Data command representing stored procedure
+     */
+    DataCommandAutoPtr PrepareDataCommand(const char *format, ...);
+
+    /**
+     * Check whether given table exists
+     *
+     * @param tableName Name of the table to check
+     * @return True if given table name exists
+     */
+    bool CheckTableExist(const char *tableName);
+
+    /**
+     * Get last insert operation new row id
+     *
+     * @return Row ID
+     */
+    RowID GetLastInsertRowID() const;
+
+    void BeginTransaction();
+
+    void RollbackTransaction();
+
+    void CommitTransaction();
+};
+} // namespace DB
+} // namespace CCHECKER
+
+#endif // CCHECKER_SQL_CONNECTION_H