TSASQLite.h

/*
Copyright (C) 2013  Nick Ogden <nick@nickogden.org>
copyright (C) Peter Ritter (2015)

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.

//  =============================================
//    NOTE: This code has been heavily modified!
//  =============================================

*/

#ifndef TSA_SQLITE__INCLUDED
#define TSA_SQLITE__INCLUDED

#include <cstddef>
#include <memory>
#include <string>
#include <exception>

#include "TSATime.h"
#include "TSAOS.h"
#include "TSADataDef.h"
#include "TSADBBase.h"

struct sqlite3;
struct sqlite3_stmt;

namespace std {
    template<typename T> class function;
}

namespace tsa {
    class out_stream_adaptor;
    class in_stream_adaptor;

    namespace sqlite {
        class database;

        /*
        ** ====================================================
        ** >>>              class error                     <<<
        ** ====================================================
        */
        class error : public std::runtime_error {
        public:
            error(const int error_code, const std::string& msg = std::string());
            error(const std::string& msg);
            error(
                const std::shared_ptr<sqlite3_stmt>& stmt,
                const std::string& msg = std::string()
                );

            const int sqlite_error_code() const /*noexcept*/ { return code; }

        private:
            const int code = 0;
        };

        // Fundamental sqlite data type
        enum type {
            sq_integer8 = 1,
            sq_float8 = 2,
            sq_text = 3,
            sq_blob = 4,
            sq_null = 5
        };

        /*
        ** ====================================================
        ** >>>               class field                    <<<
        ** ====================================================
        */
        class field {
        public:
            field(const std::shared_ptr<sqlite3_stmt>& statement,
                const std::size_t& parameter_index
                );
            bool is_null() const;
            explicit operator bool() const;
            type column_type(void)const;
            std::string column_name(void) const;
            template<typename T> T as() const;
            void get_variant(tsa::variant&, const tsa::type_t& target_type);
        private:
            std::shared_ptr<sqlite3_stmt> m_stmt_ptr;
            const std::size_t m_index;
        };

        /*
        ** ====================================================
        ** >>>                class row                     <<<
        ** ====================================================
        */
        class row {
        public:
            row(const std::shared_ptr<sqlite3_stmt>& statement);
            row(const row& other) = default;
            //row(row&& other);// = default;
            row& operator=(const row& other) = default;
            //row& operator=(row&& other) = default;
            std::size_t column_count() const;
            field operator[](const std::string& column_name) const;
            field operator[](std::size_t column_index) const;
            field at(const std::string& column_name) const;
            field at(std::size_t column_index) const;
            void print_row(std::ostream&)const;
            void print_row_v(std::ostream&)const;
        private:
            bool is_valid_index(const std::size_t& index) const;
        private:
            std::shared_ptr<sqlite3_stmt> m_stmt_ptr;
        };

        class transaction_failed : public error {
        public:
            transaction_failed(const int status) : error(status) {}
        };

        /*
        ** ====================================================
        ** >>>              class result                    <<<
        ** ====================================================
        */
        class result {
        public:
            class const_iterator {
            public:
                const_iterator(const std::shared_ptr<sqlite3_stmt>& statement, bool& at_end);
                const_iterator(const const_iterator& other) = delete;
                const_iterator(const const_iterator&& other);
                const_iterator(const_iterator&& other);// = default;
                const_iterator& operator=(const const_iterator& other) = delete;
                //const_iterator& operator=(const_iterator&& other);// = default;
                bool operator==(const const_iterator& other) const;
                bool operator!=(const const_iterator& other) const;
                const_iterator& operator++();
                const row& operator*() const;
                const row* operator->() const;
            private:
                std::shared_ptr<sqlite3_stmt> stmt;
                bool& end_reached;
                row current_row;
            };
        public:
            bool is_valid(void)const;
            result(void);//only for use by stream delegates
        public:
            result(const std::shared_ptr<sqlite3_stmt>& statement);
            result(const result& other) = delete;
            result(result&& other);

            result& operator=(const result& other) = delete;
            result& operator=(result&& other);

            size_t calculate_row_count()const;
            std::size_t row_modification_count() const;
            const_iterator begin() const;
            const_iterator end() const;
        public:
            void print_rows(std::ostream&)const;
            void print_rows_v(std::ostream&)const;
        private:
            std::shared_ptr<sqlite3_stmt> m_stmt_ptr;
            mutable bool m_end_reached = false;
        };

        class blob;
        class statement;

        enum class null_t {
            null
        };
        static const null_t null = null_t::null;

        /*
        ** ====================================================
        ** >>>           class statement                <<<
        ** ====================================================
        */
        class statement {
        public:
            statement(const std::shared_ptr<sqlite3_stmt>& statement);
            statement(const statement& other) = delete;
            statement(statement&& other);// = default;
            statement& operator=(const statement& other) = delete;
            statement& operator=(statement&& other);// = default;
            std::size_t parameter_count() const;

            template<typename T>
            void bind(const std::string& parameter, const T& value);
            void bind(const std::string& parameter, const char* value);
            void clear_bindings();
            friend std::ostream& operator<<(std::ostream& os, const statement& statement);
        private:
            void throw_on_bind_error(const int status, const std::string& parameter) const;
            friend result make_result(const statement& statement);
        private:
            std::shared_ptr<sqlite3_stmt> m_stmt_ptr;
        };

        static char const* temporary = "";

        enum class special_t {
            in_memory
        };
        static const special_t in_memory = special_t::in_memory;

        enum access_mode {
            read_only = 0x01,
            read_write = 0x02,
            read_write_create = 0x06
        };

        enum cache_type {
            shared_cache = 0x00020000,
            private_cache = 0x00040000
        };

        /*
        ** ====================================================
        ** >>>             class transaction                <<<
        ** ====================================================
        */
        class transaction {
            friend class database;
            database* m_db_ptr = nullptr;
            bool m_is_open = true;
        public:
            transaction(database* db_ptr);
            transaction(const transaction&);
            ~transaction(void);
            void commit(void);
            void rollback(void);
        };

        /*
        ** ====================================================
        ** >>>           table and field info               <<<
        ** ====================================================
        */
        struct field_info_t {
            int cid;
            std::string name;
            std::string type;
            size_t length; //only for strings
            tsa::type_t tsa_type;
            bool not_null;
            std::string default_value;
            bool is_primary_key;
        };

        class table_info_t  {
            friend class sqlite::database;
            std::string m_table_name;
            std::vector <field_info_t> m_fields;
        public:
            table_info_t(void) = default;
            table_info_t(const std::string& table_name) { m_table_name = table_name; }
            table_info_t(table_info_t&) = default;
            table_info_t(table_info_t&&);
            const std::string& name(void)const { return m_table_name; }
            const field_info_t& operator[](size_t pos);
            size_t size(void)const;
            void print(std::ostream&);
        };

        /*
        ** ====================================================
        ** >>>             class database                   <<<
        ** ====================================================
        */

        class dll_export database : public tsa::data_base {
        private:
            void close() /*noexcept*/;
            std::shared_ptr<sqlite3_stmt> create_statement(const std::string& sql) const;
        private:
            sqlite3* m_db_ptr = nullptr;
        public:
            virtual std::string type(void)const override;
        public:
            database(
                const tsa::os::path& path,
                const access_mode& permissions = sqlite::read_write_create,
                const cache_type& visibility = private_cache
                );
            database(
                const special_t& in_memory,
                const access_mode& permissions = sqlite::read_write_create,
                const cache_type& visibility = private_cache
                );
            database(const database& other) = delete;
            database(database&& other) = delete;//= default;
            virtual ~database();
        public:
            virtual out_stream_adaptor* make_output_stream_adaptor(void) override;
            in_stream_adaptor* database::make_input_stream_adaptor(const std::string& stream)override;
        public:
            virtual bool table_exists(const std::string&)const override;
            void drop_table(const std::string&, bool throw_on_error = false);
            virtual bool drop_series_table(const std::string&)override;
            virtual void create_series_table(const std::string& table_name, const tsa::column_defs&)override;
            virtual tsa::column_defs series_table_column_defs(const std::string& table_name)override;
            void series_insert(const std::string& table_name, const tsa::mem_table& data);
            virtual void series_append(const std::string& table_name, const tsa::mem_table& data)override;
            virtual void series_load(const std::string& table_name, tsa::mem_table& data,
                const date_time& from_timestamp, size_t num_records)override;
            void series_load(const std::string& table_name, tsa::mem_table& data);
            void clear_table(const std::string& table_name, bool throw_on_error = false);
            virtual date_time series_table_first_timestamp(const std::string& table_name)override;
            virtual date_time series_table_last_timestamp(const std::string& table_name)override;
            virtual int64_t table_record_count(const std::string& table_name);
            virtual bool table_has_data(const std::string& table_name)override;
            virtual date_time series_table_closest_timestamp_LOE(const date_time& ts, const std::string& table_name)override;
            virtual void truncate_series_table(const std::string& table_name, const date_time& new_max_timestamp = date_time::min);
            virtual bool table_record_count_is_known(void)const;

        public:
            database& operator=(const database& other) = delete;
            database& operator=(database&& other);// = default;
            statement prepare_statement(const std::string& sql) const;
        public:
            transaction begin(void);
            bool in_transaction(void)const;
        public:
            friend class transaction;
            void rollback(void);
            void commit(void);
        public:
            result select_all_from(const std::string& table_name);
            result execute(const std::string& sql)const;
            result execute(const statement& statement);
            template<typename T> T execute_scalar(const std::string& sql) const {
                result r = execute(sql);
                if (r.begin() == r.end()){
                    throw tsa::exception("sqlite::result", "Scalar query returned no results: " + sql, SLOC);
                }
                return (*r.begin())[0].as<T>();
            }
            template<typename T> T execute_scalar(const statement& statement)const  {
                result results = make_result(statement);
                if (results.begin() == results.end()){
                    throw tsa::exception("sqlite::result", "Scalar query returned no results.", SLOC);
                }
                return (*results.begin())[0].as<T>();
            }
            std::size_t size_on_disk()const;
            friend std::ostream& operator<<(std::ostream& stream, const database& db);
        public:
            table_info_t table_info(const std::string& table_name);
        public:
            void rand_ohlcv(const std::string& table_name, const tsa::date_time& start = "1970-01-01",
                const tsa::duration& ival = tsa::duration::minutes(1));
        public:
            void print_table(std::ostream&, const std::string& table_name);
            void print_table_v(std::ostream&, const std::string& table_name);
        };
    }   // namespace sqlite

}//tsa

#endif