Statement.h

[詳解]

 
 
#pragma once
 
#include <Windows.h>
#include "sqlite3.h"
#include "Core.h"
#include "Engine.h"
 
namespace alt
{
    namespace db
    {
        class Statement : public Core
        {
        public:
            Statement ()
                :Core ()
            {
                _statement = nullptr;
            }
 
            virtual ~Statement ()
            {
                if (_statement) Finalize ();
            }
 
            bool Prepare (Engine engine, LPCTSTR lpctszSQL)
            {
                _lastError = ::sqlite3_prepare16 (engine.GetEngine (), lpctszSQL, -1, &_statement, nullptr);
                return getResponse () && _statement != nullptr;
            }
 
            bool Bind (int position)
            {
                _lastError = ::sqlite3_bind_null (_statement, position);
                return getResponse ();
            }
 
            bool Bind (int position, int value)
            {
                _lastError = ::sqlite3_bind_int (_statement, position, value);
                return getResponse ();
            }
 
            bool Bind (int position, sqlite3_int64 value)
            {
                _lastError = ::sqlite3_bind_int64 (_statement, position, value);
                return getResponse ();
            }
 
            bool Bind (int position, double value)
            {
                _lastError = ::sqlite3_bind_double (_statement, position, value);
                return getResponse ();
            }
 
            bool Bind (int position, LPCSTR value)
            {
                _lastError = ::sqlite3_bind_text (_statement, position, value, (int)lstrlenA (value), nullptr);
                return getResponse ();
            }
 
            bool Bind (int position, LPCWSTR value)
            {
                _lastError = ::sqlite3_bind_text16 (_statement, position, value, (int)lstrlenW (value) * sizeof (wchar_t), nullptr);
                return getResponse ();
            }
 
 
            bool Execute ()
            {
                _lastError = ::sqlite3_step (_statement);
                return getResponse ();
            }
 
            bool ResetBind ()
            {
                _lastError = ::sqlite3_reset (_statement);
                bool ret = getResponse ();
                if (!ret) return ret;
 
                _lastError = ::sqlite3_clear_bindings (_statement);
                return getResponse ();
            }
 
            int GetColumns ()
            {
                return ::sqlite3_column_count (_statement);
            }
 
            LPCTSTR GetColumnName (int position)
            {
                return (LPCTSTR)::sqlite3_column_name16 (_statement, position);
            }
 
            LPCTSTR GetColumnType (int position)
            {
                return (LPCTSTR)::sqlite3_column_decltype16 (_statement, position);
            }
 
            int GetIntValue (int position)
            {
                return ::sqlite3_column_int (_statement, position);
            }
 
            sqlite3_int64 GetInt64Value (int position)
            {
                return ::sqlite3_column_int64 (_statement, position);
            }
 
            double GetDoubleValue (int position)
            {
                return ::sqlite3_column_double (_statement, position);
            }
 
            LPCSTR GetStringValue (int position)
            {
                return (LPCSTR)::sqlite3_column_text (_statement, position);
            }
 
            LPCTSTR GetString16Value (int position)
            {
                return (LPCTSTR)::sqlite3_column_text16 (_statement, position);
            }
 
            bool Finalize ()
            {
                _lastError = sqlite3_finalize (_statement);
                _statement = nullptr;
                return getResponse ();
            }
 
        protected:
            sqlite3_stmt* _statement;
        };
    }
}