Index: src/libchcore/TSQLiteSerializerRowData.cpp
===================================================================
diff -u -N -r39864b5fbb931e3b257afbd60cfb7f36f71d146d -re96806b7f8ff7ca7e9f4afbea603e6351a3dc3e3
--- src/libchcore/TSQLiteSerializerRowData.cpp	(.../TSQLiteSerializerRowData.cpp)	(revision 39864b5fbb931e3b257afbd60cfb7f36f71d146d)
+++ src/libchcore/TSQLiteSerializerRowData.cpp	(.../TSQLiteSerializerRowData.cpp)	(revision e96806b7f8ff7ca7e9f4afbea603e6351a3dc3e3)
@@ -25,511 +25,510 @@
 #include "SerializerTrace.h"
 #include "TPlainStringPool.h"
 
-BEGIN_CHCORE_NAMESPACE
-
-///////////////////////////////////////////////////////////////////////////
-TSQLiteSerializerRowData::TSQLiteSerializerRowData(object_id_t oidRowID, TSQLiteColumnsDefinition& rColumnDefinition, bool bAdded, unsigned long long* pPoolMemory, size_t stPoolMemorySizeInBytes, TPlainStringPool& poolStrings) :
-	m_rColumns(rColumnDefinition),
-	m_pPoolMemory(pPoolMemory),
-	m_poolStrings(poolStrings)
+namespace chcore
 {
-	if(!m_pPoolMemory)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Null memory provided"));
-	if(rColumnDefinition.GetCount() > 63)
-		THROW_SERIALIZER_EXCEPTION(eErr_InternalProblem, _T("Serializer supports up to 63 columns. If more is needed the block header needs to be increased."));
+	///////////////////////////////////////////////////////////////////////////
+	TSQLiteSerializerRowData::TSQLiteSerializerRowData(object_id_t oidRowID, TSQLiteColumnsDefinition& rColumnDefinition, bool bAdded, unsigned long long* pPoolMemory, size_t stPoolMemorySizeInBytes, TPlainStringPool& poolStrings) :
+		m_rColumns(rColumnDefinition),
+		m_pPoolMemory(pPoolMemory),
+		m_poolStrings(poolStrings)
+	{
+		if (!m_pPoolMemory)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Null memory provided"));
+		if (rColumnDefinition.GetCount() > 63)
+			THROW_SERIALIZER_EXCEPTION(eErr_InternalProblem, _T("Serializer supports up to 63 columns. If more is needed the block header needs to be increased."));
 
-	// initialize memory
-	memset((void*)pPoolMemory, 0, stPoolMemorySizeInBytes);
+		// initialize memory
+		memset((void*)pPoolMemory, 0, stPoolMemorySizeInBytes);
 
-	// set id
-	size_t stIDIndex = rColumnDefinition.GetColumnIndex(_T("id"));
-	SetValue(stIDIndex, oidRowID);
+		// set id
+		size_t stIDIndex = rColumnDefinition.GetColumnIndex(_T("id"));
+		SetValue(stIDIndex, oidRowID);
 
-	if(bAdded)
-		MarkAsAdded();
-}
+		if (bAdded)
+			MarkAsAdded();
+	}
 
-TSQLiteSerializerRowData::TSQLiteSerializerRowData(const TSQLiteSerializerRowData& rSrc) :
-	m_rColumns(rSrc.m_rColumns),
-	m_pPoolMemory(rSrc.m_pPoolMemory),
-	m_poolStrings(rSrc.m_poolStrings)
-{
-}
+	TSQLiteSerializerRowData::TSQLiteSerializerRowData(const TSQLiteSerializerRowData& rSrc) :
+		m_rColumns(rSrc.m_rColumns),
+		m_pPoolMemory(rSrc.m_pPoolMemory),
+		m_poolStrings(rSrc.m_poolStrings)
+	{
+	}
 
-TSQLiteSerializerRowData::~TSQLiteSerializerRowData()
-{
-}
+	TSQLiteSerializerRowData::~TSQLiteSerializerRowData()
+	{
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, bool bValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_bool)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, bool bValue)
+	{
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_bool)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	ModifyColumnData(stColIndex) = (bValue ? 1ULL : 0ULL);
-	return *this;
-}
+		ModifyColumnData(stColIndex) = (bValue ? 1ULL : 0ULL);
+		return *this;
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, short siValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_short)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, short siValue)
+	{
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_short)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	ModifyColumnData(stColIndex) = (unsigned long long)*(unsigned short*)&siValue;
-	return *this;
-}
+		ModifyColumnData(stColIndex) = (unsigned long long)*(unsigned short*)&siValue;
+		return *this;
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, unsigned short usiValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_ushort)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, unsigned short usiValue)
+	{
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_ushort)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	ModifyColumnData(stColIndex) = (unsigned long long)usiValue;
-	return *this;
-}
+		ModifyColumnData(stColIndex) = (unsigned long long)usiValue;
+		return *this;
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, int iValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_int)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, int iValue)
+	{
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_int)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	ModifyColumnData(stColIndex) = (unsigned long long)*(unsigned int*)&iValue;
-	return *this;
-}
+		ModifyColumnData(stColIndex) = (unsigned long long)*(unsigned int*)&iValue;
+		return *this;
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, unsigned int uiValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_uint)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, unsigned int uiValue)
+	{
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_uint)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	ModifyColumnData(stColIndex) = (unsigned long long)uiValue;
-	return *this;
-}
+		ModifyColumnData(stColIndex) = (unsigned long long)uiValue;
+		return *this;
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, long lValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_long)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, long lValue)
+	{
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_long)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	ModifyColumnData(stColIndex) = (unsigned long long)*(unsigned long*)&lValue;
-	return *this;
-}
+		ModifyColumnData(stColIndex) = (unsigned long long)*(unsigned long*)&lValue;
+		return *this;
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, unsigned long ulValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_ulong)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, unsigned long ulValue)
+	{
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_ulong)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	ModifyColumnData(stColIndex) = (unsigned long long)ulValue;
-	return *this;
-}
+		ModifyColumnData(stColIndex) = (unsigned long long)ulValue;
+		return *this;
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, long long llValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_longlong)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, long long llValue)
+	{
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_longlong)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	ModifyColumnData(stColIndex) = *(unsigned long long*)&llValue;
-	return *this;
-}
+		ModifyColumnData(stColIndex) = *(unsigned long long*)&llValue;
+		return *this;
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, unsigned long long ullValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_ulonglong)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, unsigned long long ullValue)
+	{
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_ulonglong)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	ModifyColumnData(stColIndex) = ullValue;
-	return *this;
-}
+		ModifyColumnData(stColIndex) = ullValue;
+		return *this;
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, double dValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_double)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, double dValue)
+	{
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_double)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	BOOST_STATIC_ASSERT(sizeof(double) == sizeof(unsigned long long));
-	ModifyColumnData(stColIndex) = *(unsigned long long*)&dValue;
-	return *this;
-}
+		BOOST_STATIC_ASSERT(sizeof(double) == sizeof(unsigned long long));
+		ModifyColumnData(stColIndex) = *(unsigned long long*)&dValue;
+		return *this;
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, const TString& strValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_string)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
-
-	if(strValue.IsEmpty())
-		ModifyColumnData(stColIndex) = (unsigned long long)0;
-	else
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, const TString& strValue)
 	{
-		wchar_t* pszBuffer = m_poolStrings.AllocForString(strValue.c_str());
-		ModifyColumnData(stColIndex) = (unsigned long long)(void*)pszBuffer;
-	}
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_string)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	return *this;
-}
+		if (strValue.IsEmpty())
+			ModifyColumnData(stColIndex) = (unsigned long long)0;
+		else
+		{
+			wchar_t* pszBuffer = m_poolStrings.AllocForString(strValue.c_str());
+			ModifyColumnData(stColIndex) = (unsigned long long)(void*)pszBuffer;
+		}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, const TSmartPath& pathValue)
-{
-	if(m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_path)
-		THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
+		return *this;
+	}
 
-	if(pathValue.IsEmpty())
-		ModifyColumnData(stColIndex) = (unsigned long long)0;
-	else
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(size_t stColIndex, const TSmartPath& pathValue)
 	{
-		wchar_t* pszBuffer = m_poolStrings.AllocForString(pathValue.ToString());
-		ModifyColumnData(stColIndex) = (unsigned long long)(void*)pszBuffer;
-	}
+		if (m_rColumns.GetColumnType(stColIndex) != IColumnsDefinition::eType_path)
+			THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid argument type provided"));
 
-	return *this;
-}
+		if (pathValue.IsEmpty())
+			ModifyColumnData(stColIndex) = (unsigned long long)0;
+		else
+		{
+			wchar_t* pszBuffer = m_poolStrings.AllocForString(pathValue.ToString());
+			ModifyColumnData(stColIndex) = (unsigned long long)(void*)pszBuffer;
+		}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, bool bValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), bValue);
-}
+		return *this;
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, short iValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), iValue);
-}
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, bool bValue)
+	{
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), bValue);
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, unsigned short uiValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), uiValue);
-}
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, short iValue)
+	{
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), iValue);
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, int iValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), iValue);
-}
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, unsigned short uiValue)
+	{
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), uiValue);
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, unsigned int uiValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), uiValue);
-}
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, int iValue)
+	{
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), iValue);
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, long lValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), lValue);
-}
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, unsigned int uiValue)
+	{
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), uiValue);
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, unsigned long ulValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), ulValue);
-}
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, long lValue)
+	{
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), lValue);
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, long long llValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), llValue);
-}
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, unsigned long ulValue)
+	{
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), ulValue);
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, unsigned long long llValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), llValue);
-}
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, long long llValue)
+	{
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), llValue);
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, double dValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), dValue);
-}
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, unsigned long long llValue)
+	{
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), llValue);
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, const TString& strValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), strValue);
-}
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, double dValue)
+	{
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), dValue);
+	}
 
-ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, const TSmartPath& pathValue)
-{
-	return SetValue(m_rColumns.GetColumnIndex(strColumnName), pathValue);
-}
-
-void TSQLiteSerializerRowData::BindParamsAndExec(sqlite::TSQLiteStatement& tStatement)
-{
-	using namespace sqlite;
-
-	if(IsAdded())
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, const TString& strValue)
 	{
-		// exec query
-		int iColumn = 1;
-		BindParams(tStatement, iColumn);
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), strValue);
+	}
 
-		tStatement.Step();
+	ISerializerRowData& TSQLiteSerializerRowData::SetValue(const wchar_t* strColumnName, const TSmartPath& pathValue)
+	{
+		return SetValue(m_rColumns.GetColumnIndex(strColumnName), pathValue);
 	}
-	else if(HasAnyData())
+
+	void TSQLiteSerializerRowData::BindParamsAndExec(sqlite::TSQLiteStatement& tStatement)
 	{
-		int iColumn = 1;
+		using namespace sqlite;
 
-		size_t stIDColumnIndex = m_rColumns.GetColumnIndex(_T("id"));
+		if (IsAdded())
+		{
+			// exec query
+			int iColumn = 1;
+			BindParams(tStatement, iColumn);
 
-		BindParams(tStatement, iColumn, stIDColumnIndex);
+			tStatement.Step();
+		}
+		else if (HasAnyData())
+		{
+			int iColumn = 1;
 
-		// bind id as the last argument
-		tStatement.BindValue(iColumn++, GetDataForColumn(stIDColumnIndex));
-		tStatement.Step();
+			size_t stIDColumnIndex = m_rColumns.GetColumnIndex(_T("id"));
 
-		int iChanges = tStatement.Changes();
-		_ASSERTE(iChanges == 1);
-		if(iChanges != 1)
-			THROW_SERIALIZER_EXCEPTION(eErr_InvalidData, _T("Update query did not update record in the database"));
+			BindParams(tStatement, iColumn, stIDColumnIndex);
+
+			// bind id as the last argument
+			tStatement.BindValue(iColumn++, GetDataForColumn(stIDColumnIndex));
+			tStatement.Step();
+
+			int iChanges = tStatement.Changes();
+			_ASSERTE(iChanges == 1);
+			if (iChanges != 1)
+				THROW_SERIALIZER_EXCEPTION(eErr_InvalidData, _T("Update query did not update record in the database"));
+		}
 	}
-}
 
-TString TSQLiteSerializerRowData::GetQuery(const TString& strContainerName) const
-{
-	if(IsAdded())
+	TString TSQLiteSerializerRowData::GetQuery(const TString& strContainerName) const
 	{
-		// prepare insert query
-		TString strQuery = boost::str(boost::wformat(L"INSERT INTO %1%(") % strContainerName).c_str();
-		TString strParams;
-
-		size_t stCount = m_rColumns.GetCount();
-		for(size_t stIndex = 0; stIndex < stCount; ++stIndex)
+		if (IsAdded())
 		{
-			strQuery += boost::str(boost::wformat(_T("%1%,")) % m_rColumns.GetColumnName(stIndex)).c_str();
-			strParams += _T("?,");
-		}
+			// prepare insert query
+			TString strQuery = boost::str(boost::wformat(L"INSERT INTO %1%(") % strContainerName).c_str();
+			TString strParams;
 
-		strQuery.TrimRightSelf(_T(","));
-		strQuery += _T(") VALUES(");
+			size_t stCount = m_rColumns.GetCount();
+			for (size_t stIndex = 0; stIndex < stCount; ++stIndex)
+			{
+				strQuery += boost::str(boost::wformat(_T("%1%,")) % m_rColumns.GetColumnName(stIndex)).c_str();
+				strParams += _T("?,");
+			}
 
-		strParams.TrimRightSelf(_T(","));
-		strQuery += strParams;
-		strQuery += _T(")");
+			strQuery.TrimRightSelf(_T(","));
+			strQuery += _T(") VALUES(");
 
-		return strQuery;
-	}
-	else if(HasAnyData())
-	{
-		// prepare update query
-		TString strQuery = boost::str(boost::wformat(L"UPDATE %1% SET ") % strContainerName).c_str();
+			strParams.TrimRightSelf(_T(","));
+			strQuery += strParams;
+			strQuery += _T(")");
 
-		size_t stCountOfAssignments = 0;
-		size_t stIDColumnIndex = m_rColumns.GetColumnIndex(_T("id"));
-		size_t stCount = m_rColumns.GetCount();
-		for(size_t stIndex = 0; stIndex < stCount; ++stIndex)
+			return strQuery;
+		}
+		else if (HasAnyData())
 		{
-			if(stIndex != stIDColumnIndex && HasData(stIndex))
+			// prepare update query
+			TString strQuery = boost::str(boost::wformat(L"UPDATE %1% SET ") % strContainerName).c_str();
+
+			size_t stCountOfAssignments = 0;
+			size_t stIDColumnIndex = m_rColumns.GetColumnIndex(_T("id"));
+			size_t stCount = m_rColumns.GetCount();
+			for (size_t stIndex = 0; stIndex < stCount; ++stIndex)
 			{
-				strQuery += boost::str(boost::wformat(_T("%1%=?,")) % m_rColumns.GetColumnName(stIndex)).c_str();
-				++stCountOfAssignments;
+				if (stIndex != stIDColumnIndex && HasData(stIndex))
+				{
+					strQuery += boost::str(boost::wformat(_T("%1%=?,")) % m_rColumns.GetColumnName(stIndex)).c_str();
+					++stCountOfAssignments;
+				}
 			}
-		}
 
-		if(stCountOfAssignments == 0)
-			return TString();
+			if (stCountOfAssignments == 0)
+				return TString();
 
-		strQuery.TrimRightSelf(_T(","));
-		strQuery += _T(" WHERE id=?");
+			strQuery.TrimRightSelf(_T(","));
+			strQuery += _T(" WHERE id=?");
 
-		return strQuery;
+			return strQuery;
+		}
+		else
+			return TString();
 	}
-	else
-		return TString();
-}
 
-unsigned long long TSQLiteSerializerRowData::GetChangeIdentification() const
-{
-	return GetDataHeader();
-}
+	unsigned long long TSQLiteSerializerRowData::GetChangeIdentification() const
+	{
+		return GetDataHeader();
+	}
 
-void TSQLiteSerializerRowData::MarkAsAdded()
-{
-	// first bit is always the "added" bit
-	m_pPoolMemory[0] |= AddedBit;
-}
+	void TSQLiteSerializerRowData::MarkAsAdded()
+	{
+		// first bit is always the "added" bit
+		m_pPoolMemory[0] |= AddedBit;
+	}
 
-const unsigned long long& TSQLiteSerializerRowData::GetDataForColumn(size_t stColIndex) const
-{
-	return (m_pPoolMemory[stColIndex + 1]);
-}
+	const unsigned long long& TSQLiteSerializerRowData::GetDataForColumn(size_t stColIndex) const
+	{
+		return (m_pPoolMemory[stColIndex + 1]);
+	}
 
-unsigned long long& TSQLiteSerializerRowData::ModifyColumnData(size_t stColIndex)
-{
-	FreeColumnData(stColIndex);
+	unsigned long long& TSQLiteSerializerRowData::ModifyColumnData(size_t stColIndex)
+	{
+		FreeColumnData(stColIndex);
 
-	MarkColumnUsage(stColIndex, true);
-	return (m_pPoolMemory[stColIndex + 1]);
-}
+		MarkColumnUsage(stColIndex, true);
+		return (m_pPoolMemory[stColIndex + 1]);
+	}
 
-void TSQLiteSerializerRowData::MarkColumnUsage(size_t stIndex, bool bUsed)
-{
-	if(stIndex >= m_rColumns.GetCount())
-		THROW_SERIALIZER_EXCEPTION(eErr_BoundsExceeded, _T("Wrong column provided"));
+	void TSQLiteSerializerRowData::MarkColumnUsage(size_t stIndex, bool bUsed)
+	{
+		if (stIndex >= m_rColumns.GetCount())
+			THROW_SERIALIZER_EXCEPTION(eErr_BoundsExceeded, _T("Wrong column provided"));
 
-	unsigned long long ullMask = 2ULL << stIndex;
-	if(bUsed)
-		m_pPoolMemory[0] |= ullMask;
-	else
-		m_pPoolMemory[0] &= ~ullMask;
-}
+		unsigned long long ullMask = 2ULL << stIndex;
+		if (bUsed)
+			m_pPoolMemory[0] |= ullMask;
+		else
+			m_pPoolMemory[0] &= ~ullMask;
+	}
 
-bool TSQLiteSerializerRowData::IsAdded() const
-{
-	return (m_pPoolMemory[0] & AddedBit) != 0;
-}
+	bool TSQLiteSerializerRowData::IsAdded() const
+	{
+		return (m_pPoolMemory[0] & AddedBit) != 0;
+	}
 
-bool TSQLiteSerializerRowData::HasAnyData() const
-{
-	return GetDataHeader() != 0;
-}
+	bool TSQLiteSerializerRowData::HasAnyData() const
+	{
+		return GetDataHeader() != 0;
+	}
 
-bool TSQLiteSerializerRowData::HasData(size_t stColumnIndex) const
-{
-	return (GetDataHeader() & (2ULL << stColumnIndex)) != 0;
-}
-
-void TSQLiteSerializerRowData::BindParams(sqlite::TSQLiteStatement &tStatement, int& iSQLiteColumnNumber, size_t stSkipColumn)
-{
-	size_t stCount = m_rColumns.GetCount();
-	for(size_t stColumn = 0; stColumn < stCount; ++stColumn)
+	bool TSQLiteSerializerRowData::HasData(size_t stColumnIndex) const
 	{
-		if(stColumn == stSkipColumn)
-			continue;
+		return (GetDataHeader() & (2ULL << stColumnIndex)) != 0;
+	}
 
-		if(HasData(stColumn))
+	void TSQLiteSerializerRowData::BindParams(sqlite::TSQLiteStatement &tStatement, int& iSQLiteColumnNumber, size_t stSkipColumn)
+	{
+		size_t stCount = m_rColumns.GetCount();
+		for (size_t stColumn = 0; stColumn < stCount; ++stColumn)
 		{
-			switch(m_rColumns.GetColumnType(stColumn))
-			{
-			case IColumnsDefinition::eType_bool:
-			{
-				bool bValue = GetDataForColumn(stColumn) != 0 ? true : false;
-				DBTRACE1_D(_T("- param(bool): %ld\n"), bValue ? 1l : 0l);
-				tStatement.BindValue(iSQLiteColumnNumber++, bValue);
-				break;
-			}
+			if (stColumn == stSkipColumn)
+				continue;
 
-			case IColumnsDefinition::eType_short:
+			if (HasData(stColumn))
 			{
-				short siValue = *(short*)(unsigned short*)&GetDataForColumn(stColumn);
-				DBTRACE1_D(_T("- param(short): %d\n"), siValue);
-				tStatement.BindValue(iSQLiteColumnNumber++, siValue);
-				break;
-			}
+				switch (m_rColumns.GetColumnType(stColumn))
+				{
+				case IColumnsDefinition::eType_bool:
+				{
+					bool bValue = GetDataForColumn(stColumn) != 0 ? true : false;
+					DBTRACE1_D(_T("- param(bool): %ld\n"), bValue ? 1l : 0l);
+					tStatement.BindValue(iSQLiteColumnNumber++, bValue);
+					break;
+				}
 
-			case IColumnsDefinition::eType_ushort:
-			{
-				unsigned short usiValue = (unsigned short)GetDataForColumn(stColumn);
-				DBTRACE1_D(_T("- param(ushort): %u\n"), usiValue);
-				tStatement.BindValue(iSQLiteColumnNumber++, usiValue);
-				break;
-			}
+				case IColumnsDefinition::eType_short:
+				{
+					short siValue = *(short*)(unsigned short*)&GetDataForColumn(stColumn);
+					DBTRACE1_D(_T("- param(short): %d\n"), siValue);
+					tStatement.BindValue(iSQLiteColumnNumber++, siValue);
+					break;
+				}
 
-			case IColumnsDefinition::eType_int:
-			{
-				int iValue = *(int*)(unsigned int*)&GetDataForColumn(stColumn);
-				DBTRACE1_D(_T("- param(int): %ld\n"), iValue);
-				tStatement.BindValue(iSQLiteColumnNumber++, iValue);
-				break;
-			}
+				case IColumnsDefinition::eType_ushort:
+				{
+					unsigned short usiValue = (unsigned short)GetDataForColumn(stColumn);
+					DBTRACE1_D(_T("- param(ushort): %u\n"), usiValue);
+					tStatement.BindValue(iSQLiteColumnNumber++, usiValue);
+					break;
+				}
 
-			case IColumnsDefinition::eType_uint:
-			{
-				unsigned int uiValue = (unsigned int)GetDataForColumn(stColumn);
-				DBTRACE1_D(_T("- param(uint): %lu\n"), uiValue);
-				tStatement.BindValue(iSQLiteColumnNumber++, uiValue);
-				break;
-			}
+				case IColumnsDefinition::eType_int:
+				{
+					int iValue = *(int*)(unsigned int*)&GetDataForColumn(stColumn);
+					DBTRACE1_D(_T("- param(int): %ld\n"), iValue);
+					tStatement.BindValue(iSQLiteColumnNumber++, iValue);
+					break;
+				}
 
-			case IColumnsDefinition::eType_long:
-			{
-				long lValue = *(long*)(unsigned long*)&GetDataForColumn(stColumn);
-				DBTRACE1_D(_T("- param(long): %ld\n"), lValue);
-				tStatement.BindValue(iSQLiteColumnNumber++, lValue);
-				break;
-			}
+				case IColumnsDefinition::eType_uint:
+				{
+					unsigned int uiValue = (unsigned int)GetDataForColumn(stColumn);
+					DBTRACE1_D(_T("- param(uint): %lu\n"), uiValue);
+					tStatement.BindValue(iSQLiteColumnNumber++, uiValue);
+					break;
+				}
 
-			case IColumnsDefinition::eType_ulong:
-			{
-				unsigned long ulValue = (unsigned long)GetDataForColumn(stColumn);
-				DBTRACE1_D(_T("- param(ulong): %lu\n"), ulValue);
-				tStatement.BindValue(iSQLiteColumnNumber++, ulValue);
-				break;
-			}
+				case IColumnsDefinition::eType_long:
+				{
+					long lValue = *(long*)(unsigned long*)&GetDataForColumn(stColumn);
+					DBTRACE1_D(_T("- param(long): %ld\n"), lValue);
+					tStatement.BindValue(iSQLiteColumnNumber++, lValue);
+					break;
+				}
 
-			case IColumnsDefinition::eType_longlong:
-			{
-				long long llValue = *(long long*)(unsigned long long*)&GetDataForColumn(stColumn);
-				DBTRACE1_D(_T("- param(llong): %I64d\n"), llValue);
-				tStatement.BindValue(iSQLiteColumnNumber++, llValue);
-				break;
-			}
+				case IColumnsDefinition::eType_ulong:
+				{
+					unsigned long ulValue = (unsigned long)GetDataForColumn(stColumn);
+					DBTRACE1_D(_T("- param(ulong): %lu\n"), ulValue);
+					tStatement.BindValue(iSQLiteColumnNumber++, ulValue);
+					break;
+				}
 
-			case IColumnsDefinition::eType_ulonglong:
-			{
-				unsigned long long ullValue = GetDataForColumn(stColumn);
-				DBTRACE1_D(_T("- param(ullong): %I64u\n"), ullValue);
-				tStatement.BindValue(iSQLiteColumnNumber++, ullValue);
-				break;
-			}
+				case IColumnsDefinition::eType_longlong:
+				{
+					long long llValue = *(long long*)(unsigned long long*)&GetDataForColumn(stColumn);
+					DBTRACE1_D(_T("- param(llong): %I64d\n"), llValue);
+					tStatement.BindValue(iSQLiteColumnNumber++, llValue);
+					break;
+				}
 
-			case IColumnsDefinition::eType_double:
-			{
-				double dValue = *(double*)(unsigned long long*)&GetDataForColumn(stColumn);
-				DBTRACE1_D(_T("- param(double): %f\n"), dValue);
-				tStatement.BindValue(iSQLiteColumnNumber++, dValue);
-				break;
-			}
+				case IColumnsDefinition::eType_ulonglong:
+				{
+					unsigned long long ullValue = GetDataForColumn(stColumn);
+					DBTRACE1_D(_T("- param(ullong): %I64u\n"), ullValue);
+					tStatement.BindValue(iSQLiteColumnNumber++, ullValue);
+					break;
+				}
 
-			case IColumnsDefinition::eType_string:
-			{
-				const wchar_t* pszValue = (const wchar_t*)(unsigned long long*)GetDataForColumn(stColumn);
-				DBTRACE1_D(_T("- param(string): %s\n"), pszValue ? pszValue : _T(""));
-				tStatement.BindValue(iSQLiteColumnNumber++, pszValue ? pszValue : _T(""));
-				break;
-			}
+				case IColumnsDefinition::eType_double:
+				{
+					double dValue = *(double*)(unsigned long long*)&GetDataForColumn(stColumn);
+					DBTRACE1_D(_T("- param(double): %f\n"), dValue);
+					tStatement.BindValue(iSQLiteColumnNumber++, dValue);
+					break;
+				}
 
-			case IColumnsDefinition::eType_path:
-			{
-				const wchar_t* pszValue = (const wchar_t*)(unsigned long long*)GetDataForColumn(stColumn);
-				DBTRACE1_D(_T("- param(path): %s\n"), pszValue ? pszValue : _T(""));
-				tStatement.BindValue(iSQLiteColumnNumber++, pszValue ? PathFromString(pszValue) : TSmartPath());
-				break;
-			}
+				case IColumnsDefinition::eType_string:
+				{
+					const wchar_t* pszValue = (const wchar_t*)(unsigned long long*)GetDataForColumn(stColumn);
+					DBTRACE1_D(_T("- param(string): %s\n"), pszValue ? pszValue : _T(""));
+					tStatement.BindValue(iSQLiteColumnNumber++, pszValue ? pszValue : _T(""));
+					break;
+				}
 
-			default:
-				THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid type"));
+				case IColumnsDefinition::eType_path:
+				{
+					const wchar_t* pszValue = (const wchar_t*)(unsigned long long*)GetDataForColumn(stColumn);
+					DBTRACE1_D(_T("- param(path): %s\n"), pszValue ? pszValue : _T(""));
+					tStatement.BindValue(iSQLiteColumnNumber++, pszValue ? PathFromString(pszValue) : TSmartPath());
+					break;
+				}
+
+				default:
+					THROW_SERIALIZER_EXCEPTION(eErr_InvalidArgument, _T("Invalid type"));
+				}
 			}
 		}
 	}
-}
 
-unsigned long long TSQLiteSerializerRowData::GetDataHeader() const
-{
-	return m_pPoolMemory[0];
-}
+	unsigned long long TSQLiteSerializerRowData::GetDataHeader() const
+	{
+		return m_pPoolMemory[0];
+	}
 
-void TSQLiteSerializerRowData::FreeColumnData(size_t stColumnID)
-{
-	if(!HasData(stColumnID))
-		return;
-
-	switch(m_rColumns.GetColumnType(stColumnID))
+	void TSQLiteSerializerRowData::FreeColumnData(size_t stColumnID)
 	{
-	case IColumnsDefinition::eType_path:
-	case IColumnsDefinition::eType_string:
+		if (!HasData(stColumnID))
+			return;
+
+		switch (m_rColumns.GetColumnType(stColumnID))
 		{
+		case IColumnsDefinition::eType_path:
+		case IColumnsDefinition::eType_string:
+		{
 			unsigned long long& ullColumnData = m_pPoolMemory[stColumnID + 1];
 			ullColumnData = 0ULL;
-			
+
 			break;
 		}
+		}
 	}
-}
 
-void TSQLiteSerializerRowData::FreeAllColumnData()
-{
-	size_t stCount = m_rColumns.GetCount();
-	for(size_t stColumn = 0; stColumn < stCount; ++stColumn)
+	void TSQLiteSerializerRowData::FreeAllColumnData()
 	{
-		FreeColumnData(stColumn);
+		size_t stCount = m_rColumns.GetCount();
+		for (size_t stColumn = 0; stColumn < stCount; ++stColumn)
+		{
+			FreeColumnData(stColumn);
+		}
 	}
-}
 
-TSQLiteSerializerRowData& TSQLiteSerializerRowData::operator=(const TSQLiteSerializerRowData& rSrc)
-{
-	m_pPoolMemory = rSrc.m_pPoolMemory;
+	TSQLiteSerializerRowData& TSQLiteSerializerRowData::operator=(const TSQLiteSerializerRowData& rSrc)
+	{
+		m_pPoolMemory = rSrc.m_pPoolMemory;
 
-	return *this;
+		return *this;
+	}
 }
-
-END_CHCORE_NAMESPACE