drvinfo.cpp

快速SQL交互工具

			pTypeData->pNext = 0;
			InsertTypeData(pTypeData);
			m_lbDataTypes.AddString(m_pGetTypeInfo->m_strTypeName);
			m_pGetTypeInfo->MoveNext();
		}
		m_pGetTypeInfo->Close();
		delete m_pGetTypeInfo;
		m_pGetTypeInfo = 0;

		if (m_lbDataTypes.GetCount())
		{
			m_lbDataTypes.SetCurSel(0);
			OnSelchangeDataTypeList();
		}
	}
}

void CDataTypes::InsertTypeData(TYPEDATA* pTypeData)
{
	TYPEDATA*   p1 = m_pTypeDataTail;
	if (!p1)
		m_pTypeDataHead = m_pTypeDataTail = pTypeData;
	else
	{
		p1->pNext = pTypeData;
		m_pTypeDataTail = pTypeData;
	}
}

BOOL CDataTypes::OnInitDialog()
{
	CWaitCursor wait;

	CPropertyPage::OnInitDialog();

	OnNewDSN();

	return TRUE;  // return TRUE unless you set the focus to a control
				  // EXCEPTION: OCX Property Pages should return FALSE
}

void CDataTypes::OnSelchangeDataTypeList()
{
	if (m_pTypeDataHead)
	{
		CString string;
		m_lbDataTypes.GetText(m_lbDataTypes.GetCurSel(),string);

		TYPEDATA* pTypeData = m_pTypeDataHead;
		while (pTypeData)
		{
			if (pTypeData->strTypeName == string)
				break;
			pTypeData = pTypeData->pNext;
		}
		if (pTypeData)
		{
			// note: table lookup would be bettter here
			switch (pTypeData->nSqlType)
			{
			case SQL_BIGINT:
				m_strSqlType = _T("SQL_BIGINT");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_BIGINT));
				break;
			case SQL_BINARY:
				m_strSqlType = _T("SQL_BINARY");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_BINARY));
				break;
			case SQL_BIT:
				m_strSqlType = _T("SQL_BIT");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_BIT));
				break;
			case SQL_CHAR:
				m_strSqlType = _T("SQL_CHAR");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_CHAR));
				break;
			case SQL_DATE:
				m_strSqlType = _T("SQL_DATE");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_DATE));
				break;
			case SQL_DECIMAL:
				m_strSqlType = _T("SQL_DECIMAL");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_DECIMAL));
				break;
			case SQL_DOUBLE:
				m_strSqlType = _T("SQL_DOUBLE");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_DOUBLE));
				break;
			case SQL_FLOAT:
				m_strSqlType = _T("SQL_FLOAT");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_FLOAT));
				break;
			case SQL_INTEGER:
				m_strSqlType = _T("SQL_INTEGER");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_INTEGER));
				break;
			case SQL_LONGVARBINARY:
				m_strSqlType = _T("SQL_LONGVARBINARY");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_LONGVARBINARY));
				break;
			case SQL_LONGVARCHAR:
				m_strSqlType = _T("SQL_LONGVARCHAR");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_LONGVARCHAR));
				break;
			case SQL_NUMERIC:
				m_strSqlType = _T("SQL_NUMERIC");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_NUMERIC));
				break;
			case SQL_REAL:
				m_strSqlType = _T("SQL_REAL");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_REAL));
				break;
			case SQL_SMALLINT:
				m_strSqlType = _T("SQL_SMALLINT");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_SMALLINT));
				break;
			case SQL_TIME:
				m_strSqlType = _T("SQL_TIME");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_TIME));
				break;
			case SQL_TIMESTAMP:
				m_strSqlType = _T("SQL_TIMESTAMP");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_TIMESTAMP));
				break;
			case SQL_TINYINT:
				m_strSqlType = _T("SQL_TINYINT");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_TINYINT));
				break;
			case SQL_VARBINARY:
				m_strSqlType = _T("SQL_VARBINARY");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_VARBINARY));
				break;
			case SQL_VARCHAR:
				m_strSqlType = _T("SQL_VARCHAR");
				ShowConversions(SQLGetInfoLong(SQL_CONVERT_VARCHAR));
				break;
			default:
				m_strSqlType = _T("<new or driver-specific>");
				ShowConversions(0);
				break;
			}
			if (pTypeData->nPrecision == -1)
				m_strPrecision = _T("<n/a>");
			else
				m_strPrecision.Format(_T("%d"),pTypeData->nPrecision);
			if (pTypeData->strLiteralPrefix == _T(""))
				m_strPrefixSuffix = _T("<n/a>");
			else
				m_strPrefixSuffix = pTypeData->strLiteralPrefix;
			m_strPrefixSuffix += _T(",");
			if (pTypeData->strLiteralSuffix == _T(""))
				m_strPrefixSuffix += _T("<n/a>");
			else
				m_strPrefixSuffix += pTypeData->strLiteralSuffix;
			if (pTypeData->strCreateParams == _T(""))
				m_strCreateParams = _T("<none>");
			else
				m_strCreateParams = pTypeData->strCreateParams;
			switch (pTypeData->nNullable)
			{
			case SQL_NO_NULLS:
				m_strNullable = _T("No");
				break;
			case SQL_NULLABLE:
				m_strNullable = _T("Yes");
				break;
			case SQL_NULLABLE_UNKNOWN:
				m_strNullable = _T("Unknown");
				break;
			}
			if (pTypeData->bCaseSensitive)
				m_strCaseSensitive = _T("Yes");
			else
				m_strCaseSensitive = _T("No");

			switch (pTypeData->nSearchable)
			{
			case SQL_UNSEARCHABLE:
				m_strSearchable = _T("No");
				break;
			case SQL_LIKE_ONLY:
				m_strSearchable = _T("Only with LIKE");
				break;
			case SQL_ALL_EXCEPT_LIKE:
				m_strSearchable = _T("with all except LIKE");
				break;
			case SQL_SEARCHABLE:
				m_strSearchable = _T("Yes");
				break;
			}

			switch (pTypeData->nUnsigned)
			{
			case -1:
				m_strUnsigned = _T("<n/a>");
				break;
			case 0:
				m_strUnsigned = _T("No");
				break;
			case 1:
				m_strUnsigned = _T("Yes");
				break;
			}

			if (pTypeData->bMoney)
				m_strMoney = _T("Yes");
			else
				m_strMoney = _T("No");

			switch (pTypeData->nAutoIncrement)
			{
			case -1:
				m_strAutoIncrement = _T("<n/a>");
				break;
			case 0:
				m_strAutoIncrement = _T("No");
				break;
			case 1:
				m_strAutoIncrement = _T("Yes");
				break;
			}

			if (pTypeData->nMinimumScale == -1)
				m_strMinimumScale = _T("<n/a>");
			else
				m_strMinimumScale.Format(_T("%d"),pTypeData->nMinimumScale);

			if (pTypeData->nMaximumScale == -1)
				m_strMaximumScale = _T("<n/a>");
			else
				m_strMaximumScale.Format(_T("%d"),pTypeData->nMaximumScale);

		}
		else
			m_strSqlType = _T("<n/a>?");
	}
	else
		m_strSqlType = _T("<n/a>");

	UpdateData(FALSE);
}

void CDataTypes::ShowConversions(SDWORD dwDataType)
{
	m_lbConversions.ResetContent();
	if (!dwDataType)
		m_lbConversions.AddString(_T("<none>"));
	else
	{
		if (dwDataType & SQL_CVT_BIGINT)
			m_lbConversions.AddString(_T("SQL_BIGINT"));
		if (dwDataType & SQL_CVT_BINARY)
			m_lbConversions.AddString(_T("SQL_BINARY"));
		if (dwDataType & SQL_CVT_BIT)
			m_lbConversions.AddString(_T("SQL_BIT"));
		if (dwDataType & SQL_CVT_CHAR)
			m_lbConversions.AddString(_T("SQL_CHAR"));
		if (dwDataType & SQL_CVT_DATE)
			m_lbConversions.AddString(_T("SQL_DATE"));
		if (dwDataType & SQL_CVT_DECIMAL)
			m_lbConversions.AddString(_T("SQL_DECIMAL"));
		if (dwDataType & SQL_CVT_DOUBLE)
			m_lbConversions.AddString(_T("SQL_DOUBLE"));
		if (dwDataType & SQL_CVT_FLOAT)
			m_lbConversions.AddString(_T("SQL_FLOAT"));
		if (dwDataType & SQL_CVT_INTEGER)
			m_lbConversions.AddString(_T("SQL_INTEGER"));
		if (dwDataType & SQL_CVT_LONGVARBINARY)
			m_lbConversions.AddString(_T("SQL_LONGVARBINARY"));
		if (dwDataType & SQL_CVT_LONGVARCHAR)
			m_lbConversions.AddString(_T("SQL_LONGVARCHAR"));
		if (dwDataType & SQL_CVT_NUMERIC)
			m_lbConversions.AddString(_T("SQL_NUMERIC"));
		if (dwDataType & SQL_CVT_REAL)
			m_lbConversions.AddString(_T("SQL_REAL"));
		if (dwDataType & SQL_CVT_SMALLINT)
			m_lbConversions.AddString(_T("SQL_SMALLINT"));
		if (dwDataType & SQL_CVT_TIME)
			m_lbConversions.AddString(_T("SQL_TIME"));
		if (dwDataType & SQL_CVT_TIMESTAMP)
			m_lbConversions.AddString(_T("SQL_TIMESTAMP"));
		if (dwDataType & SQL_CVT_TINYINT)
			m_lbConversions.AddString(_T("SQL_TINYINT"));
		if (dwDataType & SQL_CVT_VARBINARY)
			m_lbConversions.AddString(_T("SQL_VARBINARY"));
		if (dwDataType & SQL_CVT_VARCHAR)
			m_lbConversions.AddString(_T("SQL_VARCHAR"));
	}
}

/////////////////////////////////////////////////////////////////////////////
// CIdentifiers property page

IMPLEMENT_DYNCREATE(CIdentifiers, CPropertyPage)

CIdentifiers::CIdentifiers(CDatabase* pDatabase)
 : CMyPage(pDatabase,CIdentifiers::IDD)
{
	//{{AFX_DATA_INIT(CIdentifiers)
	m_strSqlIdentifierCase = _T("");
	m_strSqlIdentifierQuoteChar = _T("");
	m_strSqlOwnerTerm = _T("");
	m_strSqlProcedureTerm = _T("");
	m_strSqlQualifierLocation = _T("");
	m_strSqlQualifierNameSeparator = _T("");
	m_strSqlQualifierTerm = _T("");
	m_strSqlQuotedIdentifierCase = _T("");
	m_strSqlSearchPatternEscape = _T("");
	m_strSqlTableTerm = _T("");
	m_strSqlSpecialCharacters = _T("");
	//}}AFX_DATA_INIT

	OnNewDSN();
}

CIdentifiers::~CIdentifiers()
{
}

void CIdentifiers::DumpToFile(CStdioFile& file)
{
	if (m_pDatabase->IsOpen())
	{
		CString bufferString;
		CString string;
		CString workString;

		file.WriteString(_T("Identifiers\n-----------\n\n"));
		file.WriteString(_T("Driver-Specific Keywords:\n-------------------------\n"));

		char    buffer[32000];
		SWORD   cbData;
		::SQLGetInfo(m_pDatabase->m_hdbc,SQL_KEYWORDS,
			(PTR)buffer,32000,&cbData);
		bufferString = buffer;
		int     n;
		string = "";
		BOOL    b = FALSE;
		while ((n = bufferString.Find(',')) != -1)
		{
			workString = bufferString.Left(n);
			bufferString = bufferString.Right(bufferString.GetLength() - n - 1);
			if (string.GetLength() + workString.GetLength() > 75)
			{
				string += _T("\n");
				file.WriteString(string);
				string = workString;
			}
			else
			{
				if (b)
					string += _T(",");
				string += workString;
			}
			b = TRUE;
		}
		string += _T("\n\n");
		file.WriteString(string);

		string.Format(_T("          Identifier Case - %s\n"),m_strSqlIdentifierCase);
		file.WriteString(string);
		string.Format(_T("   Quoted Identifier Case - %s\n"),m_strSqlQuotedIdentifierCase);
		file.WriteString(string);
		string.Format(_T("    Search Pattern Escape - %s\n"),m_strSqlSearchPatternEscape);
		file.WriteString(string);
		string.Format(_T("    Identifier Quote Char - %s\n"),m_strSqlIdentifierQuoteChar);
		file.WriteString(string);
		string.Format(_T("       Qualifier Location - %s\n"),m_strSqlQualifierLocation);
		file.WriteString(string);
		string.Format(_T("      Qualifier Separator - %s\n"),m_strSqlQualifierNameSeparator);
		file.WriteString(string);
		string.Format(_T("               Owner Term - %s\n"),m_strSqlOwnerTerm);
		file.WriteString(string);
		string.Format(_T("           Procedure Term - %s\n"),m_strSqlProcedureTerm);
		file.WriteString(string);
		string.Format(_T("           Qualifier Term - %s\n"),m_strSqlQualifierTerm);
		file.WriteString(string);
		string.Format(_T("                TableTerm - %s\n\n"),m_strSqlTableTerm);
		file.WriteString(string);

		file.WriteString(_T("Special Characters:\n-------------------\n"));
		if (m_strSqlSpecialCharacters.GetLength() == 0)
			file.WriteString(_T("<none>\n\n"));
		else
		{
			string = m_strSqlSpecialCharacters;
			while (string.GetLength() > 75)
			{
				workString = string.Left(75);
				string = string.Right(string.GetLength() - n - 1);
				workString += _T("\n");
				file.WriteString(workString);
			}
			string += _T("\n");
			file.WriteString(string);
		}
		file.WriteString(_T("\n"));
	}
}

void CIdentifiers::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CIdentifiers)
	DDX_Control(pDX, IDC_DRIVER_KEYWORDS, m_lbDriverKeywords);
	DDX_Control(pDX, IDC_ODBC_KEYWORDS, m_lbOdbcKeywords);
	DDX_Text(pDX, IDC_SQL_IDENTIFIER_CASE, m_strSqlIdentifierCase);
	DDX_Text(pDX, IDC_SQL_IDENTIFIER_QUOTE_CHAR, m_strSqlIdentifierQuoteChar);
	DDX_Text(pDX, IDC_SQL_OWNER_TERM, m_strSqlOwnerTerm);
	DDX_Text(pDX, IDC_SQL_PROCEDURE_TERM, m_strSqlProcedureTerm);
	DDX_Text(pDX, IDC_SQL_QUALIFIER_LOCATION, m_strSqlQualifierLocation);
	DDX_Text(pDX, IDC_SQL_QUALIFIER_NAME_SEPARATOR, m_strSqlQualifierNameSeparator);
	DDX_Text(pDX, IDC_SQL_QUALIFIER_TERM, m_strSqlQualifierTerm);
	DDX_Text(pDX, IDC_SQL_QUOTED_IDENTIFIER_CASE, m_strSqlQuotedIdentifierCase);
	DDX_Text(pDX, IDC_SQL_SEARCH_PATTERN_ESCAPE, m_strSqlSearchPatternEscape);
	DDX_Text(pDX, IDC_SQL_TABLE_TERM, m_strSqlTableTerm);
	DDX_Text(pDX, IDC_SQL_SPECIAL_CHARACTERS, m_strSqlSpecialCharacters);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CIdentifiers, CPropertyPage)
	//{{AFX_MSG_MAP(CIdentifiers)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CIdentifiers message handlers

void CIdentifiers::OnNewDSN()
{
	if (m_pDatabase->IsOpen())
	{
		switch(SQLGetInfoShort(SQL_IDENTIFIER_CASE))
		{
		case SQL_IC_UPPER:
			m_strSqlIdentifierCase = _T("Upper");
			break;
		case SQL_IC_LOWER:
			m_strSqlIdentifierCase = _T("Lower");
			break;
		case SQL_IC_SENSITIVE:
			m_strSqlIdentifierCase = _T("Sensitive");
			break;
		case SQL_IC_MIXED:
			m_strSqlIdentifierCase = _T("Mixed");
			break;
		}
		m_strSqlIdentifierQuoteChar = SQLGetInfoString(SQL_IDENTIFIER_QUOTE_CHAR);
		m_strSqlOwnerTerm = SQLGetInfoString(SQL_OWNER_TERM);
		m_strSqlProcedureTerm = SQLGetInfoString(SQL_PROCEDURE_TERM);
		switch (SQLGetInfoShort(SQL_QUALIFIER_LOCATION))
		{
		case SQL_QL_START:
			m_strSqlQualifierLocation = _T("Start");
			break;
		case SQL_QL_END:
			m_strSqlQualifierLocation = _T("End");
			break;
		}
		m_strSqlQualifierNameSeparator = SQLGetInfoString(SQL_QUALIFIER_NAME_SEPARATOR);
		m_strSqlQualifierTerm = SQLGetInfoString(SQL_QUALIFIER_TERM);
		s