drvinfo.cpp

快速SQL交互工具

		}

		// numeric functions
		if (bOpen)
			value = SQLGetInfoLong(SQL_NUMERIC_FUNCTIONS);
		for (i = 0; i < NUM_NUMERICS; i++)
		{
			if (bOpen && (value & m_dwNumericMasks[i]))
				nNewItem = m_SqlListControl.InsertItem(NUMERIC_START + i,
					m_szSqlFunctions[NUMERIC_START + i],1);
			else
				nNewItem = m_SqlListControl.InsertItem(NUMERIC_START + i,
					m_szSqlFunctions[NUMERIC_START + i],0);
			m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
				m_szSqlCategories[NUMERIC_START + i],0,0,0,0);
		}

		// string functions
		if (bOpen)
			value = SQLGetInfoLong(SQL_STRING_FUNCTIONS);
		for (i = 0; i < NUM_STRINGS; i++)
		{
			if (bOpen && (value & m_dwStringsMasks[i]))
				nNewItem = m_SqlListControl.InsertItem(STRINGS_START + i,
					m_szSqlFunctions[STRINGS_START + i],1);
			else
				nNewItem = m_SqlListControl.InsertItem(STRINGS_START + i,
					m_szSqlFunctions[STRINGS_START + i],0);
			m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
				m_szSqlCategories[STRINGS_START + i],0,0,0,0);
		}

		// system functions
		if (bOpen)
			value = SQLGetInfoLong(SQL_SYSTEM_FUNCTIONS);
		for (i = 0; i < NUM_SYSTEMS; i++)
		{
			if (bOpen && (value & m_dwSystemsMasks[i]))
				nNewItem = m_SqlListControl.InsertItem(SYSTEMS_START + i,
					m_szSqlFunctions[SYSTEMS_START + i],1);
			else
				nNewItem = m_SqlListControl.InsertItem(SYSTEMS_START + i,
					m_szSqlFunctions[SYSTEMS_START + i],0);
			m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
				m_szSqlCategories[SYSTEMS_START + i],0,0,0,0);
		}

		// timedate functions
		if (bOpen)
			value = SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS);
		for (i = 0; i < NUM_TIMEDATES; i++)
		{
			if (bOpen && (value & m_dwTimeDatesMasks[i]))
				nNewItem = m_SqlListControl.InsertItem(TIMEDATES_START + i,
					m_szSqlFunctions[TIMEDATES_START + i],1);
			else
				nNewItem = m_SqlListControl.InsertItem(TIMEDATES_START + i,
					m_szSqlFunctions[TIMEDATES_START + i],0);
			m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
				m_szSqlCategories[TIMEDATES_START + i],0,0,0,0);
		}
	}
}

BOOL CFunctions::OnInitDialog()
{
	CWaitCursor wait;

	CPropertyPage::OnInitDialog();

	m_ApiListControl.SetImageList(m_pImageList,LVSIL_SMALL);
	m_SqlListControl.SetImageList(m_pImageList,LVSIL_SMALL);

	m_ApiListControl.InsertColumn(0,_T(""),LVCFMT_LEFT,130);
	m_SqlListControl.InsertColumn(0,_T("Function"),LVCFMT_LEFT,120);
	m_SqlListControl.InsertColumn(1,_T("Category"),LVCFMT_LEFT,120);

	m_SqlListControl.SetFullRowSel(TRUE);
	m_ApiListControl.SetFullRowSel(TRUE);

	OnNewDSN();

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

void CFunctions::OnColumnclickSqlFunctions(NMHDR* pNMHDR, LRESULT* pResult) 
{
	CWaitCursor wait;

	NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;

	CSortColumn sort(&m_SqlListControl, pNMListView->iSubItem, false);
	sort.Sort(m_bSort = !m_bSort);
	
	*pResult = 0;
}

/////////////////////////////////////////////////////////////////////////////
// CSupportedSQL property page

IMPLEMENT_DYNCREATE(CSupportedSQL, CPropertyPage)

CSupportedSQL::CSupportedSQL(CDatabase* pDatabase)
 : CMyPage(pDatabase,CSupportedSQL::IDD)
{
	//{{AFX_DATA_INIT(CSupportedSQL)
	m_bSqlAlterTableAdd = FALSE;
	m_bSqlAlterTableDrop = FALSE;
	m_strSqlExpressionsInOrderby = _T("");
	m_strSqlGroupBy = _T("");
	m_strSqlOrderByColumnsInSelect = _T("");
	m_strSqlOuterJoins = _T("");
	m_bSqlSqComparison = FALSE;
	m_bSqlSqCorrelatedSubqueries = FALSE;
	m_bSqlSqExists = FALSE;
	m_bSqlSqIn = FALSE;
	m_bSqlSqQuantified = FALSE;
	m_bSqlUUnion = FALSE;
	m_bSqlUUnionAll = FALSE;
	m_strSqlColumnAlias = _T("");
	m_strSqlLikeEscapeClause = _T("");
	m_bSqlPsPositionedDelete = FALSE;
	m_bSqlPsPositionedUpdate = FALSE;
	m_bSqlPsSelectForUpdate = FALSE;
	m_strSqlCorrelationName = _T("");
	//}}AFX_DATA_INIT

	OnNewDSN();
}

CSupportedSQL::~CSupportedSQL()
{
}

void CSupportedSQL::DumpToFile(CStdioFile& file)
{
	if (m_pDatabase->IsOpen())
	{
		BOOL    b;
		CString string;

		file.WriteString(_T("Supported SQL\n-------------\n"));
		b = FALSE;
		file.WriteString(_T("  ALTER TABLE Support -"));
		if (m_bSqlAlterTableAdd)
		{
			file.WriteString(_T(" ADD"));
			b = TRUE;
		}
		if (m_bSqlAlterTableDrop)
		{
			if (b)
				file.WriteString(_T(","));
			file.WriteString(_T("DROP"));
			b = TRUE;
		}
		if (!b)
			file.WriteString(_T(" <none>"));
		file.WriteString(_T("\n"));
		string.Format(_T("       Column Aliases - %s\n"),m_strSqlColumnAlias);
		file.WriteString(string);
		string.Format(_T("    Correlation Names - %s\n"),m_strSqlCorrelationName);
		file.WriteString(string);
		string.Format(_T(" ORDER BY Expressions - %s\n"),m_strSqlExpressionsInOrderby);
		file.WriteString(string);
		string.Format(_T("GROUP BY NonAggregate - %s\n"),m_strSqlGroupBy);
		file.WriteString(string);
		string.Format(_T("LIKE Escape Character - %s\n"),m_strSqlLikeEscapeClause);
		file.WriteString(string);
		string.Format(_T("   ORDER BY in SELECT - %s\n"),m_strSqlOrderByColumnsInSelect);
		file.WriteString(string);
		string.Format(_T("   Outer Join Support - %s\n"),m_strSqlOuterJoins);
		file.WriteString(string);

		file.WriteString(_T("Positioned Statements -"));
		b = FALSE;
		if (m_bSqlPsPositionedDelete)
		{
			file.WriteString(_T(" Delete"));
			b = TRUE;
		}
		if (m_bSqlPsPositionedUpdate)
		{
			if (b)
				file.WriteString(_T(","));
			file.WriteString(_T("Update"));
			b = TRUE;
		}
		if (m_bSqlPsSelectForUpdate)
		{
			if (b)
				file.WriteString(_T(","));
			file.WriteString(_T("Select for Update"));
			b = TRUE;
		}
		if (!b)
			file.WriteString(_T(" <none>"));
		file.WriteString(_T("\n"));

		file.WriteString(_T("     Subquery Support -"));
		b = FALSE;
		if (m_bSqlSqCorrelatedSubqueries)
		{
			file.WriteString(_T(" Correlated"));
			b = TRUE;
		}
		if (m_bSqlSqComparison)
		{
			if (b)
				file.WriteString(_T(","));
			file.WriteString(_T("Comparison"));
			b = TRUE;
		}
		if (m_bSqlSqExists)
		{
			if (b)
				file.WriteString(_T(","));
			file.WriteString(_T("EXISTS"));
			b = TRUE;
		}
		if (m_bSqlSqIn)
		{
			if (b)
				file.WriteString(_T(","));
			file.WriteString(_T("IN"));
			b = TRUE;
		}
		if (m_bSqlSqQuantified)
		{
			if (b)
				file.WriteString(_T(","));
			file.WriteString(_T("Quantified"));
			b = TRUE;
		}
		if (!b)
			file.WriteString(_T("<none>"));
		file.WriteString(_T("\n"));

		file.WriteString(_T("        UNION Support -"));
		b = FALSE;
		if (m_bSqlUUnion)
		{
			file.WriteString(_T(" UNION"));
			b = TRUE;
		}
		if (m_bSqlUUnionAll)
		{
			if (b)
				file.WriteString(_T(","));
			file.WriteString(_T("UNION with ALL"));
			b = TRUE;
		}
		if (!b)
			file.WriteString(_T("<none>"));
		file.WriteString(_T("\n\n"));
	}
}

void CSupportedSQL::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CSupportedSQL)
	DDX_Check(pDX, IDC_AT_ADD, m_bSqlAlterTableAdd);
	DDX_Check(pDX, IDC_AT_DROP, m_bSqlAlterTableDrop);
	DDX_Text(pDX, IDC_SQL_EXPRESSIONS_IN_ORDERBY, m_strSqlExpressionsInOrderby);
	DDX_Text(pDX, IDC_SQL_GROUP_BY, m_strSqlGroupBy);
	DDX_Text(pDX, IDC_SQL_ORDER_BY_COLUMNS_IN_SELECT, m_strSqlOrderByColumnsInSelect);
	DDX_Text(pDX, IDC_SQL_OUTER_JOINS, m_strSqlOuterJoins);
	DDX_Check(pDX, IDC_SQL_SQ_COMPARISON, m_bSqlSqComparison);
	DDX_Check(pDX, IDC_SQL_SQ_CORRELATED_SUBQUERIES, m_bSqlSqCorrelatedSubqueries);
	DDX_Check(pDX, IDC_SQL_SQ_EXISTS, m_bSqlSqExists);
	DDX_Check(pDX, IDC_SQL_SQ_IN, m_bSqlSqIn);
	DDX_Check(pDX, IDC_SQL_SQ_QUANTIFIED, m_bSqlSqQuantified);
	DDX_Check(pDX, IDC_SQL_U_UNION, m_bSqlUUnion);
	DDX_Check(pDX, IDC_SQL_U_UNION_ALL, m_bSqlUUnionAll);
	DDX_Text(pDX, IDC_SQL_COLUMN_ALIAS, m_strSqlColumnAlias);
	DDX_Text(pDX, IDC_SQL_LIKE_ESCAPE_CLAUSE, m_strSqlLikeEscapeClause);
	DDX_Check(pDX, IDC_SQL_PS_POSITIONED_DELETE, m_bSqlPsPositionedDelete);
	DDX_Check(pDX, IDC_SQL_PS_POSITIONED_UPDATE, m_bSqlPsPositionedUpdate);
	DDX_Check(pDX, IDC_SQL_PS_SELECT_FOR_UPDATE, m_bSqlPsSelectForUpdate);
	DDX_Text(pDX, IDC_SQL_CORRELATION_NAME, m_strSqlCorrelationName);
	//}}AFX_DATA_MAP
}


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

/////////////////////////////////////////////////////////////////////////////
// CSupportedSQL message handlers

void CSupportedSQL::OnNewDSN()
{
	if (m_pDatabase->IsOpen())
	{
		CString string;
		SDWORD  longValue;

		longValue = SQLGetInfoLong(SQL_ALTER_TABLE);
		if (longValue & SQL_AT_ADD_COLUMN)
			m_bSqlAlterTableAdd = TRUE;
		else
			m_bSqlAlterTableAdd = FALSE;
		if (longValue & SQL_AT_DROP_COLUMN)
			m_bSqlAlterTableDrop = TRUE;
		else
			m_bSqlAlterTableDrop = FALSE;
		YIsSupported(m_strSqlColumnAlias,SQL_COLUMN_ALIAS);
		switch (SQLGetInfoShort(SQL_CORRELATION_NAME))
		{
		case SQL_CN_NONE:
			m_strSqlCorrelationName = _T("Not Supported");
			break;
		case SQL_CN_DIFFERENT:
			m_strSqlCorrelationName = _T("Supported, table names must be different");
			break;
		case SQL_CN_ANY:
			m_strSqlCorrelationName = _T("Supported");
			break;
		}
		YIsSupported(m_strSqlExpressionsInOrderby,SQL_EXPRESSIONS_IN_ORDERBY);
		switch (SQLGetInfoShort(SQL_GROUP_BY))
		{
		case SQL_GB_NOT_SUPPORTED:
			m_strSqlGroupBy = _T("GROUP BY Not Supported");
			break;
		case SQL_GB_GROUP_BY_EQUALS_SELECT:
			m_strSqlGroupBy = _T("GROUP BY Equals SELECT");
			break;
		case SQL_GB_GROUP_BY_CONTAINS_SELECT:
			m_strSqlGroupBy = _T("GROUP BY Contains SELECT");
			break;
		case SQL_GB_NO_RELATION:
			m_strSqlGroupBy = _T("No Relation");
			break;
		}
		YIsSupported(m_strSqlLikeEscapeClause,SQL_LIKE_ESCAPE_CLAUSE);
		YIsYes(m_strSqlOrderByColumnsInSelect,SQL_ORDER_BY_COLUMNS_IN_SELECT);
		string = SQLGetInfoString(SQL_OUTER_JOINS);
		if (string == _T("N"))
			m_strSqlOuterJoins = _T("No");
		else if (string == _T("Y"))
			m_strSqlOuterJoins = _T("Yes");
		else if (string == _T("P"))
			m_strSqlOuterJoins = _T("Partial");
		else if (string == _T("F"))
			m_strSqlOuterJoins = _T("Full");
		longValue = SQLGetInfoLong(SQL_POSITIONED_STATEMENTS);
		if (longValue & SQL_PS_POSITIONED_DELETE)
			m_bSqlPsPositionedDelete = TRUE;
		else
			m_bSqlPsPositionedDelete = FALSE;
		if (longValue & SQL_PS_POSITIONED_UPDATE)
			m_bSqlPsPositionedUpdate = TRUE;
		else
			m_bSqlPsPositionedUpdate = FALSE;
		if (longValue & SQL_PS_SELECT_FOR_UPDATE)
			m_bSqlPsSelectForUpdate = TRUE;
		else
			m_bSqlPsSelectForUpdate = FALSE;
		longValue = SQLGetInfoLong(SQL_SUBQUERIES);
		if (longValue & SQL_SQ_CORRELATED_SUBQUERIES)
			m_bSqlSqCorrelatedSubqueries = TRUE;
		else
			m_bSqlSqCorrelatedSubqueries = FALSE;
		if (longValue & SQL_SQ_COMPARISON)
			m_bSqlSqComparison = TRUE;
		else
			m_bSqlSqComparison = FALSE;
		if (longValue & SQL_SQ_EXISTS)
			m_bSqlSqExists = TRUE;
		else
			m_bSqlSqExists = FALSE;
		if (longValue & SQL_SQ_IN)
			m_bSqlSqIn = TRUE;
		else
			m_bSqlSqIn = FALSE;
		if (longValue & SQL_SQ_QUANTIFIED)
			m_bSqlSqQuantified = TRUE;
		else
			m_bSqlSqQuantified = FALSE;
		longValue = SQLGetInfoLong(SQL_UNION);
		if (longValue & SQL_U_UNION)
			m_bSqlUUnion = TRUE;
		else
			m_bSqlUUnion = FALSE;
		if (longValue & SQL_U_UNION_ALL)
			m_bSqlUUnionAll = TRUE;
		else
			m_bSqlUUnionAll = FALSE;

		if (IsWindow(m_hWnd))
			UpdateData(FALSE);
	}
}

BOOL CSupportedSQL::OnInitDialog()
{
	CWaitCursor wait;

	CPropertyPage::OnInitDialog();

	UpdateData(FALSE);

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

/////////////////////////////////////////////////////////////////////////////
// CDataTypes property page

IMPLEMENT_DYNCREATE(CDataTypes, CPropertyPage)

CDataTypes::CDataTypes(CDatabase* pDatabase)
	: m_pGetTypeInfo(0),CMyPage(pDatabase,CDataTypes::IDD),
	m_pTypeDataHead(0),m_pTypeDataTail(0)
{
	//{{AFX_DATA_INIT(CDataTypes)
	m_strSqlType = _T("");
	m_strPrecision = _T("");
	m_strPrefixSuffix = _T("");
	m_strCreateParams = _T("");
	m_strNullable = _T("");
	m_strCaseSensitive = _T("");
	m_strSearchable = _T("");
	m_strMoney = _T("");
	m_strUnsigned = _T("");
	m_strAutoIncrement = _T("");
	m_strMaximumScale = _T("");
	m_strMinimumScale = _T("");
	//}}AFX_DATA_INIT
}

CDataTypes::~CDataTypes()
{
	if (m_pGetTypeInfo)
	{
		if (m_pGetTypeInfo->IsOpen())
			m_pGetTypeInfo->Close();
		delete m_pGetTypeInfo;
	}

	// delete type data list
	TYPEDATA*   p1 = m_pTypeDataHead;
	TYPEDATA*   p2;
	while (p1)
	{
		p2 = p1;
		p1 = p1->pNext;
		delete p2;
	}
}

void CDataTypes::DumpToFile(CStdioFile& file)
{
	if (m_pDatabase->IsOpen())
	{
		CString string;
		CString workString;
		SDWORD  value;

		file.WriteString(_T("Data Types\n----------\n\n"));
		file.WriteString(_T("Native type         SQL Type          Precision   Min Scale  Max Scale\n"));