Files
mono/mcs/tools/sqlsharp/gui/gtk-sharp/sqlsharpgtk.cs
T
Raja R Harinath cd51491631 Fix a few cases of mixed line-endings
This is a scripted conversion of mixed line-ending files to LF-only or CRLF-only
based on which patch is smaller.  I used a threshold of upto a quarter of the
lines to determine whether to keep the patch or not.
2010-07-26 02:20:13 +05:30

1711 lines
40 KiB
C#

//
// SqlSharpGtk - Mono SQL# For GTK# - SQL Query and Configuration tool for
// Mono.Data providers
//
// Author:
// Daniel Morgan <[email protected]>
//
// (C)Copyright 2002, 2003 by Daniel Morgan
//
// To be included with Mono as a SQL query tool licensed under the GPL license.
//
namespace Mono.Data.SqlSharp.Gui.GtkSharp
{
using System;
using System.Collections;
using System.Data;
using System.Data.Common;
using System.Data.Odbc;
using System.Data.OleDb;
using System.Data.SqlClient;
using System.Drawing;
using System.Text;
using System.IO;
using System.Reflection;
using System.Runtime.Remoting;
using System.Runtime.InteropServices;
using System.Diagnostics;
using Gdk;
using Gtk;
using GtkSharp;
using Mono.GtkSharp.Goodies;
using Gtk.Controls;
using SqlEditorSharp;
public enum OutputResults
{
TextView,
DataGrid
}
public enum ExecuteOutputType
{
Normal,
XmlFile,
HtmlFile,
CsvFile
}
public class EditorTab
{
public SqlEditorSharp editor;
public Label label;
public string filename;
public string basefilename;
public int page;
}
public class SqlSharpGtk
{
static int SqlWindowCount = 0;
private IDbConnection conn = null;
public DbProvider dbProvider = null;
private Type connectionType = null;
private Type adapterType = null;
public Assembly providerAssembly = null;
public string connectionString = "";
private Statusbar statusBar;
private Toolbar toolbar;
int lastUnknownFile = 0;
// OutputResults
private VBox outbox;
// OutputResults.TextView
private ScrolledWindow swin;
public TextBuffer buf;
private TextView textView;
private TextTag textTag;
// OutputResults.DataGrid
private DataGrid grid;
private Gtk.Window win;
public static readonly string ApplicationName = "Mono SQL# For GTK#";
private OutputResults outputResults;
public DbProviderCollection providerList;
Notebook sourceFileNotebook;
Notebook resultsNotebook;
ArrayList editorTabs = new ArrayList();
public SqlSharpGtk ()
{
CreateGui ();
SqlWindowCount ++;
LoadProviders ();
}
public void Show ()
{
win.ShowAll ();
}
public void CreateGui()
{
win = new Gtk.Window (ApplicationName);
win.DeleteEvent += new GtkSharp.DeleteEventHandler(OnWindow_Delete);
win.BorderWidth = 4;
win.DefaultSize = new Size (450, 300);
VBox vbox = new VBox (false, 4);
win.Add (vbox);
// Menu Bar
MenuBar mb = CreateMenuBar ();
vbox.PackStart(mb, false, false, 0);
// Tool Bar
toolbar = CreateToolbar ();
vbox.PackStart (toolbar, false, false, 0);
// Panels
VPaned paned = new VPaned ();
vbox.PackStart (paned, true, true, 0);
// SQL Editor (top TextView panel)
sourceFileNotebook = new Notebook();
sourceFileNotebook.Scrollable = true;
NewEditorTab();
paned.Add1 (sourceFileNotebook);
sourceFileNotebook.SwitchPage += new
GtkSharp.SwitchPageHandler(OnEditorTabSwitched);
// bottom panel
resultsNotebook = CreateOutputResultsGui ();
paned.Add2 (resultsNotebook);
statusBar = new Statusbar ();
vbox.PackEnd (statusBar, false, false, 0);
outputResults = OutputResults.TextView;
ToggleResultsOutput ();
}
EditorTab NewEditorTab ()
{
SqlEditorSharp editor;
editor = new SqlEditorSharp ();
editor.UseSyntaxHiLighting = true;
editor.View.Show ();
editor.View.KeyPressEvent +=
new GtkSharp.KeyPressEventHandler(OnKeyPressEventKey);
lastUnknownFile ++;
string unknownFile = "Unknown" +
lastUnknownFile.ToString() + ".sql";
Label label = new Label(unknownFile);
label.Show();
sourceFileNotebook.AppendPage(editor, label);
sourceFileNotebook.ShowAll ();
sourceFileNotebook.ResizeChildren ();
sourceFileNotebook.CurrentPage = -1;
EditorTab tab = new EditorTab();
tab.editor = editor;
tab.label = label;
tab.filename = "";
tab.basefilename = unknownFile;
tab.page = sourceFileNotebook.CurrentPage;
editorTabs.Add(tab);
editor.Tab = tab;
UpdateTitleBar(tab);
return tab;
}
// bottom panel
Notebook CreateOutputResultsGui ()
{
Label label;
Notebook results = new Notebook();
results.TabPos = PositionType.Bottom;
grid = CreateOutputResultsDataGrid ();
grid.Show();
label = new Label("Grid");
results.AppendPage(grid, label);
swin = CreateOutputResultsTextView ();
swin.Show();
label = new Label("Log");
results.AppendPage(swin, label);
sourceFileNotebook.ShowAll ();
sourceFileNotebook.ResizeChildren ();
return results;
}
DataGrid CreateOutputResultsDataGrid ()
{
return new DataGrid ();
}
ScrolledWindow CreateOutputResultsTextView ()
{
ScrolledWindow sw;
sw = new ScrolledWindow (
new Adjustment (0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
new Adjustment (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
sw.HscrollbarPolicy = Gtk.PolicyType.Automatic;
sw.VscrollbarPolicy = Gtk.PolicyType.Automatic;
sw.ShadowType = Gtk.ShadowType.In;
textView = new TextView ();
buf = textView.Buffer;
textView.Editable = false;
textView.ModifyFont (Pango.FontDescription.FromString ("courier new"));
sw.Add (textView);
return sw;
}
void OnKeyPressEventKey(object o, GtkSharp.KeyPressEventArgs args)
{
if (o is TextView) {
TextView tv = (TextView) o;
//Gdk.EventKey k = args.Event;
// if the F5 key was pressed
if (args.Event.keyval == 0xFFC2) {
if (tv.Editable == true) {
// execute SQL
ExecuteSQL (ExecuteOutputType.Normal, "");
}
}
}
}
Toolbar CreateToolbar ()
{
Toolbar toolbar = new Toolbar ();
toolbar.ToolbarStyle = ToolbarStyle.Icons;
toolbar.AppendItem ("Execute",
"Execute SQL Commands.", String.Empty,
new Gtk.Image (Stock.Execute, IconSize.SmallToolbar),
new Gtk.SignalFunc (OnToolbar_Execute));
toolbar.AppendItem ("DataGrid",
"Toggle Results to DataGrid or TextView", String.Empty,
new Gtk.Image (Stock.GoDown, IconSize.SmallToolbar),
new Gtk.SignalFunc (OnToolbar_ToggleResultsOutput));
return toolbar;
}
// TODO: use the ProviderFactory in Mono.Data
// to load providers
// instead of what's below
public void LoadProviders ()
{
providerList = new DbProviderCollection ();
providerList.Add (new DbProvider (
"MYSQL",
"MySQL (Mono)",
"Mono.Data.MySql",
"Mono.Data.MySql.MySqlConnection",
"Mono.Data.MySql.MySqlDataAdapter",
false ));
providerList.Add (new DbProvider (
"MYSQLNET",
"MySQL (ByteFX)",
"ByteFX.Data",
"ByteFX.Data.MySQLClient.MySQLConnection",
"ByteFX.Data.MySQLClient.MySQLDataAdapter",
false ));
providerList.Add (new DbProvider (
"POSTGRESQL",
"PostgreSQL (Mono)",
"Mono.Data.PostgreSqlClient",
"Mono.Data.PostgreSqlClient.PgSqlConnection",
"Mono.Data.PostgreSqlClient.PgSqlDataAdapter",
false ));
providerList.Add (new DbProvider (
"NPGSQL",
"PostgreSQL (Npgsql)",
"Npgsql",
"Npgsql.NpgsqlConnection",
"Npgsql.NpgsqlDataAdapter",
false ));
providerList.Add (new DbProvider (
"SQLCLIENT",
"Microsoft SQL Server",
"",
"",
"",
true ));
providerList.Add (new DbProvider (
"TDS",
"TDS Generic",
"Mono.Data.TdsClient",
"Mono.Data.TdsClient.TdsConnection",
"Mono.Data.TdsClient.TdsDataAdapter",
false ));
providerList.Add (new DbProvider (
"ODBC",
"ODBC",
"",
"",
"",
true ));
providerList.Add (new DbProvider (
"OLEDB",
"OLE DB",
"",
"",
"",
true ));
providerList.Add (new DbProvider (
"SQLITE",
"SQL Lite",
"Mono.Data.SqliteClient",
"Mono.Data.SqliteClient.SqliteConnection",
"Mono.Data.SqliteClient.SqliteDataAdapter",
false ));
providerList.Add (new DbProvider (
"SYBASE",
"Sybase",
"Mono.Data.SybaseClient",
"Mono.Data.SybaseClient.SybaseConnection",
"Mono.Data.SybaseClient.SybaseDataAdapter",
false ));
providerList.Add (new DbProvider (
"DB2",
"IBM DB2",
"Mono.Data.DB2Client",
"Mono.Data.DB2Client.DB2ClientConnection",
"Mono.Data.DB2Client.DB2ClientDataAdapter",
false ));
providerList.Add (new DbProvider (
"ORACLE",
"Oracle",
"System.Data.OracleClient",
"System.Data.OracleClient.OracleConnection",
"System.Data.OracleClient.OracleDataAdapter",
false ));
}
public MenuBar CreateMenuBar ()
{
MenuBar menuBar = new MenuBar ();
Menu menu;
Menu submenu;
MenuItem item;
MenuItem barItem;
MenuItem subitem;
// File menu
menu = new Menu ();
item = new MenuItem ("New SQL# _Window");
item.Activated += new EventHandler (OnMenu_FileNewSqlWindow);
menu.Append (item);
menu.Append (new SeparatorMenuItem ());
item = new MenuItem ("_New");
item.Activated += new EventHandler (OnMenu_FileNew);
menu.Append (item);
item = new MenuItem ("_Open...");
item.Activated += new EventHandler (OnMenu_FileOpen);
menu.Append (item);
item = new MenuItem ("_Save");
item.Activated += new EventHandler (OnMenu_FileSave);
menu.Append (item);
item = new MenuItem ("Save _As...");
item.Activated += new EventHandler (OnMenu_FileSaveAs);
menu.Append (item);
item = new MenuItem ("Close");
item.Activated += new EventHandler (OnMenu_FileClose);
menu.Append (item);
menu.Append (new SeparatorMenuItem ());
// TODO: submenu Save Output
submenu = new Menu ();
subitem = new MenuItem ("CSV - Comma Separated Values");
//subitem.Activated += new EventHandler (OnMenu_FileSaveOutput_CSV);
submenu.Append(subitem);
subitem = new MenuItem ("TAB - Tab Separated Values");
//subitem.Activated += new EventHandler (OnMenu_FileSaveOutput_TAB);
submenu.Append(subitem);
subitem = new MenuItem ("XML");
//subitem.Activated += new EventHandler (OnMenu_FileSaveOutput_XML);
submenu.Append(subitem);
item = new MenuItem ("Save _Output...");
item.Submenu = submenu;
menu.Append (item);
menu.Append (new SeparatorMenuItem ());
item = new MenuItem ("E_xit");
item.Activated += new EventHandler (OnMenu_FileExit);
menu.Append (item);
barItem = new MenuItem ("_File");
barItem.Submenu = menu;
menuBar.Append (barItem);
// Edit menu
menu = new Menu ();
item = new MenuItem ("_Undo");
//item.Activated += new EventHandler (OnMenu_EditUndo);
menu.Append (item);
item = new MenuItem ("_Redo");
//item.Activated += new EventHandler (OnMenu_EditRedo);
menu.Append (item);
menu.Append (new SeparatorMenuItem ());
item = new MenuItem ("Cu_t");
//item.Activated += new EventHandler (OnMenu_EditCut);
menu.Append (item);
item = new MenuItem ("_Copy");
//item.Activated += new EventHandler (OnMenu_EditCopy);
menu.Append (item);
item = new MenuItem ("_Paste");
//item.Activated += new EventHandler (OnMenu_EditPaste);
menu.Append (item);
item = new MenuItem ("_Delete");
//item.Activated += new EventHandler (OnMenu_EditDelete);
menu.Append (item);
menu.Append (new SeparatorMenuItem ());
item = new MenuItem ("_Find and Replace...");
//item.Activated += new EventHandler (OnMenu_EditFindReplace);
menu.Append (item);
menu.Append (new SeparatorMenuItem ());
item = new MenuItem ("_Options");
//item.Activated += new EventHandler (OnMenu_EditOptions);
menu.Append (item);
barItem = new MenuItem ("_Edit");
barItem.Submenu = menu;
menuBar.Append (barItem);
// Session menu
menu = new Menu ();
item = new MenuItem ("_Connect");
item.Activated += new EventHandler (OnMenu_SessionConnect);
menu.Append (item);
item = new MenuItem ("_Disconnect");
item.Activated += new EventHandler (OnMenu_SessionDisconnect);
menu.Append (item);
barItem = new MenuItem ("_Session");
barItem.Submenu = menu;
menuBar.Append (barItem);
// Command menu
menu = new Menu ();
item = new MenuItem ("_Execute");
item.Activated += new EventHandler (OnMenu_CommandExecute);
menu.Append (item);
item = new MenuItem ("_Execute With Output to XML");
item.Activated += new EventHandler (OnMenu_CommandExecuteXML);
menu.Append (item);
item = new MenuItem ("_Execute With Output to CSV");
item.Activated += new EventHandler (OnMenu_CommandExecuteCSV);
menu.Append (item);
item = new MenuItem ("_Execute With Output to HTML");
item.Activated += new EventHandler (OnMenu_CommandExecuteHTML);
menu.Append (item);
barItem = new MenuItem ("_Command");
barItem.Submenu = menu;
menuBar.Append (barItem);
return menuBar;
}
void AppendText (string text)
{
AppendText (buf, text);
}
public void AppendTextWithoutScroll (TextBuffer buffer, string text)
{
TextIter iter;
text = text.Replace("\0","");
buffer.MoveMark(buf.InsertMark, buffer.EndIter);
if (text.Equals ("") == false) {
iter = buffer.EndIter;
buffer.Insert (iter, text);
}
iter = buffer.EndIter;
buffer.Insert (iter, "\n");
}
// WriteLine() to output text to bottom TextView
// for displaying result sets and logging messages
public void AppendText (TextBuffer buffer, string text)
{
AppendTextWithoutScroll(buffer,text);
while (Application.EventsPending ())
Application.RunIteration ();
textView.ScrollToMark (buf.InsertMark, 0.4, true, 0.0, 1.0);
}
public bool LoadExternalProvider (string strProviderAssembly,
string providerConnectionClass)
{
try {
SqlSharpGtk.DebugWriteLine ("Loading external provider...");
providerAssembly = null;
providerAssembly = Assembly.Load (strProviderAssembly);
Type typ = providerAssembly.GetType (providerConnectionClass);
conn = (IDbConnection) Activator.CreateInstance (typ);
SqlSharpGtk.DebugWriteLine ("External provider loaded.");
}
catch (Exception f) {
string errorMessage = String.Format (
"Error: unable to load the assembly of the provider: {1} because: {2}",
providerAssembly,
f.Message);
Error (errorMessage);
return false;
}
return true;
}
void QuitApplication()
{
if(conn != null)
if(conn.State == ConnectionState.Open) {
Console.WriteLine("Closing connection...");
conn.Close();
conn = null;
Console.WriteLine("Connection closed.");
}
if(grid.DataSource != null) {
grid.Clear ();
grid.DataSource = null;
grid.DataMember = "";
grid = null;
}
SqlWindowCount --;
if(SqlWindowCount == 0)
Application.Quit ();
else
win.Destroy ();
}
void UpdateTitleBar(EditorTab tab)
{
string title = "";
if(tab != null) {
if(tab.filename.Equals(""))
title = tab.label.Text + " - " + ApplicationName;
else
title = tab.filename + " - " + ApplicationName;
}
else {
title = ApplicationName;
}
win.Title = title;
}
void OnEditorTabSwitched (object o, GtkSharp.SwitchPageArgs args)
{
int page = (int) args.PageNum;
EditorTab tab = FindEditorTab(page);
UpdateTitleBar (tab);
}
void OnWindow_Delete (object o, GtkSharp.DeleteEventArgs args)
{
QuitApplication();
}
void OnExit (Gtk.Object o)
{
QuitApplication();
}
void OnMenu_FileNewSqlWindow (object o, EventArgs args)
{
SqlSharpGtk sqlSharp = new SqlSharpGtk ();
sqlSharp.Show ();
}
void OnMenu_FileNew (object o, EventArgs args)
{
NewEditorTab();
sourceFileNotebook.CurrentPage = -1;
}
void OnMenu_FileOpen (object o, EventArgs args)
{
FileSelectionDialog openFileDialog =
new FileSelectionDialog ("Open File",
new FileSelectionEventHandler (OnOpenFile));
}
void OnOpenFile (object o, FileSelectionEventArgs args)
{
EditorTab etab = NewEditorTab();
try {
etab.editor.LoadFromFile (args.Filename);
}
catch(Exception openFileException) {
Error("Error: Could not open file: \n" +
args.Filename +
"\n\nReason: " +
openFileException.Message);
return;
}
TextBuffer buf = etab.editor.Buffer;
buf.Modified = false;
string basefile = Path.GetFileName (args.Filename);
etab.label.Text = basefile;
etab.basefilename = basefile;
etab.filename = args.Filename;
sourceFileNotebook.CurrentPage = -1;
UpdateTitleBar(etab);
}
EditorTab FindEditorTab (int searchPage)
{
EditorTab tab = null;
for (int t = 0; t < editorTabs.Count; t++) {
tab = (EditorTab) editorTabs[t];
if (tab.page == searchPage)
return tab;
}
return tab;
}
void OnMenu_FileSave (object o, EventArgs args)
{
int page = sourceFileNotebook.CurrentPage;
EditorTab tab = FindEditorTab(page);
if(tab.filename.Equals(""))
SaveAs();
else {
SaveFile(tab.filename);
tab.label.Text = tab.basefilename;
}
}
void SaveFile (string filename)
{
int page = sourceFileNotebook.CurrentPage;
EditorTab etab = FindEditorTab(page);
try {
// FIXME: if file exists, ask if you want to
// overwrite. currently, it overwrites
// without asking.
etab.editor.SaveToFile (filename);
} catch(Exception saveFileException) {
Error("Error: Could not open file: \n" +
filename +
"\n\nReason: " +
saveFileException.Message);
return;
}
TextBuffer buf = etab.editor.Buffer;
buf.Modified = false;
}
void OnMenu_FileSaveAs (object o, EventArgs args)
{
SaveAs();
}
void SaveAs()
{
FileSelectionDialog openFileDialog =
new FileSelectionDialog ("File Save As",
new FileSelectionEventHandler (OnSaveAsFile));
}
void OnSaveAsFile (object o, FileSelectionEventArgs args)
{
int page = sourceFileNotebook.CurrentPage;
EditorTab etab = FindEditorTab(page);
SaveFile(args.Filename);
string basefile = Path.GetFileName (args.Filename);
etab.label.Text = basefile;
etab.basefilename = basefile;
etab.filename = args.Filename;
UpdateTitleBar(etab);
}
void OnMenu_FileClose (object o, EventArgs args)
{
CloseEditor();
}
void OnCloseEditor (object obj, EventArgs args)
{
CloseEditor();
}
void CloseEditor ()
{
int page = sourceFileNotebook.CurrentPage;
SqlEditorSharp sqlEditor;
sqlEditor = (SqlEditorSharp) sourceFileNotebook.GetNthPage(page);
TextBuffer buffer = sqlEditor.Buffer;
if(buffer.Modified) {
// TODO: if text modified,
// ask if user wants to save
// before closing.
// use MessageDialog to prompt
RemoveEditorTab (sqlEditor.Tab, page);
}
else {
RemoveEditorTab (sqlEditor.Tab, page);
}
sqlEditor = null;
buffer = null;
}
void RemoveEditorTab (EditorTab tab, int page)
{
tab.editor.Clear();
tab.editor.Tab = null;
tab.editor = null;
tab.label = null;
editorTabs.Remove(tab);
sourceFileNotebook.RemovePage (page);
sourceFileNotebook.QueueDraw();
tab = null;
}
void OnMenu_FileExit (object o, EventArgs args)
{
QuitApplication ();
}
void OnMenu_SessionConnect (object o, EventArgs args)
{
LoginDialog login = new LoginDialog (this);
login = null;
}
void OnMenu_SessionDisconnect (object o, EventArgs args)
{
AppendText(buf, "Disconnecting...");
try {
conn.Close ();
conn = null;
}
catch (Exception e) {
Error ("Error: Unable to disconnect." +
e.Message);
conn = null;
return;
}
AppendText (buf, "Disconnected.");
}
void OnToolbar_ToggleResultsOutput ()
{
ToggleResultsOutput ();
}
void ToggleResultsOutput ()
{
if (outputResults == OutputResults.TextView) {
outputResults = OutputResults.DataGrid;
}
else if (outputResults == OutputResults.DataGrid) {
outputResults = OutputResults.TextView;
}
}
public void OnToolbar_Execute ()
{
ExecuteSQL (ExecuteOutputType.Normal, "");
}
// Execute SQL Commands
void ExecuteSQL (ExecuteOutputType outputType, string filename)
{
if (conn == null) {
AppendText (buf, "Error: Not Connected.");
return;
}
DataTable schemaTable = null;
int page = sourceFileNotebook.CurrentPage;
EditorTab tab = FindEditorTab(page);
string msg = "";
string sql = "";
IDbCommand cmd;
try {
cmd = conn.CreateCommand ();
}
catch (Exception ec) {
AppendText (buf,
"Error: Unable to create command to execute: " +
ec.Message);
return;
}
SqlSharpGtk.DebugWriteLine ("get text from SQL editor...");
// get text from SQL editor
try {
TextIter start_iter, end_iter;
TextBuffer exeBuff;
exeBuff = tab.editor.Buffer;
start_iter = exeBuff.StartIter;
end_iter = exeBuff.EndIter;
sql = exeBuff.GetText(start_iter, end_iter, false);
}
catch (Exception et) {
AppendText (buf,
"Error: Unable to get text from SQL editor: " +
et.Message);
return;
}
try {
cmd.CommandText = sql;
}
catch (Exception e) {
AppendText (buf,
"Error: Unable to set SQL text to command.");
}
IDataReader reader = null;
SqlSharpGtk.DebugWriteLine ("Executing SQL: " + sql);
if ((outputResults == OutputResults.TextView &&
outputType == ExecuteOutputType.Normal) ||
outputType == ExecuteOutputType.HtmlFile ||
outputType == ExecuteOutputType.CsvFile) {
try {
reader = cmd.ExecuteReader ();
}
catch (Exception e) {
//msg = "SQL Execution Error: " + e.Message;
msg = "SQL Execution Error: " + e;
Error (msg);
return;
}
if (reader == null) {
Error("Error: reader is null");
return;
}
}
try {
if (outputResults == OutputResults.TextView &&
outputType == ExecuteOutputType.Normal) {
DisplayData (reader);
// clean up
reader.Close ();
reader.Dispose ();
reader = null;
}
else if(outputType == ExecuteOutputType.HtmlFile) {
schemaTable = reader.GetSchemaTable();
if(schemaTable != null && reader.FieldCount > 0) {
OutputDataToHtmlFile(reader, schemaTable, filename);
}
else {
AppendText("Command executed.");
}
// clean up
reader.Close ();
reader.Dispose ();
reader = null;
}
else if(outputType == ExecuteOutputType.CsvFile) {
schemaTable = reader.GetSchemaTable();
if(schemaTable != null && reader.FieldCount > 0) {
OutputDataToCsvFile(reader, schemaTable, filename);
}
else {
AppendText("Command executed.");
}
// clean up
reader.Close ();
reader.Dispose ();
reader = null;
}
else {
DataTable dataTable = LoadDataTable (cmd);
switch(outputType) {
case ExecuteOutputType.Normal:
AppendText("set DataGrid.DataSource to DataTable...");
grid.DataSource = dataTable;
AppendText("DataBind...");
grid.DataBind ();
AppendText("Clean up...");
// clean up
grid.DataSource = null;
break;
case ExecuteOutputType.XmlFile:
AppendText("Create DataSet...");
DataSet dataSet = new DataSet();
AppendText("Add DataTable to DataSet's DataTableCollection...");
dataSet.Tables.Add(dataTable);
AppendText("Write DataSet to XML file: " +
filename);
dataSet.WriteXml(filename);
AppendText("Clean up...");
dataSet = null;
break;
}
// clean up
dataTable.Clear();
dataTable.Dispose();
dataTable = null;
AppendText("Done.");
cmd.Dispose();
cmd = null;
}
}
catch (Exception e) {
//msg = "Error Displaying Data: " + e.Message;
msg = "Error Displaying Data: " + e;
Error (msg);
}
}
public void OutputDataToHtmlFile(IDataReader rdr, DataTable dt, string file)
{
AppendText("Outputting results to HTML file " + file + "...");
StreamWriter outputFilestream = null;
try {
outputFilestream = new StreamWriter(file);
}
catch(Exception e) {
Error("Error: Unable to setup output results file. " +
e.Message);
return;
}
StringBuilder strHtml = new StringBuilder();
strHtml.Append("<html>\n<head><title>");
strHtml.Append("Results");
strHtml.Append("</title></head>\n");
strHtml.Append("<body>\n");
strHtml.Append("<h1>Results</h1>\n");
strHtml.Append("\t<table border=1>\n");
outputFilestream.WriteLine(strHtml.ToString());
strHtml = null;
strHtml = new StringBuilder();
strHtml.Append("\t\t<tr>\n");
for (int c = 0; c < rdr.FieldCount; c++) {
strHtml.Append("\t\t\t<td><b>");
string sColumnName = rdr.GetName(c);
strHtml.Append(sColumnName);
strHtml.Append("</b></td>\n");
}
strHtml.Append("\t\t</tr>\n");
outputFilestream.WriteLine(strHtml.ToString());
strHtml = null;
int col = 0;
string dataValue = "";
while(rdr.Read()) {
strHtml = new StringBuilder();
strHtml.Append("\t\t<tr>\n");
for(col = 0; col < rdr.FieldCount; col++) {
// column data
if(rdr.IsDBNull(col) == true)
dataValue = "NULL";
else {
object obj = rdr.GetValue(col);
dataValue = obj.ToString();
}
strHtml.Append("\t\t\t<td>");
strHtml.Append(dataValue);
strHtml.Append("</td>\n");
}
strHtml.Append("\t\t</tr>\n");
outputFilestream.WriteLine(strHtml.ToString());
strHtml = null;
}
outputFilestream.WriteLine("\t</table>\n</body>\n</html>\n");
strHtml = null;
outputFilestream.Close();
outputFilestream = null;
AppendText("Outputting file done.");
}
public void OutputDataToCsvFile(IDataReader rdr, DataTable dt, string file)
{
AppendText("Outputting results to CSV file " + file + "...");
StreamWriter outputFilestream = null;
try {
outputFilestream = new StreamWriter(file);
}
catch(Exception e) {
Error("Error: Unable to setup output results file. " +
e.Message);
return;
}
StringBuilder strCsv = null;
int col = 0;
string dataValue = "";
while(rdr.Read()) {
strCsv = new StringBuilder();
for(col = 0; col < rdr.FieldCount; col++) {
if(col > 0)
strCsv.Append(",");
// column data
if(rdr.IsDBNull(col) == true)
dataValue = "\"\"";
else {
object obj = rdr.GetValue(col);
dataValue = "\"" + obj.ToString() + "\"";
}
strCsv.Append(dataValue);
}
outputFilestream.WriteLine(strCsv.ToString());
strCsv = null;
}
strCsv = null;
outputFilestream.Close();
outputFilestream = null;
AppendText("Outputting file done.");
}
void OnMenu_CommandExecute (object o, EventArgs args)
{
ExecuteSQL (ExecuteOutputType.Normal, "");
}
void OnMenu_CommandExecuteXML (object o, EventArgs args)
{
ExecuteAndSaveResultsToFile (ExecuteOutputType.XmlFile);
}
void OnMenu_CommandExecuteCSV (object o, EventArgs args)
{
ExecuteAndSaveResultsToFile (ExecuteOutputType.CsvFile);
}
void OnMenu_CommandExecuteHTML (object o, EventArgs args)
{
ExecuteAndSaveResultsToFile (ExecuteOutputType.HtmlFile);
}
ExecuteOutputType outType;
void ExecuteAndSaveResultsToFile(ExecuteOutputType oType)
{
outType = oType;
FileSelectionDialog openFileDialog =
new FileSelectionDialog ("Results File Save As",
new FileSelectionEventHandler (OnSaveExeOutFile));
}
void OnSaveExeOutFile (object o, FileSelectionEventArgs args)
{
ExecuteSQL (outType, args.Filename);
}
public void DisplayResult (IDataReader reader, DataTable schemaTable)
{
const string zero = "0";
StringBuilder column = null;
StringBuilder line = null;
StringBuilder hdrUnderline = null;
string outData = "";
int hdrLen = 0;
int spacing = 0;
int columnSize = 0;
int c;
char spacingChar = ' '; // a space
char underlineChar = '='; // an equal sign
string dataType; // .NET Type
Type theType;
string dataTypeName; // native Database type
DataRow row; // schema row
line = new StringBuilder ();
hdrUnderline = new StringBuilder ();
try {
OutputLine ("Fields in Query Result: " +
reader.FieldCount);
}
catch(Exception e){
Error ("Error: Unable to get FieldCount: " +
e.Message);
return;
}
OutputLine ("");
for(c = 0; c < reader.FieldCount; c++) {
try {
DataRow schemaRow = schemaTable.Rows[c];
string columnHeader = reader.GetName (c);
if (columnHeader.Equals (""))
columnHeader = "column";
if (columnHeader.Length > 32)
columnHeader = columnHeader.Substring (0,32);
// spacing
columnSize = (int) schemaRow["ColumnSize"];
theType = reader.GetFieldType(c);
dataType = theType.ToString();
//dataTypeName = reader.GetDataTypeName(c);
switch(dataType) {
case "System.DateTime":
columnSize = 19;
break;
case "System.Boolean":
columnSize = 5;
break;
}
hdrLen = Math.Max (columnHeader.Length, columnSize);
if(hdrLen < 0)
hdrLen = 0;
if(hdrLen > 32)
hdrLen = 32;
line.Append(columnHeader);
if(columnHeader.Length < hdrLen) {
spacing = hdrLen - columnHeader.Length;
line.Append(spacingChar, spacing);
}
hdrUnderline.Append(underlineChar, hdrLen);
line.Append(" ");
hdrUnderline.Append(" ");
}
catch(Exception e) {
Error ("Error: Unable to display header: " +
e.Message);
return;
}
}
OutputHeader(line.ToString());
line = null;
OutputHeader(hdrUnderline.ToString());
OutputHeader("");
hdrUnderline = null;
int numRows = 0;
// column data
try {
while(reader.Read()) {
numRows++;
line = new StringBuilder();
for(c = 0; c < reader.FieldCount; c++) {
int dataLen = 0;
string dataValue = "";
column = new StringBuilder();
outData = "";
row = schemaTable.Rows[c];
string colhdr = (string) reader.GetName(c);
if(colhdr.Equals(""))
colhdr = "column";
if(colhdr.Length > 32)
colhdr = colhdr.Substring(0, 32);
columnSize = (int) row["ColumnSize"];
theType = reader.GetFieldType(c);
dataType = theType.ToString();
//dataTypeName = reader.GetDataTypeName(c);
switch(dataType) {
case "System.DateTime":
columnSize = 19;
break;
case "System.Boolean":
columnSize = 5;
break;
}
columnSize = Math.Max(colhdr.Length, columnSize);
if(columnSize < 0)
columnSize = 0;
if(columnSize > 32)
columnSize = 32;
dataValue = "";
if(reader.IsDBNull(c)) {
dataValue = "";
dataLen = 0;
}
else {
StringBuilder sb;
DateTime dt;
if(dataType.Equals("System.DateTime")) {
// display date in ISO format
// "YYYY-MM-DD HH:MM:SS"
dt = reader.GetDateTime(c);
sb = new StringBuilder();
// year
if(dt.Year < 10)
sb.Append("000" + dt.Year);
else if(dt.Year < 100)
sb.Append("00" + dt.Year);
else if(dt.Year < 1000)
sb.Append("0" + dt.Year);
else
sb.Append(dt.Year);
sb.Append("-");
// month
if(dt.Month < 10)
sb.Append(zero + dt.Month);
else
sb.Append(dt.Month);
sb.Append("-");
// day
if(dt.Day < 10)
sb.Append(zero + dt.Day);
else
sb.Append(dt.Day);
sb.Append(" ");
// hour
if(dt.Hour < 10)
sb.Append(zero + dt.Hour);
else
sb.Append(dt.Hour);
sb.Append(":");
// minute
if(dt.Minute < 10)
sb.Append(zero + dt.Minute);
else
sb.Append(dt.Minute);
sb.Append(":");
// second
if(dt.Second < 10)
sb.Append(zero + dt.Second);
else
sb.Append(dt.Second);
dataValue = sb.ToString();
}
else {
object o = reader.GetValue(c);
dataValue = o.ToString();
}
dataLen = dataValue.Length;
if(dataLen <= 0) {
dataValue = "";
dataLen = 0;
}
if(dataLen > 32) {
dataValue = dataValue.Substring(0,32);
dataLen = 32;
}
}
columnSize = Math.Max (columnSize, dataLen);
if(dataLen < columnSize) {
switch(dataType) {
case "System.Byte":
case "System.SByte":
case "System.Int16":
case "System.UInt16":
case "System.Int32":
case "System.UInt32":
case "System.Int64":
case "System.UInt64":
case "System.Single":
case "System.Double":
case "System.Decimal":
outData = dataValue.PadLeft(columnSize);
break;
default:
outData = dataValue.PadRight(columnSize);
break;
}
outData = outData + " ";
}
else
outData = dataValue;
line.Append (outData);
line.Append (" ");
}
OutputData (line.ToString ());
line = null;
}
}
catch (Exception rr) {
Error ("Error: Unable to read next row: " +
rr.Message);
return;
}
OutputLine ("\nRows retrieved: " + numRows.ToString());
AppendText("");
}
public void DisplayData(IDataReader reader)
{
bool another = false;
DataTable schemaTable = null;
int ResultSet = 0;
OutputLine ("Display any result sets...");
do {
// by Default, data reader has the
// first Result set if any
ResultSet++;
OutputLine ("Display the result set " + ResultSet);
if (reader.FieldCount > 0) {
// SQL Query (SELECT)
// RecordsAffected -1 and DataTable has a reference
try {
schemaTable = reader.GetSchemaTable ();
}
catch (Exception es) {
Error ("Error: Unable to get schema table: " +
es.Message);
return;
}
AppendText (buf, "Display Result...");
DisplayResult (reader, schemaTable);
}
else if (reader.RecordsAffected >= 0) {
// SQL Command (INSERT, UPDATE, or DELETE)
// RecordsAffected >= 0
int records = 0;
try {
records = reader.RecordsAffected;
AppendText (buf, "SQL Command Records Affected: " +
records);
}
catch (Exception er) {
Error ("Error: Unable to get records affected: " +
er.Message);
return;
}
}
else {
// SQL Command (not INSERT, UPDATE, nor DELETE)
// RecordsAffected -1 and DataTable has a null reference
AppendText (buf, "SQL Command Executed.");
}
// get next result set (if anymore is left)
try {
another = reader.NextResult ();
}
catch(Exception e) {
Error ("Error: Unable to read next result: " +
e.Message);
return;
}
} while(another == true);
}
// used for outputting message, but if silent is set,
// don't display
public void OutputLine(string line)
{
//if(silent == false)
OutputData(line);
}
// used for outputting the header columns of a result
public void OutputHeader(string line)
{
//if(showHeader == true)
OutputData(line);
}
// OutputData() - used for outputting data
// if an output filename is set, then the data will
// go to a file; otherwise, it will go to the Console.
public void OutputData(string line)
{
//if(outputFilestream == null)
// Console.WriteLine(line);
//else
// outputFilestream.WriteLine(line);
AppendTextWithoutScroll(buf,line);
}
public void Error(string message)
{
Console.WriteLine(message);
Console.Out.Flush();
AppendText(buf, message);
}
bool OpenInternalProvider ()
{
string msg;
string providerKey = dbProvider.Key;
switch (providerKey.ToUpper ()) {
case "SQLCLIENT":
try {
conn = new SqlConnection ();
}
catch (Exception e) {
msg = "Error: unable to create connection: " +
e.Message;
Error (msg);
return false;
}
break;
case "ODBC":
try {
conn = new OdbcConnection ();
}
catch (Exception e) {
msg = "Error: unable to create connection: " +
e.Message;
Error (msg);
return false;
}
break;
case "OLEDB":
try {
conn = new OleDbConnection ();
}
catch (Exception e) {
msg = "Error: unable to create connection: " +
e.Message;
Error (msg);
return false;
}
break;
default:
msg = "Error: provider not supported.";
Error (msg);
return false;
}
return true;
}
bool OpenExternalProvider()
{
bool success = false;
success = LoadExternalProvider (
dbProvider.Assembly,
dbProvider.ConnectionClass);
return success;
}
public DbDataAdapter CreateDbDataAdapter (IDbCommand cmd)
{
string msg = "";
DbDataAdapter dbAdapter = null;
if (dbProvider.InternalProvider == true) {
dbAdapter = CreateInternalDataAdapter (cmd);
}
else {
dbAdapter = CreateExternalDataAdapter (dbProvider.AdapterClass, cmd);
}
return dbAdapter;
}
public DbDataAdapter CreateInternalDataAdapter (IDbCommand cmd)
{
string msg = "";
DbDataAdapter dbAdapter = null;
string providerKey = dbProvider.Key;
switch (providerKey.ToUpper ()) {
case "SQLCLIENT":
try {
dbAdapter = new SqlDataAdapter (cmd as SqlCommand);
}
catch (Exception e) {
msg = "Error: unable to create adapter: " +
e.Message;
Error (msg);
return null;
}
break;
case "OLEDB":
try {
dbAdapter = new OleDbDataAdapter (cmd as OleDbCommand);
}
catch (Exception e) {
msg = "Error: unable to create adapter: " +
e.Message;
Error (msg);
return null;
}
break;
case "ODBC":
try {
dbAdapter = new OdbcDataAdapter (cmd as OdbcCommand);
}
catch (Exception e) {
msg = "Error: unable to create adapter: " +
e.Message;
Error (msg);
return null;
}
break;
}
return dbAdapter;
}
public DbDataAdapter CreateExternalDataAdapter (string adapterClass, IDbCommand cmd)
{
adapterType = providerAssembly.GetType (adapterClass);
System.Object ad = Activator.CreateInstance (adapterType);
// set property SelectCommand on DbDataAdapter
PropertyInfo prop = adapterType.GetProperty("SelectCommand");
prop.SetValue (ad, cmd, null);
return (DbDataAdapter) ad;
}
public DataTable LoadDataTable (IDbCommand dbcmd)
{
string status = String.Empty;
AppendText("Create DbDataAdapter...");
SqlSharpDataAdapter adapter = new SqlSharpDataAdapter (dbcmd);
AppendText("Create DataTable...");
DataTable dataTable = new DataTable ();
AppendText("Fill data into DataTable via DbDataAdapter...");
int rowsAddedOrRefreshed = 0;
IDataReader reader = null;
try {
reader = dbcmd.ExecuteReader ();
if (reader.FieldCount > 0)
rowsAddedOrRefreshed = adapter.FillTable (dataTable, reader);
}
catch(Exception sqle) {
status = "Error: " + sqle.Message;
}
if (status.Equals(String.Empty)) {
AppendText("Rows successfully Added or Refreshed in the DataTable: " +
rowsAddedOrRefreshed);
int rowsAffected = reader.RecordsAffected;
AppendText("Rows Affected: " + rowsAffected);
int fields = ((IDataRecord) reader).FieldCount;
AppendText("Field Count: " + fields);
if (fields > 0) {
status = "Rows Selected: " + rowsAddedOrRefreshed +
" Fields: " + fields;
}
else {
status = "Rows Modified: " + rowsAffected;
}
}
AppendText("Status: " + status);
adapter.Dispose();
adapter = null;
AppendText("Return DataTable...");
return dataTable;
}
public bool OpenDataSource ()
{
string msg;
bool gotClass = false;
msg = "Attempt to open connection...";
AppendText (buf, msg);
conn = null;
try {
if (dbProvider.InternalProvider == true) {
gotClass = OpenInternalProvider ();
}
else {
gotClass = OpenExternalProvider ();
}
}
catch (Exception e) {
msg = "Error: Unable to create Connection object. " +
e.Message;
Error (msg);
return false;
}
if (gotClass == false)
return false;
conn.ConnectionString = connectionString;
try {
conn.Open ();
if( conn.State == ConnectionState.Open)
AppendText (buf, "Open was successfull.");
else {
AppendText (buf, "Error: Open failed.");
return false;
}
}
catch (Exception e) {
msg = "Error: Could not open data source: " + e.Message;
Error (msg);
conn = null;
}
return true;
}
public static void DebugWriteLine (string text)
{
#if DEBUG
Console.WriteLine (text);
Console.Out.Flush ();
#endif // DEBUG
}
public static int Main (string[] args)
{
Application.Init ();
SqlSharpGtk sqlSharp = new SqlSharpGtk ();
sqlSharp.Show ();
Application.Run ();
return 0;
}
}
}