上一篇文章實現的數據庫很不方便
一方面基于不同的數據，需要不同的函數用于存取
另一方面數據存儲基于數組，大小一開始的固定的，顯然不行
這一章來嘗試改一改

我們希望這個數據庫是動態大小的，能存多少都行
那么一提到這個，第一個想到的應該就是鏈表了
先來整體看看改動后的smallsql.h

可以看到數據采用鏈表來存儲，接口也改為固定的一對get/set了，其余不變
依然來先看看open函數吧

bool smallsql::open(const std::string& sqlPath)  
{  
    FILE* fp = nullptr;  
    m_sqlPath = sqlPath;  
  
    fopen_s(&fp, sqlPath.c_str(), "r");  
    if (fp == nullptr)  
    {  
        return true;  
    }  
  
    SqlDataList* pHead = m_pDatas;  
    SqlDataList* pPre = nullptr;  
  
    while (!feof(fp))  
    {  
        int type = 0;  
        fread_s(&type, 1, 1, 1, fp);  
  
        int key_len = 0;  
        fread_s(&key_len, 1, 1, 1, fp);  
  
        if (key_len == 0)  
        {  
            continue;  
        }  
  
        m_pDatas = new SqlDataList;  
        m_pDatas->pNext = nullptr;  
        m_pDatas->type = type;  
  
        if (pPre != nullptr)  
        {  
            pPre->pNext = m_pDatas;  
        }  
  
        char* key = new char[key_len + 1];  
        fread_s(key, key_len, key_len, 1, fp);  
        key[key_len] = 0;  
        m_pDatas->key = std::string(key);  
  
        if (type == 0)  
        {  
            SqlData<int>* pItem = new SqlData<int>();  
            fread_s(&pItem->value, 4, 4, 1, fp);  
            m_pDatas->pValue = pItem;  
        }  
        else  
        {  
            SqlData<std::string>* pItem = new SqlData<std::string>();  
            int value_len = 0;  
            fread_s(&value_len, 1, 1, 1, fp);  
            char* value_str = new char[value_len + 1];  
            fread_s(value_str, value_len, value_len, 1, fp);  
            value_str[value_len] = 0;  
            pItem->value = std::string(value_str);  
            delete[] value_str;  
            m_pDatas->pValue = pItem;  
        }  
  
        delete[] key;  
  
        if (pHead == nullptr)  
        {  
            pHead = m_pDatas;  
        }  
  
        pPre = m_pDatas;  
    }  
  
    m_pDatas = pHead;  
  
    fclose(fp);  
  
    return true;  
}  

和上一章想比，就是改變了數據的讀取而已
這是改寫后的get函數

template<typename T>  
T smallsql::get(const std::string& key)  
{  
    SqlDataList* pData = m_pDatas;  
  
    while (pData != nullptr)  
    {  
        if (pData->key == key)  
        {  
            int type = typeid(T) == typeid(int) ? 0 : 1;  
  
            if (type == pData->type)  
            {  
                SqlData<T>* pItem = static_cast<SqlData<T>*>(pData->pValue);  
                return pItem->value;  
            }  
            else  
            {  
                return T();  
            }  
        }  
  
        pData = pData->pNext;  
    }  
  
    return T();  
}  
template<typename T>  
void smallsql::set(const std::string& key, const T& value)  
{  
    SqlDataList* pHead = m_pDatas;  
    SqlDataList* pPre = nullptr;  
  
    while (m_pDatas != nullptr)  
    {  
        if (m_pDatas->key == key)  
        {  
            delete m_pDatas->pValue;  
            SqlData<T>* pItem = new SqlData<T>();  
            pItem->value = value;  
            m_pDatas->pValue = pItem;  
  
            if (pHead != nullptr)  
            {  
                m_pDatas = pHead;  
            }  
  
            return;  
        }  
        else  
        {  
            pPre = m_pDatas;  
            m_pDatas = m_pDatas->pNext;  
        }  
    }  
  
    SqlData<T>* pItem = new SqlData<T>();  
    pItem->value = value;  
  
    m_pDatas = new SqlDataList;  
    m_pDatas->key = key;  
    m_pDatas->pValue = pItem;  
  
    if (typeid(T) == typeid(int))  
    {  
        m_pDatas->type = 0;  
    }  
    else  
    {  
        m_pDatas->type = 1;  
    }  
  
    m_pDatas->pNext = nullptr;  
  
    if (pPre != nullptr)  
    {  
        pPre->pNext = m_pDatas;  
    }  
  
    if (pHead != nullptr)  
    {  
        m_pDatas = pHead;  
    }  
}  

新的get和set用模板來當做數據項保存內容，實現一個接口存儲，比上一章要好了不少了另外這里的typeid其余可以考慮用模板特化來消除掉

總體來說，這一版改動了數據的存儲格式和查詢修改的接口
這是1W個數據的時間，相比上一章沒什么大的變化因為并沒有優化過，10W個數據的時間任然慘不忍睹 哈哈

看來當務之急的解決效率問題了，10W個數據的操作80多秒是不能忍受的
下一章就嘗試解決這個問題