OTS/OTSCPP/OTSClassifyEngine/InclutionEngine/STDDataDB.cpp

#include "stdafx.h"
#include "STDDataDB.h"
#include "STDDataTable.h"

namespace OTSClassifyEngine
{
	using namespace OTSSQLITE;
	CSTDDataDB::CSTDDataDB(CDBStoreBasePtr a_datastore)
	{
		m_tableInfo.reset(new CSTDDataTable());
		myDB = CreateNewSQLiteDB(a_datastore,m_tableInfo);
	}

	CSTDDataDB::~CSTDDataDB()
	{
	}

	CSTDItemPtr CSTDDataDB::GetSTDItemById(const long a_nIncAId)
	{
		CSTDItemPtr pSTDItem;

		if (!m_listSTDItem.empty())
		{
			for (auto pItem : m_listSTDItem)
			{
				if (pItem->GetSTDId() == (DWORD)a_nIncAId)
				{
					pSTDItem = pItem;
				}
			}
		}
		else
		{
			auto tableQuery = GetQueryById(a_nIncAId);
			ASSERT(tableQuery);
			if (!tableQuery)
			{
				return pSTDItem;
			}

			if (!ReadSTDItem(tableQuery))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("read x-ray failed."));
				return pSTDItem;
			}

			pSTDItem = CSTDItemPtr(new CSTDItem(*m_pSTDItem.get()));

		}

		return pSTDItem;
	}

	CSTDItemsList& CSTDDataDB::GetSTDItemList(const BOOL a_bForce/* = FALSE*/)
	{
		if (a_bForce)
		{
			m_listSTDItem.clear();
		}

		if (m_listSTDItem.size() == 0)
		{
			ReadSTDItemList();
		}

		return m_listSTDItem;
	}
	
	CDBTableBasePtr CSTDDataDB::GetTableInfo()
	{
		/*if (!m_tableInfo)
		{
			m_tableInfo.reset(new CSTDDataTable);
		}*/

		return m_tableInfo;
	}

	BOOL CSTDDataDB::Init(const BOOL a_bClean /*= FALSE*/)
	{
		return myDB->Init(a_bClean);
	}

	BOOL CSTDDataDB::CreateTable(const BOOL a_bForce /*= FALSE*/)
	{
		return myDB->CreateTable(a_bForce);
	}

	BOOL CSTDDataDB::DeleteTable()
	{
		return myDB->DeleteTable();
	}

	BOOL CSTDDataDB::RemoveAllRows()
	{
		return myDB->RemoveAllRows();
	}

	BOOL CSTDDataDB::IsDBExist()
	{
		return myDB->IsDBExist();
	}

	OTSSQLITE::CDBStoreBasePtr CSTDDataDB::GetDatastore()
	{
		return myDB->GetDatastore();
	}

	OTSSQLITE::CDBQueryBasePtr CSTDDataDB::GetTableQuery(LPCTSTR a_sOrderColumnName /*= nullptr*/)
	{
		return myDB->GetTableQuery(a_sOrderColumnName);
	}

	BOOL CSTDDataDB::ReadSTDItemList()
	{
		auto tableInfoPtr = GetTableInfo();
		ASSERT(tableInfoPtr);
		if (!tableInfoPtr)
		{
			return FALSE;
		}

		auto query = GetTableQuery();
		ASSERT(query);
		if (!query)
		{
			return FALSE;
		}

		m_listSTDItem = ReadSTDItemList(query);

		return TRUE;
	}

	CSTDItemsList CSTDDataDB::ReadSTDItemList(CDBQueryBasePtr a_query)
	{
		CSTDItemsList listSTDItem;

		int nRowId = 0;
		int nWrongItems = 0;
		while (!a_query->IsEOF())
		{
			if (!ReadSTDItem(a_query))	//current x-ray point		
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Read xray point failed"));
				nWrongItems++;
				break;
			}

			listSTDItem.push_back(m_pSTDItem);

			a_query->NextRow();
			nRowId++;
		}

		return listSTDItem;
	}

	BOOL CSTDDataDB::ReadSTDItem(CDBQueryBasePtr a_query)
	{
		int nCol;
		m_pSTDItem = CSTDItemPtr(new CSTDItem());

		CString sIncAName;
		nCol = (int)CSTDDataTable::ColumnID::S_NAME - (int)CSTDDataTable::ColumnID::MIN;
		sIncAName = a_query->GetColStringValue(nCol, _T(""));
		m_pSTDItem->SetName(sIncAName);

		int nIncAIdNow;
		nCol = (int)CSTDDataTable::ColumnID::N_INCA_ID - (int)CSTDDataTable::ColumnID::MIN;
		nIncAIdNow = a_query->GetColIntValue(nCol, -1);
		m_pSTDItem->SetSTDId(nIncAIdNow);

		CString sColor;
		nCol = (int)CSTDDataTable::ColumnID::S_COLOR - (int)CSTDDataTable::ColumnID::MIN;
		sColor = a_query->GetColStringValue(nCol, _T(""));
		m_pSTDItem->SetColor(sColor);

		double dHeightWidthRatio;
		nCol = (int)CSTDDataTable::ColumnID::F_HEIGHT_WIDTH_RATIO - (int)CSTDDataTable::ColumnID::MIN;
		dHeightWidthRatio = a_query->GetColFloatValue(nCol, -1);
		m_pSTDItem->SetWidth_HeightRadio(dHeightWidthRatio);

		int nGrayStart;
		nCol = (int)CSTDDataTable::ColumnID::N_GRAY_START - (int)CSTDDataTable::ColumnID::MIN;
		nGrayStart = a_query->GetColIntValue(nCol, -1);
		
		int nGrayEnd;
		nCol = (int)CSTDDataTable::ColumnID::N_GRAY_START - (int)CSTDDataTable::ColumnID::MIN;
		nGrayEnd = a_query->GetColIntValue(nCol, -1);

		CIntRangePtr pGrayRange = CIntRangePtr(new CIntRange());
		pGrayRange->SetStart(nGrayStart);
		pGrayRange->SetEnd(nGrayEnd);
		m_pSTDItem->SetGrayLevelRange(pGrayRange);

		int nElementRangeNum;
		nCol = (int)CSTDDataTable::ColumnID::N_ELEMENT_RANGE_NUM - (int)CSTDDataTable::ColumnID::MIN;
		nElementRangeNum = a_query->GetColIntValue(nCol, -1);
		m_pSTDItem->SetElementRange(nElementRangeNum);

		return TRUE;
	}
	CDBQueryBasePtr CSTDDataDB::GetQueryById(const long a_nIncAId)
	{
		CDBQueryBasePtr query;
		auto datastorePtr = GetDatastore();
		ASSERT(datastorePtr);
		if (!datastorePtr)
		{
			return query;
		}

		auto tableInfoPtr = GetTableInfo();
		ASSERT(tableInfoPtr);
		if (!tableInfoPtr)
		{
			return query;
		}

		CString sIncAIdColumnName = tableInfoPtr->GetColumnName((int)CSTDDataTable::ColumnID::N_INCA_ID - (int)CSTDDataTable::ColumnID::MIN);

		CString sSQLCommand;
		sSQLCommand.Format(_T("SELECT * FROM \'%s\' WHERE %s = %d AND %s = %d;"),
			(LPCTSTR)tableInfoPtr->GetTableName(),
			(LPCTSTR)sIncAIdColumnName,
			a_nIncAId);

		query = datastorePtr->QueryByCommand(sSQLCommand);
		ASSERT(query);
		if (!query || !query->IsValid())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Invalid quary command (%s)."), (LPCTSTR)sSQLCommand);
			ASSERT(FALSE);
			return (CDBQueryBasePtr());
		}

		// do the table related valid checking
		if (query->GetColCount() != GetTableInfo()->GetColumnCount())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("query col num value is %d, but not %d"), query->GetColCount(), GetTableInfo()->GetColumnCount());
			ASSERT(FALSE);
			return (CDBQueryBasePtr());
		}

		return query;
	}
}