/sqlite3cc

/*

 * basic_statement.cc

 *

 * Copyright (C) 2009 Tim Marston <edam@waxworlds.org>

 *

 * This file is part of sqlite3cc (hereafter referred to as "this program").

 * See http://www.waxworlds.org/edam/software/sqlite3cc for more information.

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as published

 * by the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <sqlite3cc/basic_statement.h>

#include <sqlite3cc/exception.h>

#include <sqlite3cc/database.h>

#include <sqlite3cc/manipulator.h>

#include <string.h>

#include <iomanip>

sqlite::basic_statement::basic_statement(

	database &database,

	const std::string &sql )

	:

	_database( database ),

	_handle( NULL ),

	_bind_index( 1 )

{

	int error_code = prepare( sql );

	if( error_code != SQLITE_OK ) throw sqlite_error( error_code );

}

sqlite::basic_statement::basic_statement(

	database &database )

	:

	_database( database ),

	_handle( NULL ),

	_bind_index( 1 )

{

}

sqlite::basic_statement::~basic_statement()

{

	finalize();

}

int sqlite::basic_statement::prepare(

	const std::string &sql )

{

	finalize();

	return sqlite3_prepare_v2( _database._handle, sql.c_str(),

		sql.length() + 1, &_handle, NULL );

}

int sqlite::basic_statement::reset()

{

	return sqlite3_reset( _handle );

}

int sqlite::basic_statement::clear_bindings()

{

	_bind_index = 1;

	return sqlite3_clear_bindings( _handle );

}

int sqlite::basic_statement::bind_static(

	unsigned int index,

	const char *value,

	unsigned int value_length )

{

	return sqlite3_bind_text( _handle, index, value, value_length,

		SQLITE_STATIC );

}

int sqlite::basic_statement::bind_static(

	unsigned int index,

	const char *value )

{

	return bind_static( index, value, strlen( value ) );

}

int sqlite::basic_statement::bind_static(

	unsigned int index,

	const std::string &value )

{

	return bind_static( index, value.c_str(), value.length() );

}

int sqlite::basic_statement::bind_null(

	unsigned int index )

{

	return sqlite3_bind_null( _handle, index );

}

int sqlite::basic_statement::bind_static(

	const std::string &name,

	const char *value,

	unsigned int value_length )

{

	return bind_static( bind_parameter_index( name ), value, value_length );

}

int sqlite::basic_statement::bind_static(

	const std::string &name,

	const char *value )

{

	return bind_static( name, value, ::strlen( value ) );

}

int sqlite::basic_statement::bind_static(

	const std::string &name,

	const std::string &value )

{

	return bind_static( name, value.c_str(), value.length() );

}

int sqlite::basic_statement::bind_null(

	const std::string &name )

{

	return bind_null( bind_parameter_index( name ) );

}

int sqlite::basic_statement::finalize()

{

	int error_code = SQLITE_OK;

	if( _handle ) {

		error_code = sqlite3_finalize( _handle );

		_handle = NULL;

	}

	return error_code;

}

int sqlite::basic_statement::step()

{

	return sqlite3_step( _handle );

}

int sqlite::basic_statement::bind_parameter_index(

	const std::string &name )

{

	unsigned int index = sqlite3_bind_parameter_index( _handle, name.c_str() );

	if( !index ) throw std::range_error( "named parameter not found" );

	return index;

}

template< >

sqlite::basic_statement &sqlite::basic_statement::operator <<

	< sqlite::_null_t >(

	const sqlite::_null_t & )

{

	int error_code = bind_null( _bind_index );

	if( error_code != SQLITE_OK ) throw sqlite_error( error_code );

	_bind_index++;

	return *this;

}

template< >

sqlite::basic_statement &sqlite::basic_statement::operator <<

	< sqlite::_exec_t >(

	const sqlite::_exec_t & )

{

	int error_code = step();

	if( error_code != SQLITE_DONE ) {

		if( error_code == SQLITE_ROW )

			throw sqlite_error( "statement returned results" );

		else

			throw sqlite_error( error_code );

	}

	return *this;

}

template< >

sqlite::basic_statement &sqlite::basic_statement::operator <<

	< sqlite::_set_index_t >(

	const sqlite::_set_index_t &t )

{

	_bind_index = t._index;

	return *this;

}