Внутренняя организация базы данных

@Gepar · Регистрация: 01.07.2009

Author24 — интернет-сервис помощи студентам

Нужно написать небольшую консольную бд на с++, хотел бы посмотреть реальные примеры. Подкиньте парочку посмотреть пожалуйста

В инете конечно полно примеров БД на visual c++ (mfc например), но там ведь не очень честные бд - там львиная доля работы сделана библиотеками MS и там достаточно было лишь выбрать что мы хотим создать БД да слегка заполнить всё. Мне же нужен какой-то пример где есть все этапы разработки. До этого мне читали проектирование БД, а практика проводилась в MS Access так что сам я пока что бд не программировал.
Моя бд не должна быть слишком навороченной, ей предстоит всего-то создавать таблички (и записи конечно), удалять их. Искать записи ... это в принципе всё что требуется, по желанию можно будет расширить. В общем мне нужна бд где я смогу посмотреть на примере как организовывают хранение таблиц с информацией разных типов (char, int, double, date).
Или же хоть так на словах подскажите по теме пожалуйста, но лучше если будет пример

Добавлено через 18 часов 21 минуту
Не поверю что никто не писал бд на с++, вот не поверю и всё. Поделитесь знаниями в этой области пожалуйста

Ато возникают вопросы как то же создание таблицы делать, нас ведь могут попросить создать таблицу как с двумя полями так и с 5 например, а типы то разные. Не знаю вот как правильно извратиться чтобы обработать это условие.

Добавлено через 4 часа 11 минут
Вот же беда. Раз никто не хочет делиться своей какой-либо старой бд то подскажите хоть как реализовать таблицы пожалуйста.
Задача: сделать поддержку SQL (очень примитивную). Тоесть моя бд должна поддерживать такой минимальный набор команд:

SQL

CREATE TABLE TEST(X INTEGER, Y VARCHAR(255));
CREATE TABLE TEST2(A INTEGER, B VARCHAR(255));
INSERT INTO TEST VALUES(1, "abcde");
INSERT INTO TEST VALUES(2, "defgh");
INSERT INTO TEST VALUES(4, "tersf");
INSERT INTO TEST2 VALUES(2, "abcde");
INSERT INTO TEST2 VALUES(3, "defgh");
INSERT INTO TEST2 VALUES(4, "tersf");
SELECT X FROM TEST;
SELECT X, Y FROM TEST;
SELECT * FROM TEST;
SELECT * FROM TEST,TEST2 WHERE X=A;
DELETE TABLE TEST;

Тоесть я должен как-то создавать таблицы с n полями. Но как мне реализовать это создание таблицы с n полями? Сделать шаблонный класс столбецТаблицы и при вызове CREATE создавать n объектов этого класса столбецТаблицы? Но как это сделать когда я заранее не знаю ни сколько таблиц мне подсунут ни их типы. Распарсить команду не проблема, но как дальше поступить с созданием таблицы ...что-то не могу придумать. Подскажите как в таких случаях делают.

@ForEveR · 19.05.2012, 18:36

Вот писал когда-то... Это первый вариант того, что было. Затем допиливал, но сейчас этого варианта на руках нет. Может на работе остался - посмотрю.

code

C++

#include <vector>
#include <string>
#include <boost/any.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string.hpp>
#include <sstream>
#include <stdexcept>
#include <iostream>
#include <typeinfo>
#include <limits>
 
 
namespace my
{
    enum types_ {int_, string_, other_};
 
    class Holder
    {
    public:
        template<class T>
        Holder(const T& value, types_ type = other_):value_(value), type_name_(value_.type().name()), type_(type)
        {
        }
        const boost::any& getValue() const {return value_;}
        template<class T>
        void setValue(const T& val) {value_ = val;}
        void setType(const types_& tp) {type_ = tp;}
        const types_& getType() const {return type_;}
        const std::string& getSTDType() const {return type_name_;}
        std::string to_string(const types_& tp) const
        {
            std::string result;
            if (tp == string_)
            {
                result = boost::any_cast<std::string>(value_);
            }
            else if (tp == int_)
            {
                int val = boost::any_cast<int>(value_);
                result = boost::lexical_cast<std::string>(val);
            }
            else
            {
                throw std::runtime_error("Unknown type");
            }
            return result;
        }
        int to_int(const types_& tp) const
        {
            int val = 0;
            if (tp == int_)
            {
                val = boost::any_cast<int>(value_);
            }
            else if (tp == string_)
            {
                std::string result = boost::any_cast<std::string>(value_);
                try
                {
                    val = boost::lexical_cast<int>(result);
                }
                catch(const boost::bad_lexical_cast& e)
                {
                    throw std::runtime_error(std::string("Not integer in string: ") + e.what());
                }
            }
            else
            {
                throw std::runtime_error("Unknown type");
            }
            return val;
        }
        static boost::any from_string(const std::string& string)
        {
            int value = 0;
            try
            {
                value = boost::lexical_cast<int>(string);
            }
            catch (const boost::bad_lexical_cast& e)
            {
                return boost::any(string);
            }
            return boost::any(value);
        }
        static types_ type_from_string(const std::string& string)
        {
            types_ tp;
            if (string == "number")
            {
                tp = int_;
            }
            else if (string == "string")
            {
                tp = string_;
            }
            else
            {
                throw std::runtime_error("Unexpected type");
            }
            return tp;
        }
        static Holder value_from_type(const types_& tp)
        {
            Holder hld(0);
            if (tp == int_)
            {
                hld = Holder(0);
            }
            else if (tp == string_)
            {
                hld = Holder(std::string());
            }
            else
            {
                throw std::runtime_error("Unexpected type");
            }
            return hld;
        }
    private:
        boost::any value_;
        std::string type_name_;
        types_ type_;
    };
 
    class Table
    {
    public:
        typedef std::vector<Holder> Data;
        typedef std::vector<Data> TableData;
 
        explicit Table(const std::string& tbl_name):table_name_(tbl_name)
        {
        }
 
        const std::string& getName() const {return table_name_;}
 
        void create(const std::vector<std::string>& plhs, const std::vector<types_>& tps)
        {
            auto plh_iter = plhs.begin();
            auto tp_iter = tps.begin();
            Data dt;
            for(; plh_iter != plhs.end(); ++plh_iter, ++tp_iter)
            {
                dt.push_back(Holder(*plh_iter, *tp_iter));
            }
            matrix_.push_back(dt);
        }
 
        void insert(const std::vector<std::string>& plhs, const std::vector<boost::any>& values)
        {
            if (plhs.empty())
            {
                insert_(values);
            }
            else
            {
                insert_(plhs, values);
            }
        }
        
        std::string select(const std::vector<std::string>& plhs, const std::vector<std::string>& cond_plhs,
                    const std::vector<std::string>& conds, const std::vector<boost::any>& cond_vals)
        {
            std::string result;
            if (plhs.empty() && cond_plhs.empty())
            {
                result = select_();
            }
            else if (cond_plhs.empty())
            {
                result = select_(plhs);
            }
            else if (plhs.empty())
            {
                result = select_(cond_plhs, conds, cond_vals);
            }
            else
            {
                result = select_(plhs, cond_plhs, conds, cond_vals);
            }
            if ((plhs.empty() && result == select_headers()) || (!plhs.empty() && result == select_headers(plhs)) || result.empty())
            {
                result = "\nNo data fetched\n\n";
            }
            return result;
        }
 
        void add_alter(const std::vector<std::string>& plhs, const std::vector<types_>& types)
        {
            add_alter_(plhs, types);
        }
        
        void drop_alter(const std::vector<std::string>& plhs)
        {
            drop_alter_(plhs);
        }
 
        void alter(const std::vector<std::string>& plhs, const std::vector<types_>& types)
        {
            alter_(plhs, types);
        }
        
        void truncate()
        {
            check_table_empty();
            for (auto iter = matrix_.begin() + 1; iter != matrix_.end();)
            {
                matrix_.erase(iter);
            }
        }
        void update(const std::vector<std::string>& plhs, const std::vector<boost::any>& values, 
                    const std::vector<std::string>& cond_plhs, const std::vector<std::string>& opers,
                    const std::vector<boost::any>& cond_values)
        {
            check_table_empty();
            if (cond_plhs.empty())
            {
                update_(plhs, values);
            }
            else
            {
                update_(plhs, values, cond_plhs, opers, cond_values);
            }
        }
    private:
        std::string table_name_;
        TableData matrix_;
 
        std::string select_()
        {
            check_table_empty();
            std::ostringstream ost;
            ost << select_headers();
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&ost, matrix_](const Data& dt)
            {
                auto iter = matrix_[0].begin();
                std::for_each(dt.begin(), dt.end(), [&ost, &iter](const Holder& hld)
                {
                    ost << hld.to_string(iter->getType()) << '\t';
                    ++iter;
                });
                ost << '\n';
            });
            return ost.str();
        }
 
        std::string select_(const std::vector<std::string>& plhs)
        {
            check_table_empty();
            std::ostringstream ost;
            ost << select_headers(plhs);
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&ost, &matrix_, &plhs](const Data& dt)
            {
                auto iter = matrix_[0].begin();
                auto plh_iter = plhs.begin();
                std::for_each(dt.begin(), dt.end(), [&ost, &iter, &plh_iter, &plhs](const Holder& hld)
                {
                    if (iter->to_string(string_) == *plh_iter)
                    {
                        ost << hld.to_string(iter->getType()) << '\t';
                        ++plh_iter;
                    }
                    ++iter;
                });
                ost << '\n';
            });
            return ost.str();
        }
 
        std::string select_(const std::vector<std::string>& condition_placeholders, 
                           const std::vector<std::string>& conditions,
                           const std::vector<boost::any>& cond_values)
        {
            check_table_empty();
            std::ostringstream ost;
            ost << select_headers();
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&condition_placeholders, &conditions, &cond_values, &ost, this]
                                                        (const Data& dt)
            {
                if (where(dt, condition_placeholders, conditions, cond_values))
                {
                    auto iter = matrix_[0].begin();
                    std::for_each(dt.begin(), dt.end(), [&ost, &iter](const Holder& hld)
                    {
                        ost << hld.to_string(iter->getType()) << '\t';
                        ++iter;
                    });
                    ost << '\n';
                }
            });
            return ost.str();
        }
        
        std::string select_(const std::vector<std::string>& plhs, 
                           const std::vector<std::string>& condition_plhs,
                           const std::vector<std::string>& conditions,
                           const std::vector<boost::any>& cond_values)
        {
            check_table_empty();
            std::ostringstream ost;
            ost << select_headers(plhs);
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&plhs, &condition_plhs, &conditions, &cond_values, &ost, this]
                                                              (const Data& dt)
            {
                if (where(dt, condition_plhs, conditions, cond_values))
                {
                    auto iter = matrix_[0].begin();
                    auto plh_iter = plhs.begin();
                    std::for_each(dt.begin(), dt.end(), [&ost, &iter, &plh_iter](const Holder& hld)
                    {
                        if (*plh_iter == iter->to_string(string_))
                        {
                            ost << hld.to_string(iter->getType()) << '\t';
                            ++plh_iter;
                        }
                        ++iter;
                    });
                    ost << '\n';
                }
            });
            return ost.str();
        }
 
        void insert_(const std::vector<boost::any>& values)
        {
            check_table_empty();
            Data dt;
            auto iterator = matrix_[0].begin();
            for (auto iter = values.begin(); iter != values.end(); ++iter, ++iterator)
            {
                if (iterator->getType() == int_)
                {
                    dt.push_back(boost::any_cast<int>(*iter));
                }
                else
                {
                    dt.push_back(*iter);
                }
            }
            matrix_.push_back(dt);
        }
        
        void insert_(const std::vector<std::string>& plhs, const std::vector<boost::any>& values)
        {
            check_table_empty();
            Data dt;
            auto plh_iter = plhs.begin();
            auto val_iter = values.begin();
            for(auto iter = matrix_[0].begin(); iter != matrix_[0].end(); ++iter)
            {
                if (iter->to_string(string_) == *plh_iter)
                {
                    dt.push_back(*val_iter);
                    ++val_iter;
                    ++plh_iter;
                }
                else
                {
                    dt.push_back(Holder::value_from_type(iter->getType()));
                }
            }
            matrix_.push_back(dt);
        }
        
        void add_alter_(const std::vector<std::string>& plhs, const std::vector<types_>& types)
        {
            auto pl_iter = plhs.begin();
            auto tp_iter = types.begin();
            for (; pl_iter != plhs.end(); ++pl_iter, ++tp_iter)
            {
                add_alter_one_(*pl_iter, *tp_iter);
            }
        }
        
        void add_alter_one_(const std::string& plh, const types_& type)
        {
            if (matrix_.empty())
            {
                matrix_.push_back(Data());
            }
            auto iter = matrix_[0].insert(matrix_[0].end(), Holder(plh, type));
            for (auto iter_ = matrix_.begin() + 1; iter_ != matrix_.end(); ++iter_)
            {
                iter_->push_back(Holder::value_from_type(iter->getType()));
            }
        }
        
        void drop_alter_(const std::vector<std::string>& plhs)
        {
            check_table_empty();
            auto pl_iter = plhs.begin();
            for (auto iter = matrix_[0].begin(); iter != matrix_[0].end();)
            {
                if (iter->to_string(string_) == *pl_iter)
                {
                    size_t idx = std::distance(matrix_[0].begin(), iter);
                    for (auto itr = matrix_.begin() + 1; itr != matrix_.end(); ++itr)
                    {
                        itr->erase(itr->begin() + idx); 
                    }
                    iter = matrix_[0].erase(iter);
                    ++pl_iter;
                }
                else
                {
                    ++iter;
                }
            }
            if (select_headers() == "\n\n\n")
            {
                matrix_.clear();
            }
        }
        
        void alter_(const std::vector<std::string>& plhs, const std::vector<types_>& types)
        {
            check_table_empty();
            auto pl_iter = plhs.begin();
            auto tp_iter = types.begin();
            for (auto iter = matrix_[0].begin(); iter != matrix_[0].end(); ++iter)
            {
                if (iter->to_string(string_) == *pl_iter)
                {
                    size_t idx = std::distance(matrix_[0].begin(), iter);
                    for (auto itr = matrix_.begin() + 1; itr != matrix_.end(); ++itr)
                    {
                        if (*tp_iter == string_)
                        {
                            try
                            {
                                (itr->begin() + idx)->setValue((itr->begin() + idx)->to_string(iter->getType()));
                            }
                            catch(const std::exception& e)
                            {
                                (itr->begin() + idx)->setValue(std::string());
                            }
                        }
                        else if (*tp_iter == int_)
                        {
                            try
                            {
                                (itr->begin() + idx)->setValue((itr->begin() + idx)->to_int(iter->getType()));
                            }
                            catch (const std::exception& e)
                            {
                                (itr->begin() + idx)->setValue(0);
                            }
                        }
                        else
                        {
                            throw std::runtime_error("Unexpected type");
                        }
                    }
                    iter->setType(*tp_iter);
                    ++tp_iter;
                    ++pl_iter;
                }
            }
        }
        
        void update_(const std::vector<std::string>& plhs, const std::vector<boost::any>& values)
        {
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&plhs, &values, &matrix_](Data& dt)
            {
                auto iter = matrix_[0].begin();
                auto pl_iter = plhs.begin();
                auto val_iter = values.begin();
                std::for_each(dt.begin(), dt.end(), [&iter, &pl_iter, &val_iter](Holder& hld)
                {
                    if (iter->to_string(string_) == *pl_iter)
                    {
                        hld.setValue(*val_iter);
                        ++pl_iter;
                        ++val_iter;
                    }
                    ++iter;
                });
            });
        }
        
        void update_(const std::vector<std::string>& plhs, const std::vector<boost::any>& values, 
                    const std::vector<std::string>& cond_plhs, const std::vector<std::string>& cond_opers,
                    const std::vector<boost::any>& cond_values)
        {
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&plhs, &values, &cond_plhs, &cond_opers, &cond_values, this]
                                                              (Data& dt)
            {
                if (where(dt, cond_plhs, cond_opers, cond_values))
                {
                    auto pl_iter = plhs.begin();
                    auto val_iter = values.begin();
                    auto iter = matrix_[0].begin();
                    std::for_each(dt.begin(), dt.end(), [&pl_iter, &val_iter, &iter](Holder& hld)
                    {
                        if (iter->to_string(string_) == *pl_iter)
                        {
                            hld.setValue(*val_iter);
                            ++pl_iter;
                            ++val_iter;
                        }
                        ++iter;
                    });
                }
            });
        }
 
        std::string select_headers() const
        {
            std::ostringstream ost;
            ost << '\n';
            std::for_each(matrix_[0].begin(), matrix_[0].end(), [&ost](const Holder& hld)                 
            {
                ost << hld.to_string(string_) << '\t';
            });
            ost << "\n\n";
            return ost.str();
        }
 
        std::string select_headers(const std::vector<std::string>& plhs) const
        {
            std::ostringstream ost;
            ost << '\n';
            auto iter = plhs.begin();
            auto end_iter = plhs.end();
            std::for_each(matrix_[0].begin(), matrix_[0].end(), [&ost, &iter, &end_iter](const Holder& hld)
            {
                if (iter != end_iter)
                {
                    if (hld.to_string(string_) == *iter)
                    {
                        ost << hld.to_string(string_) << '\t';
                        ++iter;
                    }
                }
            });
            ost << "\n\n";
            return ost.str();
        }
 
        bool where(const Data& dt,
                   const std::vector<std::string>& condition_plhs,
                   const std::vector<std::string>& conditions,
                   const std::vector<boost::any>& cond_values)
        {
            bool flg = true;
            auto intern_plh_iter = matrix_[0].begin();
            auto cond_plh_iter = condition_plhs.begin();
            auto cond_iter = conditions.begin();
            auto cond_val_iter = cond_values.begin();
            auto data_iter = dt.begin();
            for (; intern_plh_iter != matrix_[0].end(); ++intern_plh_iter, ++data_iter)
            {
                if (cond_plh_iter == condition_plhs.end())
                {
                    break;
                }
                if (*cond_plh_iter == intern_plh_iter->to_string(string_))
                {
                    if (intern_plh_iter->getType() == string_)
                    {
                        if (!compare(data_iter->to_string(string_), *cond_iter, boost::any_cast<std::string>(*cond_val_iter)))
                        {
                            flg = false;
                        }
                    }
                    else if (intern_plh_iter->getType() == int_)
                    {
                        if (!compare(data_iter->to_int(int_), *cond_iter, boost::any_cast<int>(*cond_val_iter)))
                        {
                            flg = false;
                        }
                    }
                    if (flg == false)
                    {
                        return flg;
                    }
                    ++cond_plh_iter;
                    ++cond_iter;
                    ++cond_val_iter;
                }
            }
            return flg;
        }
 
        template<class T>
        bool compare(const T& first, const std::string& oper, const T& second)
        {
            bool flg = false;
            if (oper == "=")
            {
                flg = first == second;
            }
            else if (oper == "!=")
            {
                flg = first != second;
            }
            else if (oper == "<")
            {
                flg = first < second;
            }
            else if (oper == ">")
            {
                flg = first > second;
            }
            else if (oper == "<=")
            {
                flg = first <= second;
            }
            else if (oper == ">=")
            {
                flg = first >= second;
            }
            else
            {
                throw std::runtime_error("Only simple conditions allowed");
            }
            return flg;
        }
 
        void check_table_empty()
        {
            if (matrix_.empty())
            {
                throw std::runtime_error("Table is empty");
            }
        }
    };
    
    struct TableCmpByTblName
    {
    public:
        TableCmpByTblName(const std::string& tbl_name):
            table_name(tbl_name)
        {
        }
        bool operator () (const Table& tbl)
        {
            return table_name == tbl.getName();
        }
    private:
        std::string table_name;
    };
 
    class DataBase
    {
        enum commands_enum {create_, insert_, delete_, select_};
    public:
        DataBase()
        {
        }
        void create_tbl(const std::string& tbl_name, const std::vector<std::string>& plhs, 
                    const std::vector<types_>& tps)
        {
            check_table_exist(tbl_name);
            auto iter = db.insert(db.end(), Table(tbl_name));
            iter->create(plhs, tps);
        }
        void insert(const std::string& tbl_name, const std::vector<std::string>& plhs, 
                    const std::vector<boost::any>& values)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->insert(plhs, values);
        }
        std::string select(const std::string& tbl_name, const std::vector<std::string>& plhs,
                           const std::vector<std::string>& condition_placeholders,
                           const std::vector<std::string>& conditions,
                           const std::vector<boost::any>& cond_values)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            return iter->select(plhs, condition_placeholders, conditions, cond_values);
        }
        void add_alter(const std::string& tbl_name, const std::vector<std::string>& plhs, const std::vector<types_>& types)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->add_alter(plhs, types);
        }
        void drop_alter(const std::string& tbl_name, const std::vector<std::string>& plhs)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->drop_alter(plhs);
        }
        void alter(const std::string& tbl_name, const std::vector<std::string>& plhs, const std::vector<types_>& types)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->alter(plhs, types);
        }
        void drop(const std::string& tbl_name)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            db.erase(iter);
        }
        void truncate(const std::string& tbl_name)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->truncate();
        }
        void update(const std::string& tbl_name, const std::vector<std::string>& plhs, const std::vector<boost::any>& values,
                    const std::vector<std::string>& cond_plhs, const std::vector<std::string>& cond_opers, 
                    const std::vector<boost::any>& cond_values)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->update(plhs, values, cond_plhs, cond_opers, cond_values);
        }
    private:
        std::vector<Table> db;
        std::vector<Table>::iterator find_table_by_name(const std::string& tbl_name)
        {
            std::vector<Table>::iterator iter = std::find_if(db.begin(), db.end(), TableCmpByTblName(tbl_name));
            if (iter == db.end())
            {
                throw std::logic_error("Table doesn`t exist");
            }
            return iter;
        }
        void check_db_empty() const
        {
            if (db.size() == 0)
            {
                throw std::logic_error("Database is empty");
            }
        }
        void check_table_exist(const std::string& tbl_name)
        {
            try
            {
                find_table_by_name(tbl_name);
            }
            catch(const std::logic_error& e)
            {
                return;
            }
            throw std::runtime_error("Table is allready exist");
        }
    };
}
 
static my::DataBase DataBase_;
 
class Program
{
public:
    static void process(const std::string& comm_string, std::ostream& os = std::cout)
    {
        Program prog;
        if (comm_string.empty())
        {
            prog.help();
            throw std::runtime_error("Command string shouldn`t be empty");
        }
        try
        {
            const std::string delims = " ,:";
            std::vector<std::string> commands;
            boost::algorithm::split(commands, comm_string, boost::is_any_of(delims), boost::token_compress_on);
            std::string table_name;
            std::vector<std::string> plhs;
            std::vector<boost::any> values;
            if (commands.at(0) == "create")
            {
                prog.create(commands);
            }
            else if (commands.at(0) == "insert")
            {
                prog.insert(commands);
            }
            else if (commands.at(0) == "select")
            {
                os << prog.select(commands) << '\n';
            }
            else if (commands.at(0) == "help")
            {
                prog.help();
            }
            else if (commands.at(0) == "alter")
            {
                prog.alter(commands);
            }
            else if (commands.at(0) == "drop")
            {
                prog.drop(commands);
            }
            else if (commands.at(0) == "truncate")
            {
                prog.truncate(commands);
            }
            else if (commands.at(0) == "update")
            {
                prog.update(commands);
            }
            else
            {
                prog.help();
                throw std::runtime_error("Sorry. Unimplemented ability");
            }
        }
        catch (const std::out_of_range& e)
        {
            throw std::runtime_error(std::string("Wrong command") + "\n" + comm_string);
        }
        catch (const std::exception& e)
        {
            throw std::runtime_error(std::string(e.what()) + "\n" + comm_string);
        }
    }
private:
    void create(const std::vector<std::string>& commands)
    {
        if (commands.size() < 4)
        {
            throw std::runtime_error("Wrong create command");
        }
        std::string table_name = commands.at(1);
        std::vector<std::string> plhs;
        std::vector<my::types_> tps;
        for (std::vector<std::string>::const_iterator iter = commands.begin() + 2; iter != commands.end();)
        {
            plhs.push_back(*iter);
            ++iter;
            tps.push_back(my::Holder::type_from_string(*iter));
            ++iter;
        }
        DataBase_.create_tbl(table_name, plhs, tps);
    }
    void insert(const std::vector<std::string>& commands)
    {
        if (commands.at(1) != "into" || commands.size() < 5)
        {
            throw std::runtime_error("Wrong insert command");
        }
        std::string table_name = commands.at(2);
        auto iter = commands.begin() + 2;
        std::vector<std::string> plhs;
        if (*(++iter) != "values")
        {
            for (; *iter != "values"; ++iter)
            {
                plhs.push_back(*iter);
            }
        }
        if (*iter != "values")
        {
            throw std::runtime_error("Wrong insert command");
        }
        ++iter;
        std::vector<boost::any> values;
        for(; iter != commands.end(); ++iter)
        {
            values.push_back(my::Holder::from_string(*iter));
        }
        DataBase_.insert(table_name, plhs, values);
    }
 
    std::string select(const std::vector<std::string>& commands) const
    {
        if (commands.size() < 4)
        {
            throw std::runtime_error("Wrong select command");
        }
        std::vector<std::string> plhs;
        auto iter = commands.begin() + 1;
        if (*iter != "*")
        {
            for (; *iter != "from"; ++iter)
            {
                plhs.push_back(*iter);
            }
            ++iter;
        }
        else
        {
            iter += 2;
        }
        std::string table_name = *iter;
        std::vector<std::string> cond_plhs;
        std::vector<std::string> opers;
        std::vector<boost::any> cond_values;
        ++iter;
        if (iter != commands.end() && *iter == "where")
        {
            ++iter;
            for (; iter != commands.end();)
            {
                cond_plhs.push_back(*iter);
                ++iter;
                opers.push_back(*iter);
                ++iter;
                cond_values.push_back(my::Holder::from_string(*iter));
                ++iter;
            }
        }
        return DataBase_.select(table_name, plhs, cond_plhs, opers,
                     cond_values);
    }
    void alter(const std::vector<std::string>& commands)
    {
        if (commands.size() < 4)
        {
            throw std::runtime_error("Wrong alter command");
        }
        std::string table_name = commands.at(1);
        std::vector<std::string> plhs;
        std::vector<my::types_> types;
        if (commands.at(2) == "add")
        {
            for (auto iter = commands.begin() + 3; iter != commands.end();)
            {
                plhs.push_back(*iter);
                ++iter;
                types.push_back(my::Holder::type_from_string(*iter));
                ++iter;
            }
            DataBase_.add_alter(table_name, plhs, types);
        }
        else if (commands.at(2) == "drop")
        {
            plhs = std::vector<std::string>(commands.begin() + 3, commands.end());
            DataBase_.drop_alter(table_name, plhs);
        }
        else if (commands.at(2) == "alter")
        {
            for (auto iter = commands.begin() + 3; iter != commands.end();)
            {
                plhs.push_back(*iter);
                ++iter;
                types.push_back(my::Holder::type_from_string(*iter));
                ++iter;
            }
            DataBase_.alter(table_name, plhs, types);
        }
    }
    void drop(const std::vector<std::string>& commands)
    {
        if (commands.size() < 2)
        {
            throw std::runtime_error("Wrond drop command");
        }
        std::string table_name = commands.at(1);
        DataBase_.drop(table_name);
    }
    void truncate(const std::vector<std::string>& commands)
    {
        if (commands.size() < 2)
        {
            throw std::runtime_error("Wrong truncate command");
        }
        std::string table_name = commands.at(1);
        DataBase_.truncate(table_name);
    }
    void update(const std::vector<std::string>& commands)
    {
        if (commands.size() < 6)
        {
            throw std::runtime_error("Wrong update command");
        }
        std::string table_name = commands.at(1);
        if (commands.at(2) != "set")
        {
            throw std::runtime_error("Wrong update command");
        }
        std::vector<std::string> plhs;
        std::vector<boost::any> values;
        std::vector<std::string> cond_plhs;
        std::vector<std::string> cond_opers;
        std::vector<boost::any> cond_values;
        auto iter = commands.begin() + 3;
        for (; iter != commands.end() && *iter != "where";)
        {
            plhs.push_back(*iter);
            ++iter;
            if (*iter != "=")
            {
                throw std::runtime_error("Wrong update command");
            }
            ++iter;
            values.push_back(my::Holder::from_string(*iter));
            ++iter;
        }
        if (iter != commands.end() && *iter == "where")
        {
            ++iter;
            for (; iter != commands.end();)
            {
                cond_plhs.push_back(*iter);
                ++iter;
                cond_opers.push_back(*iter);
                ++iter;
                cond_values.push_back(my::Holder::from_string(*iter));
                ++iter;
            }
        }
        DataBase_.update(table_name, plhs, values, cond_plhs, cond_opers, cond_values);
    }
    void help()
    {
        std::cout << "----------------HELP-------------------\n\n";
        std::cout << "Simple database 1.0\n";
        std::cout << "Commands: create, insert, select, alter, drop, update, truncate\n";
        std::cout << "Examples of usage\n";
        std::cout << "Example of create: create tbl1 id:number, name:string\n";
        std::cout << "Command create table named tbl1 with fields id with type number and name with type string\n";
        std::cout << "Example of insert: insert into tbl1 values 1, a\n";
        std::cout << "Command insert in table named tbl1 value 1 in id and a in name\n";
        std::cout << "Example of insert: insert into tbl1 id values 1\n";
        std::cout << "Command insert in table named tbl1 values 1 in id and null in name (for string null is empty string)\n";
        std::cout << "Example of select: select * from tbl1\n";
        std::cout << "Command select values from all fields of tbl1\n";
        std::cout << "Example of select: select * from tbl1 where id = 1\n";
        std::cout << "Command select values from all fields of tbl1 where value of field id = 1\n";
        std::cout << "Example of select: select id from tbl1 where name = a\n";
        std::cout << "Command select values from field if of tbl1 where values of field name = a\n";
        std::cout << "Example of alter: alter tbl1 add value:string\n";
        std::cout << "Command add to table field value with type string\n";
        std::cout << "Example of alter: alter tbl1 drop value\n";
        std::cout << "Command drop from table column named values\n";
        std::cout << "Example of alter: alter tbl1 alter value:number\n";
        std::cout << "Command change type of field value to number\n";
        std::cout << "Example of drop: drop tbl1\n";
        std::cout << "Command drop all table. After this command table is destroyed\n";
        std::cout << "Example of truncate: truncate tbl1\n";
        std::cout << "Command drop all values in the table\n";
        std::cout << "Example of update: update tbl1 set id = 1\n";
        std::cout << "Command set value of field named id in 1 in all table\n";
        std::cout << "Example of update: update tbl1 set id = 1 where name = a\n";
        std::cout << "Command set value of field named id in 1 if value of field name in this row = a\n";
        std::cout << "IN THIS VERSION SPACES IN CONDITIONS FOR WHERE ARE OBLIGATORY\n";
        std::cout << "Thanks. Good luck\n";
        std::cout << "----------------------------------------\n\n";
    }
    static my::DataBase DataBase_;
};
 
my::DataBase Program::DataBase_;

C++

#include "db.hpp"
 
int main()
{
    std::string comm;
    while (std::cout << "Enter command\n" && std::getline(std::cin, comm) && (comm != "exit" && comm != "quit"))
    {
        try
        {
            Program::process(comm);
        }
        catch(const std::runtime_error& e)
        {
            std::cerr << "ProgError: " << e.what() << '\n';
        }
    }
}

@Gepar · 20.05.2012, 00:36 **[ТС]**

Блин, boost, а его нельзя использовать, а именно от него вижу использованы RTTI механизми, с помощью которых подозреваю и делалось всё. Я то тоже увидев задание сразу же подумал "и как же это реализовать то, ведь нужен RTTI механизм который позволит создавать объекты передавая строку с указанием типа". Есть ещё какие-то хитрые идеи как это сделать не выходя за рамки си++?
У меня возникала безумная идея распарсивать строку и потом делать что-то типа

C++

if(string=="INTEGER")
 BD->Add(Table<int>);
else if(string=="DOUBLE")
 BD->Add(Table<double);

быдлокод конечно, но ничего лучше в голову не лезет. Это ещё как подумаю что это нужно запоминать какие типы подсунули да контролировать что вместо int при добавлении данных не сунут double или string ... Эх, плохо когда просят сделать что-то и ограничивают в возможностях. По-моему неправильно это когда говорят (не прямым текстом конечно) "да так хорошую бд любой дурак сделает, а ты напиши нам плохую, которая никуда не годится, но сам, и не выходи за рамки с++. STL так уж и быть разрешаем тебе, радуйся. Весь год не разрешали же, а тут пользуйся всласть." Но что поделать, таковое задание. Может у кого есть идеи получше? Ещё думаю может как-то применить typeinfo что в с++, ато больше ведь толком механизмов RTTI у с++ и нету.

Добавлено через 4 минуты
*Мне ещё SQL не читали (вот будут с осени), что должно сделать SELECT ? Я понимаю что выбрать что-то как-то и, вероятно, распечатать, но можно чуть подробнее по коду в этом моём примере (на вики я уже ходил), до булевой алгебры опускаться не надо, а так в двух словах что будет делать это:

SQL

SELECT X FROM TEST;
SELECT X, Y FROM TEST;
SELECT * FROM TEST;
SELECT * FROM TEST,TEST2 WHERE X=A;

Jupiter · 20.05.2012, 02:57

Сообщение от Gepar

что должно сделать SELECT ?

произвести отбор/выборку данных

Сообщение от Gepar

SELECT X FROM TEST

выбрать поле Х из таблицы TEST (будут выбраны все записи)

Сообщение от Gepar

SELECT X, Y FROM TEST;

выбрать поля Х, Y из таблицы TEST (будут выбраны все записи)

Сообщение от Gepar

SELECT * FROM TEST

выбрать ВСЕ поля из из таблицы TEST (будут выбраны все записи)

Сообщение от Gepar

SELECT * FROM TEST,TEST2 WHERE X=A;

выбрать ВСЕ поля из из таблицы TEST (будут выбраны все записи у которых значение поля X равно А)

Добавлено через 1 минуту

Не по теме:

Сообщение от Gepar

Распарсить команду не проблема

но тем неменее многие СУБД не в состоянии указать точную ошибку при неправильном запросе;)

Добавлено через 5 минут

Сообщение от Gepar

и потом делать что-то типа

вот и реализуй - базовый тип от которого наследуються тип целого, строки и т.д.

Добавлено через 1 минуту

Сообщение от Gepar

а контролировать что вместо int при добавлении данных не сунут double или string ...

примитивно, но...
http://www.cplusplus.com/refer... m/putback/

@Gepar · 20.05.2012, 14:49 **[ТС]**

Сообщение от Jupiter

но тем неменее многие СУБД не в состоянии указать точную ошибку при неправильном запросе

Хороший парсер всегда проблема. Но тут просят чего-то простенького. Наверное будет даже достаточно вывода "unknown command" если что-то не будет получаться распарсить, но это потом, у меня главного нет: не знаю как же сделать основную структуру с столбцами таблиц. Мне тут ещё одну глупую, но рабочую, идею подкинули: завести таблицу сразу с 4мя типами и флагом каким-нибудь что именно мы сейчас храним. Что-то типа:

C++

struct Table
{
char* VARCHAR;
int INTEGER;
string DATE;
double DOUBLE;
};

Теоретически можно даже использовать эти ээээ... не структуры, не поля, а третье, вылетело из головы ключевое слово для них ... чтобы экономить память, но это уже наверное излишнее. Такой вариант вполне позволит сделать бд (ага, быдлокод чистейшей воды, но работать будет). Но мне такой вариант совсем не нравиться.
Кстати об одном из полей - о дате: есть в с++ в STL может что-то хитрое для работы с ним? Мне лень самому писать класс Data/ использовать старый написанный когда-то класс Дата. В с++ есть что-то удобное чтобы можно было проверять правильную ли дату задают ну и чтобы хранить какую-то дату в виде поля таблицы. Я помню в си было пару вещиц, но они такие неудобные были и работали через пень-колоду. Мне что-то гибкое надо и 100% работающее и независящее от того на какой ос это всё запускать будут.
*Я кстати не вижу чтобы задавали ключевые поля. Наверное не буду добавлять возможности это делать, чего самому себе задание усложнять.

Добавлено через 4 минуты

Сообщение от Jupiter

примитивно, но...

Не, не в этом плане. Я в том плане что после того как создали мы таблицу с типами int, double, char, char то нужно же ещё парсить что суют то что надо и в правильной последовательности, значит ещё надо держать где-то те типы с которыми создана бд, а потом сверяться что подсовывают те же типы. Именно с этим проблема. Так то оно обычно просто cin>>a>>b>>c>>d if (cin.fail) вы ввели фигню, пробуйте ещё раз.

@ForEveR · 20.05.2012, 14:54

Gepar, Там буст юзается только для any. Реализовать свой any проще простого. Достаточно посмотреть исходник бустовский) Да split, который тоже реализовать не проблема. В данном варианте нету сейва/лоада, которые сделаны через boost::serialization (вот это уже самому реализовать не столь просто).

Про даты. В стандарте нету удобств для работы с датами, но етесно есть в бусте.

@ForEveR · 22.05.2012, 16:51

Вот так это выглядит сейчас. Не трогал уже довольно давно. Парсер у меня не компилится. Разберусь в чем дело потом.

Код базы

C++

#include <vector>
#include <string>
#include <map>
#include <boost/any.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/convenience.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/function.hpp>
#include <sstream>
#include <stdexcept>
#include <iostream>
#include <typeinfo>
#include <limits>
//#include "parser.hpp"
 
 
namespace serialization = boost::serialization;
namespace archive = boost::archive;
 
namespace my_serialization
{
 
class Base
{
public:
    explicit Base(const std::string& type):type_(type)
    {
    }
    virtual ~Base() 
    {
    }
    std::string getType() const {return type_;}
    virtual std::string asString() const = 0;
    virtual boost::any asAny() const = 0;
    virtual bool empty() const = 0;
    friend class serialization::access;
private:
    template<class Arch>
    void serialize(Arch& ar, const unsigned int version = 0)
    {
        ar & type_;
    }
    std::string type_;
};
 
template<class T>
class Template:public Base
{
public:
    explicit Template(const T& value = T()):Base(typeid(T).name()), value_(value)
    {
    }
    virtual ~Template()
    {
    }
    virtual std::string asString() const 
    {
        return boost::lexical_cast<std::string>(value_);
    }
    virtual boost::any asAny() const 
    {
        return value_;
    }
    virtual bool empty() const 
    {
       return value_ == T();
    }
    friend class serialization::access;
private:
    template<class Arch>
    void serialize(Arch& ar, const unsigned int version = 0)
    {
        ar & serialization::base_object<Base>(*this);
        ar & value_;
    }
    T value_;
};
 
}
 
namespace my
{
    enum types_ {int_, string_, other_};
    typedef boost::shared_ptr<my_serialization::Base> value_pointer;
    class Holder
    {
    public:
        Holder()
        {
        }
        template<class T>
        Holder(const T& value, types_ type = other_, bool not_null = false):
            value_(new my_serialization::Template<T>(value)), type_(type), not_null_(not_null)
        {
        }
        const boost::any getValue() const 
        {
            return value_->asAny();
        }
        template<class T>
        void setValue(const T& val) 
        {
            value_ = value_pointer(new my_serialization::Template<T>(val));
        }
        void setType(const types_& tp) 
        {
           type_ = tp;
        }
        const types_& getType() const 
        {
           return type_;
        }
        bool notNull() const 
        {
           return not_null_;
        }
        void setNotNull(bool nn) 
        {
           not_null_ = nn;
        }
        bool empty() const 
        {
           return value_->empty();
        }
        std::string to_string() const
        {
            return value_->asString();
        }
        int to_int() const
        {
            int val = 0;
            std::string value = value_->asString();
            try
            {
                val = boost::lexical_cast<int>(value);
            }
            catch (const std::exception& e)
            {
                throw std::runtime_error("Not integer in string");
            }
            return val;
        }
        static boost::any from_string(const std::string& string)
        {
            int value = 0;
            try
            {
                value = boost::lexical_cast<int>(string);
            }
            catch (const boost::bad_lexical_cast& e)
            {
                return boost::any(string);
            }
            return boost::any(value);
        }
        static types_ type_from_string(const std::string& string)
        {
            types_ tp;
            if (string == "number")
            {
                tp = int_;
            }
            else if (string == "string")
            {
                tp = string_;
            }
            else
            {
                throw std::runtime_error("Unexpected type");
            }
            return tp;
        }
        static Holder value_from_type(const types_& tp)
        {
            Holder hld(0);
            if (tp == int_)
            { 
                hld = Holder(0, tp);
            }
            else if (tp == string_)
            {
                hld = Holder(std::string(), tp);
            }
            else
            {
                throw std::runtime_error("Unexpected type");
            }
            return hld;
        }
        static std::string string_from_type(const types_& tp)
        {
            std::string result;
            if (tp == int_)
            {
                result = "number";
            }
            else if (tp == string_)
            {
                result = "string";
            }
            else
            {
            }
            return result;
        }
        static std::string string_from_bool(bool value)
        {
            std::string result;
            if (value == true)
            {
                result = "not null";
            }
            return result;
        }
        friend class boost::serialization::access;
    private:
        template<class Arch>
        void serialize(Arch& ar, const unsigned int version = 0)
        {
            ar & type_;
            ar & value_;
            ar & not_null_;
        }
        value_pointer value_;
        types_ type_;
        bool not_null_;
    };
 
    class Table
    {
    public:
        typedef std::vector<Holder> Data;
        typedef std::vector<Data> TableData;
        Table()
        {
        }
        explicit Table(const std::string& tbl_name):table_name_(tbl_name)
        {
        }
 
        const std::string& getName() const {return table_name_;}
 
        void create(const std::vector<std::string>& plhs, const std::vector<types_>& tps,
                    const std::list<bool>& nulls)
        {
            auto plh_iter = plhs.begin();
            auto tp_iter = tps.begin();
            auto null_iter = nulls.begin();
            Data dt;
            for(; plh_iter != plhs.end(); ++plh_iter, ++tp_iter, ++null_iter)
            {
                dt.push_back(Holder(*plh_iter, *tp_iter, *null_iter));
            }
            matrix_.push_back(dt);
        }
 
        void insert(const std::vector<std::string>& plhs, const std::vector<boost::any>& values)
        {
            if (plhs.empty())
            {
                insert_(values);
            }
            else
            {
                insert_(plhs, values);
            }
        }
        
        std::string select(const std::vector<std::string>& plhs, const std::vector<std::string>& cond_plhs,
                    const std::vector<std::string>& conds, const std::vector<boost::any>& cond_vals,
                    const std::vector<std::string>& and_ors)
        {
            std::string result;
            if (plhs.empty() && cond_plhs.empty())
            {
                result = select_();
            }
            else if (cond_plhs.empty())
            {
                result = select_(plhs);
            }
            else if (plhs.empty())
            {
                result = select_(cond_plhs, conds, cond_vals, and_ors);
            }
            else
            {
                result = select_(plhs, cond_plhs, conds, cond_vals, and_ors);
            }
            if ((plhs.empty() && result == select_headers()) || (!plhs.empty() && result == select_headers(plhs)) || result.empty())
            {
                result = "\nNo data fetched\n\n";
            }
            return result;
        }
 
        void add_alter(const std::vector<std::string>& plhs, const std::vector<types_>& types,
                       const std::list<bool>& not_nulls)
        {
            add_alter_(plhs, types, not_nulls);
        }
        
        void drop_alter(const std::vector<std::string>& plhs)
        {
            drop_alter_(plhs);
        }
 
        void alter(const std::vector<std::string>& plhs, const std::vector<types_>& types,
                   const std::list<bool>& not_nulls)
        {
            alter_(plhs, types, not_nulls);
        }
        
        void truncate()
        {
            check_table_empty();
            for (auto iter = matrix_.begin() + 1; iter != matrix_.end();)
            {
                iter = matrix_.erase(iter);
            }
        }
        void update(const std::vector<std::string>& plhs, const std::vector<boost::any>& values, 
                    const std::vector<std::string>& cond_plhs, const std::vector<std::string>& opers,
                    const std::vector<boost::any>& cond_values, const std::vector<std::string>& conds)
        {
            check_table_empty();
            if (cond_plhs.empty())
            {
                update_(plhs, values);
            }
            else
            {
                update_(plhs, values, cond_plhs, opers, cond_values, conds);
            }
        }
 
        void desc(std::ostringstream& os)
        {
            std::for_each(matrix_[0].begin(), matrix_[0].end(), [&os](const Holder& hld)
            {
                os << hld.to_string() << '\t' << Holder::string_from_type(hld.getType()) 
                   << '\t' << Holder::string_from_bool(hld.notNull()) << '\n';
            });
        }
 
        void delete_(const std::vector<std::string>& cond_plhs, const std::vector<std::string>& cond_opers, 
                     const std::vector<boost::any>& cond_values, const std::vector<std::string>& conds)
        {
           if (cond_plhs.empty())
           {
               delete_impl();
           }
           else
           {
               delete_impl(cond_plhs, cond_opers, cond_values, conds);
           }
        }
 
        friend class boost::serialization::access;
    private:
        template<class Archive>
        void save(Archive& ar, const unsigned int version) const
        {
            size_t size = matrix_.size();
            ar & size;
            for (auto iter = matrix_.begin(); iter != matrix_.end(); ++iter)
            {
                ar & *iter;
            }
            ar & table_name_;
        }
        template<class Archive>
        void load(Archive& ar, const unsigned int version)
        {
            size_t size = 0;
            ar & size;
            for (size_t i = 0; i < size; ++i)
            {
                Data dt;
                ar & dt;
                matrix_.push_back(dt);
            }
            ar & table_name_;
        }
        BOOST_SERIALIZATION_SPLIT_MEMBER()
        std::string table_name_;
        TableData matrix_;
 
        std::string select_()
        {
            check_table_empty();
            std::ostringstream ost;
            ost << select_headers();
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&ost, matrix_](const Data& dt)
            {
                auto iter = matrix_[0].begin();
                std::for_each(dt.begin(), dt.end(), [&ost, &iter](const Holder& hld)
                {
                    ost << hld.to_string() << '\t';
                    ++iter;
                });
                ost << '\n';
            });
            return ost.str();
        }
 
        std::string select_(const std::vector<std::string>& plhs)
        {
            check_table_empty();
            std::ostringstream ost;
            ost << select_headers(plhs);
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&ost, &matrix_, &plhs](const Data& dt)
            {
                auto iter = matrix_[0].begin();
                auto plh_iter = plhs.begin();
                std::for_each(dt.begin(), dt.end(), [&ost, &iter, &plh_iter, &plhs](const Holder& hld)
                {
                    if (iter->to_string() == *plh_iter)
                    {
                        ost << hld.to_string() << '\t';
                        ++plh_iter;
                    }
                    ++iter;
                });
                ost << '\n';
            });
            return ost.str();
        }
 
        std::string select_(const std::vector<std::string>& condition_placeholders, 
                           const std::vector<std::string>& conditions,
                           const std::vector<boost::any>& cond_values,
                           const std::vector<std::string>& conds) 
        {
            check_table_empty();
            std::ostringstream ost;
            ost << select_headers();
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&condition_placeholders, &conds, &conditions, &cond_values, &ost, this] 
                  (const Data& dt)
            {
                if (where(dt, condition_placeholders, conditions, cond_values, conds))
                {
                    auto iter = matrix_[0].begin();
                    std::for_each(dt.begin(), dt.end(), [&ost, &iter](const Holder& hld)
                    {
                        ost << hld.to_string() << '\t';
                        ++iter;
                    });
                    ost << '\n';
                }
            });
            return ost.str();
        }
        
        std::string select_(const std::vector<std::string>& plhs, 
                           const std::vector<std::string>& condition_plhs,
                           const std::vector<std::string>& conditions,
                           const std::vector<boost::any>& cond_values,
                           const std::vector<std::string>& conds)
        {
            check_table_empty();
            std::ostringstream ost;
            ost << select_headers(plhs);
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&plhs, conds, &condition_plhs, &conditions, &cond_values, &ost, this]
                                                              (const Data& dt)
            {
                if (where(dt, condition_plhs, conditions, cond_values, conds))
                {
                    auto iter = matrix_[0].begin();
                    auto plh_iter = plhs.begin();
                    std::for_each(dt.begin(), dt.end(), [&ost, &iter, &plh_iter](const Holder& hld)
                    {
                        if (*plh_iter == iter->to_string())
                        {
                            ost << hld.to_string() << '\t';
                            ++plh_iter;
                        }
                        ++iter;
                    });
                    ost << '\n';
                }
            });
            return ost.str();
        }
 
        void insert_(const std::vector<boost::any>& values)
        {
            check_table_empty();
            Data dt;
            auto iterator = matrix_[0].begin();
            for (auto iter = values.begin(); iter != values.end(); ++iter, ++iterator)
            {
                std::string value = boost::any_cast<std::string>(*iter);
                if (iterator->getType() == int_)
                {
                    int val = boost::lexical_cast<int>(value);
                    dt.push_back(Holder(val, iterator->getType()));
                }
                else
                {
                    dt.push_back(Holder(value, iterator->getType()));
                }
            }
            matrix_.push_back(dt);
        }
        
        void insert_(const std::vector<std::string>& plhs, const std::vector<boost::any>& values)
        {
            check_table_empty();
            Data dt;
            auto plh_iter = plhs.begin();
            auto val_iter = values.begin();
            for(auto iter = matrix_[0].begin(); iter != matrix_[0].end(); ++iter)
            {
                if (iter->to_string() == *plh_iter)
                {
                    std::string value = boost::any_cast<std::string>(*val_iter);
                    if (iter->getType() == int_)
                    {
                        int val = boost::lexical_cast<int>(value);
                        dt.push_back(Holder(val, iter->getType()));
                    }
                    else if(iter->getType() == string_)
                    {
                        dt.push_back(Holder(value, iter->getType()));
                    }
                    else
                    {
                    }
                    ++val_iter;
                    ++plh_iter;
                }
                else
                {
                    if (iter->notNull())
                    {
                        throw std::runtime_error("Cannot insert null value in table");
                    }
                    dt.push_back(Holder::value_from_type(iter->getType()));
                }
            }
            matrix_.push_back(dt);
        }
        
        void add_alter_(const std::vector<std::string>& plhs, const std::vector<types_>& types,
                        const std::list<bool>& not_nulls)
        {
            auto pl_iter = plhs.begin();
            auto tp_iter = types.begin();
            auto null_iter = not_nulls.begin();
            for (; pl_iter != plhs.end(); ++pl_iter, ++tp_iter, ++null_iter)
            {
                add_alter_one_(*pl_iter, *tp_iter, *null_iter);
            }
        }
        
        void add_alter_one_(const std::string& plh, const types_& type, bool not_null)
        {
            if (matrix_.empty())
            {
                matrix_.push_back(Data());
            }
            if (not_null && select_() != select_headers())
            {
                throw std::runtime_error("Table should be empty for add not null field");
            }
            auto iter = matrix_[0].insert(matrix_[0].end(), Holder(plh, type, not_null));
            for (auto iter_ = matrix_.begin() + 1; iter_ != matrix_.end(); ++iter_)
            {
                iter_->push_back(Holder::value_from_type(iter->getType()));
            }
        }
        
        void drop_alter_(const std::vector<std::string>& plhs)
        {
            check_table_empty();
            auto pl_iter = plhs.begin();
            for (auto iter = matrix_[0].begin(); iter != matrix_[0].end();)
            {
                if (iter->to_string() == *pl_iter)
                {
                    size_t idx = std::distance(matrix_[0].begin(), iter);
                    for (auto itr = matrix_.begin() + 1; itr != matrix_.end(); ++itr)
                    {
                        itr->erase(itr->begin() + idx); 
                    }
                    iter = matrix_[0].erase(iter);
                    ++pl_iter;
                }
                else
                {
                    ++iter;
                }
            }
            if (select_headers() == "\n\n\n")
            {
                matrix_.clear();
            }
        }
        
        void check_not_nulls(const Data::iterator& iter)
        {
            size_t idx = std::distance(matrix_[0].begin(), iter);
            for (auto itr = matrix_.begin() + 1; itr != matrix_.end(); ++itr)
            {
               if ((itr->begin() + idx)->empty())
               {
                  throw std::runtime_error("Can` t set not null spec to field because there are null values in table");
               }
            }
        }
 
        void alter_(const std::vector<std::string>& plhs, const std::vector<types_>& types,
                    const std::list<bool>& not_nulls)
        {
            check_table_empty();
            auto pl_iter = plhs.begin();
            auto tp_iter = types.begin();
            auto null_iter = not_nulls.begin();
            for (auto iter = matrix_[0].begin(); iter != matrix_[0].end(); ++iter)
            {
                if (iter->to_string() == *pl_iter)
                {
                    if (*null_iter)
                    {
                        check_not_nulls(iter);
                        iter->setNotNull(*null_iter);
                    }
                    size_t idx = std::distance(matrix_[0].begin(), iter);
                    for (auto itr = matrix_.begin() + 1; itr != matrix_.end(); ++itr)
                    {
                        if (*tp_iter == string_)
                        {
                            try
                            {
                                (itr->begin() + idx)->setValue((itr->begin() + idx)->to_string());
                            }
                            catch(const std::exception& e)
                            {
                                (itr->begin() + idx)->setValue(std::string());
                                iter->setNotNull(false);
                            }
                        }
                        else if (*tp_iter == int_)
                        {
                            try
                            {
                                (itr->begin() + idx)->setValue((itr->begin() + idx)->to_int());
                                if (*null_iter)
                                {
                                   (itr->begin() + idx)->setNotNull(true);
                                }
                            }
                            catch (const std::exception& e)
                            {
                                (itr->begin() + idx)->setValue(0);
                                iter->setNotNull(false);
                            }
                        }
                        (itr->begin() + idx)->setType(*tp_iter);
                    }
                    iter->setType(*tp_iter);
                    ++tp_iter;
                    ++pl_iter;
                    ++null_iter;
                }
            }
        }
        
        void update_(const std::vector<std::string>& plhs, const std::vector<boost::any>& values)
        {
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&plhs, &values, &matrix_](Data& dt)
            {
                auto iter = matrix_[0].begin();
                auto pl_iter = plhs.begin();
                auto val_iter = values.begin();
                std::for_each(dt.begin(), dt.end(), [&iter, &pl_iter, &val_iter](Holder& hld)
                {
                    if (iter->to_string() == *pl_iter)
                    {
                        std::string value = boost::any_cast<std::string>(*val_iter);
                        if (iter->getType() == int_)
                        {
                            int val = boost::lexical_cast<int>(value);
                            hld.setValue(val);
                        }
                        else if (iter->getType() == string_)
                        {
                            hld.setValue(value);
                        }
                        else
                        {
                        }
                        hld.setType(iter->getType());
                        ++pl_iter;
                        ++val_iter;
                    }
                    ++iter;
                });
            });
        }
        
        void update_(const std::vector<std::string>& plhs, const std::vector<boost::any>& values, 
                    const std::vector<std::string>& cond_plhs, const std::vector<std::string>& cond_opers,
                    const std::vector<boost::any>& cond_values, const std::vector<std::string>& conds)
        {
            std::for_each(matrix_.begin() + 1, matrix_.end(), [&plhs, &conds, &values, &cond_plhs, &cond_opers, &cond_values, this]
                                                              (Data& dt)
            {
                if (where(dt, cond_plhs, cond_opers, cond_values, conds))
                {
                    auto pl_iter = plhs.begin();
                    auto val_iter = values.begin();
                    auto iter = matrix_[0].begin();
                    std::for_each(dt.begin(), dt.end(), [&pl_iter, &val_iter, &iter](Holder& hld)
                    {
                        if (iter->to_string() == *pl_iter)
                        {
                            std::string value = boost::any_cast<std::string>(*val_iter);
                            if (iter->getType() == int_)
                            {
                                int val = boost::lexical_cast<int>(value);
                                hld.setValue(val);
                            }
                            else if(iter->getType() == string_)
                            {
                                hld.setValue(value);
                            }
                            else
                            {
                            }
                            ++pl_iter;
                            ++val_iter;
                        }
                        ++iter;
                    });
                }
            });
        }
 
        std::string select_headers() const
        {
            std::ostringstream ost;
            ost << '\n';
            std::for_each(matrix_[0].begin(), matrix_[0].end(), [&ost](const Holder& hld)                 
            {
                ost << hld.to_string() << '\t';
            });
            ost << "\n\n";
            return ost.str();
        }
 
        std::string select_headers(const std::vector<std::string>& plhs) const
        {
            std::ostringstream ost;
            ost << '\n';
            auto iter = plhs.begin();
            auto end_iter = plhs.end();
            std::for_each(matrix_[0].begin(), matrix_[0].end(), [&ost, &iter, &end_iter](const Holder& hld)
            {
                if (iter != end_iter)
                {
                    if (hld.to_string() == *iter)
                    {
                        ost << hld.to_string() << '\t';
                        ++iter;
                    }
                }
            });
            ost << "\n\n";
            return ost.str();
        }
 
        void delete_impl()
        {
           check_table_empty();
           for (auto iter = matrix_.begin() + 1; iter != matrix_.end();)
           {
               iter = matrix_.erase(iter);
           };
        }
        
        void delete_impl(const std::vector<std::string>& cond_plhs, const std::vector<std::string>& cond_opers,
                         const std::vector<boost::any>& cond_values, const std::vector<std::string>& conds)
        {
           for (auto iter = matrix_.begin() + 1; iter != matrix_.end();)
           {
               if (where(*iter, cond_plhs, cond_opers, cond_values, conds))
               {
                  iter = matrix_.erase(iter);
               }
               else
               {
                  ++iter;
               }
           }
        }
 
        bool where(const Data& dt,
                   const std::vector<std::string>& condition_plhs,
                   const std::vector<std::string>& conditions,
                   const std::vector<boost::any>& cond_values,
                   const std::vector<std::string>& conds)
        {
            bool flg = true;
            bool first = true;
            auto intern_plh_iter = matrix_[0].begin();
            auto cond_plh_iter = condition_plhs.begin();
            auto cond_iter = conditions.begin();
            auto cond_val_iter = cond_values.begin();
            auto or_and_iter = conds.begin();
            auto data_iter = dt.begin();
            for (; intern_plh_iter != matrix_[0].end(); ++intern_plh_iter, ++data_iter)
            {
                if (*cond_plh_iter == intern_plh_iter->to_string())
                {
                    std::string cond_value = boost::any_cast<std::string>(*cond_val_iter);
                    if (intern_plh_iter->getType() == string_)
                    {
                        std::string value = boost::any_cast<std::string>(data_iter->getValue());
                        if (!compare(value, *cond_iter, cond_value))
                        {
                            flg = false;
                        }
                        else
                        {
                            flg = true;
                        }
                    }
                    else if (intern_plh_iter->getType() == int_)
                    {
                        int val = boost::any_cast<int>(data_iter->getValue());
                        int cond_val = boost::lexical_cast<int>(cond_value);
                        if (!compare(val, *cond_iter, cond_val))
                        {
                            flg = false;    
                        }
                        else
                        {
                            flg = true;
                        }
                    }
                    if (or_and_iter == conds.end())
                    {
                        break;
                    }
                    if (*or_and_iter == "and")
                    {
                        if (!flg)
                        {
                            break;
                        }
                        flg = flg && flg;
                    }
                    else if (*or_and_iter == "or")
                    {
                        if (flg)
                        {
                            break;
                        }
                        flg = flg || flg;
                    }
                    ++cond_plh_iter;
                    ++cond_iter;
                    ++cond_val_iter;
                    if (!first)
                    {
                        ++or_and_iter;
                    }
                    if (first)
                    {
                        first = false;
                    }
                }
            }
            return flg;
        }
 
        template<class T>
        bool compare(const T& first, const std::string& oper, const T& second)
        {
            bool flg = false;
            if (oper == "=")
            {
                flg = first == second;
            }
            else if (oper == "!=")
            {
                flg = first != second;
            }
            else if (oper == "<")
            {
                flg = first < second;
            }
            else if (oper == ">")
            {
                flg = first > second;
            }
            else if (oper == "<=")
            {
                flg = first <= second;
            }
            else if (oper == ">=")
            {
                flg = first >= second;
            }
            return flg;
        }
 
        void check_table_empty()
        {
            if (matrix_.empty())
            {
                throw std::runtime_error("Table is empty");
            }
        }
    };
    
    struct TableCmpByTblName
    {
    public:
        TableCmpByTblName(const std::string& tbl_name):
            table_name(tbl_name)
        {
        }
        bool operator () (const Table& tbl)
        {
            return table_name == tbl.getName();
        }
    private:
        std::string table_name;
    };
 
    class DataBase
    {
    public:
        DataBase()
        {
        }
        explicit DataBase(const std::string& name):db_name(name)
        {
        }
        const std::string& getName() const {return db_name;}
        const std::vector<Table>& getDB() const {return db;}
        std::string show() const 
        {
            std::ostringstream ost;
            ost << "\nTables in database " << db_name << "\n";
            check_db_empty();
            for (auto iter = db.begin(); iter != db.end(); ++iter)
            {
                ost << iter->getName() << '\n';
            }
            ost << '\n';
            return ost.str();
        }
        std::string desc(const std::string& tbl_name)
        {
            std::ostringstream ost;
            ost << "\nField" << '\t'
                << "Type" << '\t'
                << "Null?" << "\n\n";
            auto iter = find_table_by_name(tbl_name);
            iter->desc(ost);
            ost << "\n";
            return ost.str();
        }
        void create_tbl(const std::string& tbl_name, const std::vector<std::string>& plhs, 
                    const std::vector<types_>& tps, const std::list<bool>& nulls)
        {
            check_table_exist(tbl_name);
            auto iter = db.insert(db.end(), Table(tbl_name));
            iter->create(plhs, tps, nulls);
        }
        void insert(const std::string& tbl_name, const std::vector<std::string>& plhs, 
                    const std::vector<boost::any>& values)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->insert(plhs, values);
        }
        std::string select(const std::string& tbl_name, const std::vector<std::string>& plhs,
                           const std::vector<std::string>& condition_placeholders,
                           const std::vector<std::string>& conditions,
                           const std::vector<boost::any>& cond_values,
                           const std::vector<std::string>& conds)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            return iter->select(plhs, condition_placeholders, conditions, cond_values, conds);
        }
        void add_alter(const std::string& tbl_name, const std::vector<std::string>& plhs, const std::vector<types_>& types,
                       const std::list<bool>& nulls)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->add_alter(plhs, types, nulls);
        }
        void drop_alter(const std::string& tbl_name, const std::vector<std::string>& plhs)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->drop_alter(plhs);
        }
        void alter(const std::string& tbl_name, const std::vector<std::string>& plhs, const std::vector<types_>& types,
                   const std::list<bool>& nulls)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->alter(plhs, types, nulls);
        }
        void drop(const std::string& tbl_name)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            db.erase(iter);
        }
        void truncate(const std::string& tbl_name)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->truncate();
        }
        void update(const std::string& tbl_name, const std::vector<std::string>& plhs, const std::vector<boost::any>& values,
                    const std::vector<std::string>& cond_plhs, const std::vector<std::string>& cond_opers, 
                    const std::vector<boost::any>& cond_values, const std::vector<std::string>& conds)
        {
            check_db_empty();
            auto iter = find_table_by_name(tbl_name);
            iter->update(plhs, values, cond_plhs, cond_opers, cond_values, conds);
        }
        void push_back(const Table& tbl)
        {
            db.push_back(tbl);
        }
        void delete_(const std::string& tbl_name, const std::vector<std::string>& cond_plhs, const std::vector<std::string>& cond_opers,
                     const std::vector<boost::any>& cond_values, const std::vector<std::string>& conds)
        {
           check_db_empty();
           auto iter = find_table_by_name(tbl_name);
           iter->delete_(cond_plhs, cond_opers, cond_values, conds);
        }
        friend class boost::serialization::access;
    private:
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            ar & db;
            ar & db_name;
        }
        std::vector<Table> db;
        std::string db_name;
        std::vector<Table>::iterator find_table_by_name(const std::string& tbl_name)
        {
            std::vector<Table>::iterator iter = std::find_if(db.begin(), db.end(), TableCmpByTblName(tbl_name));
            if (iter == db.end())
            {
                throw std::logic_error("Table doesn`t exist");
            }
            return iter;
        }
        void check_db_empty() const
        {
            if (db.size() == 0)
            {
                throw std::logic_error("Database is empty");
            }
        }
        void check_table_exist(const std::string& tbl_name)
        {
            try
            {
                find_table_by_name(tbl_name);
            }
            catch(const std::logic_error& e)
            {
                return;
            }
            throw std::runtime_error("Table is allready exist");
        }
    };
}
 
void save(const my::Table& tbl, const boost::filesystem::path& f_path)
{
    boost::filesystem::ofstream ofs(f_path);
    boost::archive::text_oarchive oarch(ofs);
    oarch.register_type(static_cast<my_serialization::Template<std::string>*>(0));
    oarch.register_type(static_cast<my_serialization::Template<int>*>(0));
    oarch << tbl;
}
 
void load(my::Table& tbl, const boost::filesystem::path& f_path)
{
    boost::filesystem::ifstream ifs(f_path);
    boost::archive::text_iarchive iarch(ifs);
    iarch.register_type(static_cast<my_serialization::Template<std::string>*>(0));
    iarch.register_type(static_cast<my_serialization::Template<int>*>(0));
    iarch >> tbl;
}
 
void save_base(const my::DataBase& DataBase_)
{
    boost::filesystem::path path(boost::filesystem::current_path());
    path /= "storage/";
    path /= DataBase_.getName();
    if (boost::filesystem::exists(path))
    {
        boost::filesystem::remove_all(path);
    }
    boost::filesystem::create_directories(path);
    for (auto iter = DataBase_.getDB().begin(); iter != DataBase_.getDB().end(); ++iter)
    {
        boost::filesystem::path temp_path = path;
        temp_path /= iter->getName();
        save(*iter, temp_path);
    }
}
 
void load_base(my::DataBase& DataBase_)
{
    boost::filesystem::path path(boost::filesystem::current_path() / "storage/");
    if (!boost::filesystem::exists(path))
    {
        return;
    }
    for (auto dir_iter = boost::filesystem::recursive_directory_iterator(path);
        dir_iter != boost::filesystem::recursive_directory_iterator(); ++dir_iter)
    {
        if (!boost::filesystem::is_directory(dir_iter->path()))
        {
            break;
        }
        boost::filesystem::directory_entry& dir_entr = *dir_iter;
        for (auto d_iter = boost::filesystem::directory_iterator(dir_entr.path()); 
            d_iter != boost::filesystem::directory_iterator(); ++d_iter)
        {
            my::Table tbl;
            load(tbl, d_iter->path());
            DataBase_.push_back(tbl);
        }
    }
}
 
class Program
{
public:
    Program()
    {
        functions = 
        {
            std::make_pair("create", &Program::create),
            std::make_pair("insert", &Program::insert),
            std::make_pair("select", &Program::select),
            std::make_pair("help", &Program::help),
            std::make_pair("alter", &Program::alter),
            std::make_pair("drop", &Program::drop),
            std::make_pair("truncate", &Program::truncate),
            std::make_pair("delete", &Program::delete_),
            std::make_pair("update", &Program::update),
            std::make_pair("show", &Program::show),
            std::make_pair("desc", &Program::desc),
            std::make_pair("describe", &Program::desc),
            std::make_pair("quit", &Program::quit),
            std::make_pair("exit", &Program::quit)
        };
    }
    static bool process(const std::string& command, my::DataBase& DataBase_, std::ostream& os = std::cout)
    {
        Program prog;
        try
        {
            std::vector<std::string> commands = Parser()(command);
            functions[commands.at(0)](&prog, commands, DataBase_);
            if (commands.at(0) == "quit" || commands.at(0) == "exit")
            {
                return true;
            }
        }
        catch (const Parser_Error& e)
        {
        }
        catch (const std::out_of_range& e)
        {
            std::cout << "ERROR: " << e.what() << std::endl;
            //throw std::runtime_error(std::string("Wrong command") + "\n" + comm_string);
        }
        catch (const std::exception& e)
        {
            std::cout << "ERROR: " << e.what() << std::endl;
            //throw std::runtime_error(std::string(e.what()) + "\n" + comm_string);
        }
        return false;
    }
private:
    
    static std::map<std::string, boost::function<void(Program*, const std::vector<std::string>&, my::DataBase&)>> functions;
 
    void create(const std::vector<std::string>& commands, my::DataBase& DataBase_)
    {
        std::copy(commands.begin(), commands.end(), std::ostream_iterator<std::string>(std::cout, "\n"));
        std::string table_name = commands.at(1);
        std::vector<std::string> plhs;
        std::vector<my::types_> tps;
        std::list<bool> nulls;
        for (std::vector<std::string>::const_iterator iter = commands.begin() + 2; iter != commands.end();)
        {
            plhs.push_back(*iter);
            ++iter;
            tps.push_back(my::Holder::type_from_string(*iter));
            ++iter;
            if (*iter == "not null")
            {
                nulls.push_back(true);
            }
            else
            {
                nulls.push_back(false);
            }
            ++iter;
        }
        DataBase_.create_tbl(table_name, plhs, tps, nulls);
    }
    
    void insert(const std::vector<std::string>& commands, my::DataBase& DataBase_)
    {
        std::string table_name = commands.at(2);
        auto iter = commands.begin() + 2;
        std::vector<std::string> plhs;
        if (*(++iter) != "values")
        {
            for (; *iter != "values"; ++iter)
            {
                plhs.push_back(*iter);
            }
        }
        ++iter;
        std::vector<boost::any> values;
        for(; iter != commands.end(); ++iter)
        {
            values.push_back(*iter);
        }
        DataBase_.insert(table_name, plhs, values);
    }
    void select(const std::vector<std::string>& commands, my::DataBase& DataBase_) const
    {
        std::vector<std::string> plhs;
        auto iter = commands.begin() + 1;
        if (*iter != "*")
        {
            for (; *iter != "from"; ++iter)
            {
                plhs.push_back(*iter);
            }
            ++iter;
        }
        else
        {
            iter += 2;
        }
        std::string table_name = *iter;
        std::vector<std::string> cond_plhs;
        std::vector<std::string> opers;
        std::vector<boost::any> cond_values;
        std::vector<std::string> conds;
        ++iter;
        if (iter != commands.end() && *iter == "where")
        {
            ++iter;
            for (; iter != commands.end();)
            {
                cond_plhs.push_back(*iter);
                ++iter;
                opers.push_back(*iter);
                ++iter;
                cond_values.push_back(*iter);
                ++iter;
                if (iter != commands.end())
                {
                    conds.push_back(*iter);
                    ++iter;
                }
            }
        }
        std::cout << DataBase_.select(table_name, plhs, cond_plhs, opers,
                     cond_values, conds) << std::endl;
    }
    void alter(const std::vector<std::string>& commands, my::DataBase& DataBase_)
    {
        std::string table_name = commands.at(1);
        std::vector<std::string> plhs;
        std::vector<my::types_> types;
        std::list<bool> not_nulls;
        if (commands.at(2) == "add")
        {
            for (auto iter = commands.begin() + 3; iter != commands.end();)
            {
                plhs.push_back(*iter);
                ++iter;
                types.push_back(my::Holder::type_from_string(*iter));
                ++iter;
                if (*iter == "not null")
                {
                    not_nulls.push_back(true);
                }
                else
                {
                    not_nulls.push_back(false);
                }
                ++iter;
            }
            DataBase_.add_alter(table_name, plhs, types, not_nulls);
        }
        else if (commands.at(2) == "drop")
        {
            plhs = std::vector<std::string>(commands.begin() + 3, commands.end());
            DataBase_.drop_alter(table_name, plhs);
        }
        else if (commands.at(2) == "alter")
        {
            for (auto iter = commands.begin() + 3; iter != commands.end();)
            {
                plhs.push_back(*iter);
                ++iter;
                types.push_back(my::Holder::type_from_string(*iter));
                ++iter;
                if (*iter == "not null")
                {
                    not_nulls.push_back(true);
                }
                else
                {
                    not_nulls.push_back(false);
                }
                ++iter;
            }
            DataBase_.alter(table_name, plhs, types, not_nulls);
        }
    }
    void drop(const std::vector<std::string>& commands, my::DataBase& DataBase_)
    {
        std::string table_name = commands.at(1);
        DataBase_.drop(table_name);
    }
    void truncate(const std::vector<std::string>& commands, my::DataBase& DataBase_)
    {
        std::string table_name = commands.at(1);
        DataBase_.truncate(table_name);
    }
    void update(const std::vector<std::string>& commands, my::DataBase& DataBase_)
    {
        std::string table_name = commands.at(1);
        std::vector<std::string> plhs;
        std::vector<boost::any> values;
        std::vector<std::string> cond_plhs;
        std::vector<std::string> cond_opers;
        std::vector<boost::any> cond_values;
        std::vector<std::string> conds;
        auto iter = commands.begin() + 3;
        for (; iter != commands.end() && *iter != "where";)
        {
            plhs.push_back(*iter);
            ++iter;
            ++iter;
            values.push_back(*iter);
            ++iter;
        }
        if (iter != commands.end() && *iter == "where")
        {
            ++iter;
            for (; iter != commands.end();)
            {
                cond_plhs.push_back(*iter);
                ++iter;
                cond_opers.push_back(*iter);
                ++iter;
                cond_values.push_back(*iter);
                ++iter;
                if (iter != commands.end())
                {
                    conds.push_back(*iter);
                    ++iter;
                }
            }
        }
        DataBase_.update(table_name, plhs, values, cond_plhs, cond_opers, cond_values, conds);
    }
    
    void show(const std::vector<std::string>&, const my::DataBase& DataBase_)
    {
        std::cout << DataBase_.show() << std::endl;
    }
    
    void desc(const std::vector<std::string>& commands, my::DataBase& DataBase_)
    {
        std::string table_name = commands.at(1);
        my::DataBase base = const_cast<my::DataBase&>(DataBase_);
        std::cout << base.desc(table_name) << std::endl;
    }
   
    void delete_(const std::vector<std::string>& commands, my::DataBase& DataBase_)
    {
        std::string table_name = commands.at(2);
        auto iter = commands.begin() + 3;
        std::vector<boost::any> cond_values;
        std::vector<std::string> cond_plhs;
        std::vector<std::string> cond_opers;
        std::vector<std::string> conds;
        if (iter != commands.end() && *iter == "where")
        {
           ++iter;
           for (; iter != commands.end();)
           {
               cond_plhs.push_back(*iter);
               ++iter;
               cond_opers.push_back(*iter);
               ++iter;
               cond_values.push_back(*iter);
               ++iter;
               if (iter != commands.end())
               {
                   conds.push_back(*iter);
                   ++iter;
               }
           }
        }
        DataBase_.delete_(table_name, cond_plhs, cond_opers, cond_values, conds);
    }
 
    void help(const std::vector<std::string>&, my::DataBase&)
    {
        std::cout << "----------------HELP-------------------\n\n";
        std::cout << "Simple database 1.0\n";
        std::cout << "Commands: create, insert, select, alter, drop, update, truncate\n";
        std::cout << "Examples of usage\n";
        std::cout << "Example of create: create tbl1 id:number, name:string\n";
        std::cout << "Command create table named tbl1 with fields id with type number and name with type string\n";
        std::cout << "Example of insert: insert into tbl1 values 1, a\n";
        std::cout << "Command insert in table named tbl1 value 1 in id and a in name\n";
        std::cout << "Example of insert: insert into tbl1 id values 1\n";
        std::cout << "Command insert in table named tbl1 values 1 in id and null in name (for string null is empty string)\n";
        std::cout << "Example of select: select * from tbl1\n";
        std::cout << "Command select values from all fields of tbl1\n";
        std::cout << "Example of select: select * from tbl1 where id = 1\n";
        std::cout << "Command select values from all fields of tbl1 where value of field id = 1\n";
        std::cout << "Example of select: select id from tbl1 where name = a\n";
        std::cout << "Command select values from field if of tbl1 where values of field name = a\n";
        std::cout << "Example of alter: alter tbl1 add value:string\n";
        std::cout << "Command add to table field value with type string\n";
        std::cout << "Example of alter: alter tbl1 drop value\n";
        std::cout << "Command drop from table column named values\n";
        std::cout << "Example of alter: alter tbl1 alter value:number\n";
        std::cout << "Command change type of field value to number\n";
        std::cout << "Example of drop: drop tbl1\n";
        std::cout << "Command drop all table. After this command table is destroyed\n";
        std::cout << "Example of truncate: truncate tbl1\n";
        std::cout << "Command drop all values in the table\n";
        std::cout << "Example of update: update tbl1 set id = 1\n";
        std::cout << "Command set value of field named id in 1 in all table\n";
        std::cout << "Example of update: update tbl1 set id = 1 where name = a\n";
        std::cout << "Command set value of field named id in 1 if value of field name in this row = a\n";
        std::cout << "IN THIS VERSION SPACES IN CONDITIONS FOR WHERE ARE OBLIGATORY\n";
        std::cout << "Thanks. Good luck\n";
        std::cout << "----------------------------------------\n\n";
    }
    
    void quit(const std::vector<std::string>&, my::DataBase& DataBase_)
    {
        save_base(DataBase_);
    }
};
 
std::map<std::string, boost::function<void(Program*, const std::vector<std::string>&, my::DataBase&)>> Program::functions;

Парсер

C++

#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <boost/spirit/include/phoenix_object.hpp>
#include <boost/spirit/include/phoenix_statement.hpp>
#include <boost/bind.hpp>
 
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
 
namespace fusion = boost::fusion;
namespace phoenix = boost::phoenix;
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
 
void push_tokens(std::vector<std::string>& tokens, const std::vector<std::string>& values)
{
    tokens.insert(tokens.end(), values.begin(), values.end());
}
 
void push_token(std::vector<std::string>& tokens, const std::string& val)
{
    tokens.push_back(val);
}
 
/* Grammar
 *
 * Expr : PrimaryCommand
 * PrimaryCommand : InsertCommand | SelectCommand | CreateCommand | DeleteCommand | AlterCommand | TruncateCommand |
 * UpdateCommand | DescCommand | ShowCommand | DropCommand | QuitCommand | HelpCommand
 * InsertCommand : insert into Name ([Names]) values (Values);
 * SelectCommand : select Names | * from Name [Conditions];
 * CreateCommand : create Name (Names and Types);
 * DeleteCommand : delete from Name [Conditions];
 * AlterCommand : alter Name Alter_add | Alter_drop | Alter_alter;
 * TruncateCommand : truncate Name;
 * UpdateCommand : update Name set Names and Values [Conditions];
 * DescCommand : desc | describe Name
 * ShowCommand : show Name
 * DropCommand : drop Name
 * Help : help
 * QuitCommand : quit | exit
 * Names : Name +[, Name]
 * Name : name of table, variable ect
 * Conditions : where Condition +[Cond Condition];
 * Condition : Name Oper Value
 * Oper : = | <= | >= | != | < | >
 * Value : value
 * Cond : and | or
 * Types : Type +[, Type]
 * Type : number | string
 * Not_null : not null | " "
 * Name and Type : Name Type Not_null
 * Names and Types : Name and Type +[, Name and Type]
 * Name and Value : Name = Value
 * Names and Values : Name and Value +[, Name and Value]
 *
*/
 
template<typename Iterator>
struct sql_grammar:qi::grammar<Iterator, std::vector<std::string>(), qi::locals<std::string>, ascii::space_type>
{
    sql_grammar(std::ostringstream& os):sql_grammar::base_type(root, "sql"), stream(os)
    {
        using qi::lit;
        using qi::lexeme;
        using qi::on_error;
        using qi::fail;
        using qi::omit;
        using ascii::char_;
        using ascii::string;
 
        using phoenix::construct;
        using phoenix::val;
        using phoenix::push_back;
        
        type = string("number") | string("string");
        name = lexeme[+(char_("a-zA-Z0-9_"))];
        not_null_spec = string("not null") | string("");
        value = lexeme[+(char_("a-zA-Z0-9_"))];
        oper = string("=") | string("!=") | string("<=") | string(">=") | string("<") | string(">");
        cond = string("and") | string("or");
 
        names = name [push_back(qi::_val, qi::_1)]
            > -(+(omit[char_(',')] > name [push_back(qi::_val, qi::_1)]))
        ;
 
        name_and_type = name [push_back(qi::_val, qi::_1)]
            > type [push_back(qi::_val, qi::_1)]
            > not_null_spec [push_back(qi::_val, qi::_1)]
        ;
 
        name_and_value = name [push_back(qi::_val, qi::_1)]
            > string("=") [push_back(qi::_val, qi::_1)]
            > value [push_back(qi::_val, qi::_1)]
        ;
 
        names_and_values = name_and_value [boost::bind(&push_tokens, ref(tokens), _1)]
            > -(+(omit[char_(',')] > name_and_value [boost::bind(&push_tokens, ref(tokens), _1)]))
        ;
 
        names_and_types = name_and_type [boost::bind(&push_tokens, ref(tokens), _1)]
            > -(+(omit[char_(',')] > name_and_type [boost::bind(&push_tokens, ref(tokens), _1)]))
        ;
        
        values = value [push_back(qi::_val, qi::_1)]
            > -(+(omit[char_(',')]> value [push_back(qi::_val, qi::_1)]))
        ;
        
        condition = name [push_back(qi::_val, qi::_1)]
            > oper [push_back(qi::_val, qi::_1)]
            > value [push_back(qi::_val, qi::_1)]
        ;
 
        conditions = condition [boost::bind(&push_tokens, ref(tokens), _1)]
            > -(+(cond [boost::bind(&push_token, ref(tokens), _1)]
            > condition [boost::bind(&push_tokens, ref(tokens), _1)]))
        ;
 
        where = string("where") [boost::bind(&push_token, ref(tokens), _1)]
            > conditions;
        
        alter_add = string("add") [boost::bind(&push_token, ref(tokens), _1)]
            > names_and_types
        ;
 
        alter_drop = string("drop") [boost::bind(&push_token, ref(tokens), _1)]
            > names [boost::bind(&push_tokens, ref(tokens), _1)]
        ;
 
        alter_alter = string("alter") [boost::bind(&push_token, ref(tokens), _1)]
            > names_and_types
        ;
 
        create = string("create") [boost::bind(&push_token, ref(tokens), _1)]
            > name [boost::bind(&push_token, ref(tokens), _1)]
            > omit[char_('(')] > names_and_types > omit[char_(')')]
            > omit[char_(';')]
        ;
 
        insert = string("insert") [boost::bind(&push_token, ref(tokens), _1)]
            > string("into") [boost::bind(&push_token, ref(tokens), _1)]
            > name [boost::bind(&push_token, ref(tokens), _1)]
            > -(omit[char_('(')] > names [boost::bind(&push_tokens, ref(tokens), _1)] > omit[char_(')')])
            > string("values") [boost::bind(&push_token, ref(tokens), _1)]
            > omit[char_('(')] > values [boost::bind(&push_tokens, ref(tokens), _1)] > omit[char_(')')]
            > omit[char_(';')]
        ;
        
        select = string("select") [boost::bind(&push_token, ref(tokens), _1)]
            > (names [boost::bind(&push_tokens, ref(tokens), _1)] | string("*") [boost::bind(&push_token, ref(tokens), _1)])
            > string("from") [boost::bind(&push_token, ref(tokens), _1)]
            > name [boost::bind(&push_token, ref(tokens), _1)]
            > -where
            > omit[char_(';')]
        ;
 
        delete_ = string("delete") [boost::bind(&push_token, ref(tokens), _1)]
            > string("from") [boost::bind(&push_token, ref(tokens), _1)]
            > name [boost::bind(&push_token, ref(tokens), _1)]
            > -where
            > omit[char_(';')]
        ;
        
        update = string("update") [boost::bind(&push_token, ref(tokens), _1)]
            > name [boost::bind(&push_token, ref(tokens), _1)]
            > string("set") [boost::bind(&push_token, ref(tokens), _1)]
            > names_and_values
            > -where
            > omit[char_(';')]
        ;
        
        alter = string("alter") [boost::bind(&push_token, ref(tokens), _1)]
            > name [boost::bind(&push_token, ref(tokens), _1)]
            > (alter_add | alter_drop | alter_alter)
            > omit[char_(';')]
        ;
        
        truncate = string("truncate") [boost::bind(&push_token, ref(tokens), _1)]
            > name [boost::bind(&push_token, ref(tokens), _1)]
            > omit[char_(';')]
        ;
        
        drop = string("drop") [boost::bind(&push_token, ref(tokens), _1)]
            > name [boost::bind(&push_token, ref(tokens), _1)]
            > omit[char_(';')]
        ;
        
        desc = (string("desc") | string("describe")) [boost::bind(&push_token, ref(tokens), _1)]
            > name [boost::bind(&push_token, ref(tokens), _1)]
            > -omit[char_(';')]
        ;
 
        show = (string("show")) [boost::bind(&push_token, ref(tokens), _1)]
            > -omit[char_(';')]
        ;
 
        quit = (string("quit") | string("exit")) [boost::bind(&push_token, ref(tokens), _1)]
            > -omit[char_(';')]
        ;
 
        help = string("help") [boost::bind(&push_token, ref(tokens), _1)]
            > -omit[char_(';')]
        ;
 
        root = create | insert | select | delete_ | update | alter | truncate
            | drop | desc | show | quit | help;
        
        root.name("expression");
        create.name("create command");
        table_name_for_create.name("table name");
        name_and_type.name("name and type");
        names_and_types.name("names and types");
        type.name("value type");
        name.name("name");
        names.name("names");
        insert.name("insert command");
        value.name("value");
        values.name("values");
        select.name("select command");
        cond.name("cond");
        condition.name("condition");
        conditions.name("conditions");
        where.name("where");
        delete_.name("delete");
        name_and_value.name("name and value");
        names_and_values.name("names and values");
        alter_add.name("alter add command");
        alter_drop.name("alter drop command");
        alter_alter.name("alter alter command");
        alter.name("alter command");
        truncate.name("truncate command");
        drop.name("drop command");
        desc.name("describe command");
        show.name("show command");
        quit.name("quit command");
        help.name("help command");
 
        on_error<fail>
        (
           root,
           stream << val("Error! Expected ")
           << qi::_4
           << val(" here: \"")
           << construct<std::string>(qi::_3, qi::_2)
           << val("\"")
           << std::endl
        );
    }
    
    qi::rule<Iterator, std::vector<std::string>(), qi::locals<std::string>, ascii::space_type> root;
    qi::rule<Iterator, std::vector<std::string>(), ascii::space_type> names_and_types, name_and_type, names,
        create, values, insert, select, where, conditions, condition, delete_, names_and_values, name_and_value,
        update, alter_add, alter_drop, alter_alter, alter, truncate, drop, desc, show, quit, help;
    qi::rule<Iterator, std::string(), ascii::space_type> table_name_for_create, type, name, not_null_spec, value,
        oper, cond;
 
    const std::vector<std::string> get_tokens() const {return tokens;}
private:
    std::ostringstream stream;
    std::vector<std::string> tokens;
};
 
class Parser_Error:public std::runtime_error
{
public:
    Parser_Error(const std::string& msg):std::runtime_error(msg)
    {
    }
};
 
class Parser
{
public:
    std::vector<std::string> operator() (const std::string& text, std::ostringstream& os)
    {
        std::string::const_iterator begin = text.begin();
        std::string::const_iterator end = text.end();
        sql_grammar<std::string::const_iterator> grammar(os);
        std::vector<std::string> temp;
        bool r = false;
        r = phrase_parse(begin, end, grammar, ascii::space, temp);
        if (r && begin == end)
        {
            return grammar.get_tokens();
        }
        else
        {
            std::cout << os.str() << std::endl;
            throw Parser_Error("Parser error");
        }
    }
};

Добавлено через 7 часов 51 минуту
Пофиксил парсер. Со стримом буду думать что делать.

парсер

C++

#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <boost/spirit/include/phoenix_object.hpp>
#include <boost/spirit/include/phoenix_statement.hpp>
#include <boost/bind.hpp>
 
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
 
namespace fusion = boost::fusion;
namespace phoenix = boost::phoenix;
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
 
void push_tokens(std::vector<std::string>& tokens, const std::vector<std::string>& values)
{
    tokens.insert(tokens.end(), values.begin(), values.end());
}
 
void push_token(std::vector<std::string>& tokens, const std::string& val)
{
    tokens.push_back(val);
}
 
/* Grammar
 *
 * Expr : PrimaryCommand
 * PrimaryCommand : InsertCommand | SelectCommand | CreateCommand | DeleteCommand | AlterCommand | TruncateCommand |
 * UpdateCommand | DescCommand | ShowCommand | DropCommand | QuitCommand | HelpCommand
 * InsertCommand : insert into Name ([Names]) values (Values);
 * SelectCommand : select Names | * from Name [Conditions];
 * CreateCommand : create Name (Names and Types);
 * DeleteCommand : delete from Name [Conditions];
 * AlterCommand : alter Name Alter_add | Alter_drop | Alter_alter;
 * TruncateCommand : truncate Name;
 * UpdateCommand : update Name set Names and Values [Conditions];
 * DescCommand : desc | describe Name
 * ShowCommand : show Name
 * DropCommand : drop Name
 * Help : help
 * QuitCommand : quit | exit
 * Names : Name +[, Name]
 * Name : name of table, variable ect
 * Conditions : where Condition +[Cond Condition];
 * Condition : Name Oper Value
 * Oper : = | <= | >= | != | < | >
 * Value : value
 * Cond : and | or
 * Types : Type +[, Type]
 * Type : number | string
 * Not_null : not null | " "
 * Name and Type : Name Type Not_null
 * Names and Types : Name and Type +[, Name and Type]
 * Name and Value : Name = Value
 * Names and Values : Name and Value +[, Name and Value]
 *
*/
 
template<typename Iterator>
struct sql_grammar:qi::grammar<Iterator, std::vector<std::string>(), qi::locals<std::string>, ascii::space_type>
{
    sql_grammar():sql_grammar::base_type(root, "sql")
    {
        using qi::lit;
        using qi::lexeme;
        using qi::on_error;
        using qi::fail;
        using qi::omit;
        using qi::as_string;
        using qi::eps;
        using ascii::char_;
        using ascii::string;
 
        using phoenix::construct;
        using phoenix::val;
        using phoenix::push_back;
        
        type = string("number") | string("string");
        name = lexeme[+char_("a-zA-Z0-9_")];
        not_null_spec = string("not null") | string("");
        value = lexeme[+char_("a-zA-Z0-9_")];
        oper = string("=") | string("!=") | string("<=") | string(">=") | string("<") | string(">");
        cond = string("and") | string("or");
        aster = string("*");
 
        names = name > *(lit(",") > name);
        name_and_type = name > type > not_null_spec;
        name_and_value = name > string("=") > value;
        names_and_values = name_and_value > *(lit(",") > name_and_value);
        names_and_types = name_and_type > *(lit(",") > name_and_type);
        values = value > -(+(lit(",") > value));
        condition = name > oper > value;
        conditions = condition > *(cond > condition);
        where = string("where") > conditions;
        alter_add = string("add") > names_and_types;
        alter_drop = string("drop") > names;
        alter_alter = string("alter") > names_and_types;
 
        create = string("create") > name
            > lit("(") > names_and_types > lit(")") > lit(";");
 
        insert = string("insert") > string("into") > name
            > -(lit("(") > names > lit(")")) > string("values")
            > lit("(") > values > lit(")") > lit(";");
        
        select = string("select") > (names | aster) > string("from")
            > name > -where > lit(";");
 
        delete_ = string("delete") > string("from") > name
            > -where > lit(";");
        
        update = string("update") > name > string("set")
            > names_and_values > -where > lit(";");
        
        alter = string("alter") > name
            > (alter_add | alter_drop | alter_alter) > lit(";");
        
        truncate = string("truncate") > name > lit(";");
        drop = string("drop") > name > lit(";");
        desc = (string("desc") | string("describe")) > name > -lit(";");
        show = (string("show")) > -lit(";");
        quit = (string("quit") | string("exit")) > -lit(";");
        help = string("help") > -lit(";");
 
        root = create | insert | select | delete_ | update | alter | truncate
            | drop | desc | show | quit | help;
        
        root.name("expression");
        create.name("create command");
        name_and_type.name("name and type");
        names_and_types.name("names and types");
        type.name("value type");
        name.name("name");
        names.name("names");
        insert.name("insert command");
        value.name("value");
        values.name("values");
        select.name("select command");
        cond.name("cond");
        condition.name("condition");
        conditions.name("conditions");
        where.name("where");
        delete_.name("delete");
        name_and_value.name("name and value");
        names_and_values.name("names and values");
        alter_add.name("alter add command");
        alter_drop.name("alter drop command");
        alter_alter.name("alter alter command");
        alter.name("alter command");
        truncate.name("truncate command");
        drop.name("drop command");
        desc.name("describe command");
        show.name("show command");
        quit.name("quit command");
        help.name("help command");
 
        /*on_error<fail>
        (
           root,
           stream << val("Error! Expected ")
           << qi::_4
           << val(" here: \"")
           << construct<std::string>(qi::_3, qi::_2)
           << val("\"")
           << std::endl
        );*/
      auto function = [&stream_]
      (
         const fusion::vector<Iterator, const Iterator&, const Iterator&, const boost::spirit::info&>& pars,
         const typename sql_grammar::base_type::start_type::context_type&, const qi::error_handler_result&
      )
      {
         stream_ << "Error! Expected: " << fusion::at_c<3>(pars) << " here: \""
         << std::string(fusion::at_c<2>(pars), fusion::at_c<1>(pars)) << "\"" << std::endl;
      };
      on_error<fail>
      (
         root, function
      );
    }
    
    std::string get_error() const
    {
       std::string result = stream_.str();
       stream_.clear();
       return result;
    }
 
    qi::rule<Iterator, std::vector<std::string>(), qi::locals<std::string>, ascii::space_type> root;
    qi::rule<Iterator, std::vector<std::string>(), ascii::space_type> names_and_types, name_and_type, names,
        create, values, insert, select, where, conditions, condition, delete_, names_and_values, name_and_value,
        update, alter_add, alter_drop, alter_alter, alter, truncate, drop, desc, show, quit, help;
    qi::rule<Iterator, std::string(), ascii::space_type> type, name, not_null_spec, value,
        oper, cond, aster;
private:
    mutable std::ostringstream stream_;
};
 
template<typename Iterator>
std::ostream& operator << (std::ostream& os, const sql_grammar<Iterator>& grammar)
{
   os << grammar.get_error();
   return os;
}
 
class Parser_Error:public std::runtime_error
{
public:
    Parser_Error(const std::string& msg):std::runtime_error(msg)
    {
    }
};
 
class Parser
{
public:
    std::vector<std::string> operator() (const std::string& text)
    {
        std::string::const_iterator begin = text.begin();
        std::string::const_iterator end = text.end();
        sql_grammar<std::string::const_iterator> grammar;
        std::vector<std::string> temp;
        bool r = false;
        r = phrase_parse(begin, end, grammar, ascii::space, temp);
        if (r && begin == end)
        {
           return temp;
        }
        else
        {
            std::cout << grammar.get_error() << std::endl;
            throw Parser_Error("Parser error");
        }
    }
};

@Gepar · 03.06.2012, 22:08 **[ТС]**

Написал создание таблиц и вставку данных в бд, а вот на SELECT застрял.
Это кошмар какой-то пытаться распарсить и обработать это:

SQL

1 2	SELECT * FROM TEST SELECT * FROM TEST,TEST2 WHERE X=A;

Это же блин 100500 возможных вариантов: Может быть *, может быть имя одного из полей и тогда нужно шарить по всем таблицам искать это имя, потом может быть разный оператор сравнения (=, !=, <,>,>=,<= ), потом ещё нужно учесть что поля нужно сравнивать по разному же, а если учесть что WHERE может быть, а может не быть. Несколько таблиц может быть надо соединять, а может и не надо, а если надо то нужно ещё как-то их соединить и исключить повторы ... тупой SELECT.

@ForEveR · 03.06.2012, 23:46

Gepar, Ну без join-а у меня в коде все реализовано, не столь уж и сложно. А вот с join-ом - да. Трудно.

Внутренняя организация базы данных

Решение

Решение

Решение

Jupiter Каратель 6609 / 4028 / 401 Регистрация: 26.03.2010 Сообщений: 9,273 Записей в блоге: 1
	20.05.2012, 02:57	4
	Сообщение было отмечено как решение Решение Сообщение от Gepar что должно сделать SELECT ? произвести отбор/выборку данных Сообщение от Gepar SELECT X FROM TEST выбрать поле Х из таблицы TEST (будут выбраны все записи) Сообщение от Gepar SELECT X, Y FROM TEST; выбрать поля Х, Y из таблицы TEST (будут выбраны все записи) Сообщение от Gepar SELECT * FROM TEST выбрать ВСЕ поля из из таблицы TEST (будут выбраны все записи) Сообщение от Gepar SELECT * FROM TEST,TEST2 WHERE X=A; выбрать ВСЕ поля из из таблицы TEST (будут выбраны все записи у которых значение поля X равно А) Добавлено через 1 минуту Не по теме: Сообщение от Gepar Распарсить команду не проблема но тем неменее многие СУБД не в состоянии указать точную ошибку при неправильном запросе;) Добавлено через 5 минут Сообщение от Gepar и потом делать что-то типа вот и реализуй - базовый тип от которого наследуються тип целого, строки и т.д. Добавлено через 1 минуту Сообщение от Gepar а контролировать что вместо int при добавлении данных не сунут double или string ... примитивно, но... http://www.cplusplus.com/refer... m/putback/ 0

@ForEveR В астрале 8049 / 4806 / 655 Регистрация: 24.06.2010 Сообщений: 10,562
	20.05.2012, 14:54	6
	Gepar, Там буст юзается только для any. Реализовать свой any проще простого. Достаточно посмотреть исходник бустовский) Да split, который тоже реализовать не проблема. В данном варианте нету сейва/лоада, которые сделаны через boost::serialization (вот это уже самому реализовать не столь просто). Про даты. В стандарте нету удобств для работы с датами, но етесно есть в бусте. 1

@ForEveR В астрале 8049 / 4806 / 655 Регистрация: 24.06.2010 Сообщений: 10,562
	03.06.2012, 23:46	9
	Gepar, Ну без join-а у меня в коде все реализовано, не столь уж и сложно. А вот с join-ом - да. Трудно. 0