private void ShowPlanButton_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrWhiteSpace(SqlText))
{
return;
}
Helpers.DataConnectionHelper.LogUsage("EditorShowPlan");
try
{
using (var repository = Helpers.DataConnectionHelper.CreateRepository(DatabaseInfo))
{
var textBox = new TextBox();
textBox.FontFamily = fontFamiliy;
textBox.FontSize = fontSize;
string sql = GetSqlFromSqlEditorTextBox();
string showPlan = repository.ParseSql(sql);
try
{
TryLaunchSqlplan(showPlan);
}
catch (System.ComponentModel.Win32Exception)
{
EnvDTEHelper.ShowError("This feature requires Visual Studio 2010 Premium / SQL Server Management Studio to be installed");
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLCE35);
}
}
}
catch (Exception sqlException)
{
ParseSqlErrorToResultsBox(Helpers.DataConnectionHelper.CreateEngineHelper(DatabaseInfo.DatabaseType).FormatError(sqlException));
}
}
public void AddCe35Database(object sender, ExecutedRoutedEventArgs e)
{
// http://www.mztools.com/articles/2007/MZ2007011.aspx
if (!Helpers.DataConnectionHelper.DDEXProviderIsInstalled(new Guid(Resources.SqlCompact35Provider)))
{
EnvDTEHelper.ShowError("The version 3.5 Visual Studio DDEX provider is not installed, cannot add connection");
return;
}
try
{
var objIVsDataConnectionDialogFactory = package.GetServiceHelper(typeof(IVsDataConnectionDialogFactory)) as IVsDataConnectionDialogFactory;
var objIVsDataConnectionDialog = objIVsDataConnectionDialogFactory.CreateConnectionDialog();
objIVsDataConnectionDialog.AddAllSources();
objIVsDataConnectionDialog.SelectedSource = new Guid("130BADA6-E128-423c-9D07-02E4734D45D4");
objIVsDataConnectionDialog.SelectedProvider = new Guid(Resources.SqlCompact35Provider);
if (objIVsDataConnectionDialog.ShowDialog() && objIVsDataConnectionDialog.SelectedProvider == new Guid(Resources.SqlCompact35Provider))
{
Helpers.DataConnectionHelper.SaveDataConnection(package, objIVsDataConnectionDialog.EncryptedConnectionString, objIVsDataConnectionDialog.DisplayConnectionString, DatabaseType.SQLCE35, new Guid(Resources.SqlCompact35Provider));
ExplorerControl control = _parentWindow.Content as ExplorerControl;
control.BuildDatabaseTree();
Helpers.DataConnectionHelper.LogUsage("DatabasesAddCe35Database");
}
objIVsDataConnectionDialog.Dispose();
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLCE35);
}
}
private bool SaveSettings()
{
try
{
TableName = this.txtTableDesc.Text;
if (string.IsNullOrEmpty(TableName))
{
EnvDTEHelper.ShowError("Table name is required");
return(false);
}
var validation = TableColumn.ValidateColumns(columns.ToList());
if (!string.IsNullOrEmpty(validation))
{
EnvDTEHelper.ShowError(validation);
return(false);
}
TableColumns = TableColumn.BuildColumns(columns.ToList(), TableName);
PkScript = TableColumn.BuildPkScript(columns.ToList(), TableName);
if (_dbType == DatabaseType.SQLite)
{
PkScript = BuildSQLitePkScript(columns.ToList(), TableName);
}
else
{
PkScript = TableColumn.BuildPkScript(columns.ToList(), TableName);
}
return(true);
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLServer);
}
return(false);
}
private void ResultsetGrid_Load(object sender, EventArgs e)
{
this.tableName = TableName;
try
{
this.dataGridView1.AutoGenerateColumns = true;
this.dataGridView1.DataError += new DataGridViewDataErrorEventHandler(dataGridView1_DataError);
imageContext.Items.Add("Import Image", null, new EventHandler(ImportImage));
imageContext.Items.Add("Export Image", null, new EventHandler(ExportImage));
imageContext.Items.Add("Delete Image", null, new EventHandler(DeleteImage));
LoadData(SqlText);
this.dataGridView1.ReadOnly = ReadOnly;
if (this.ReadOnlyColumns != null)
{
foreach (int x in ReadOnlyColumns)
{
this.dataGridView1.Columns[x].ReadOnly = true;
this.dataGridView1.Columns[x].DefaultCellStyle.ForeColor = SystemColors.GrayText;
}
}
if (Properties.Settings.Default.MultiLineTextEntry)
{
foreach (DataGridViewColumn col in dataGridView1.Columns)
{
if (col is DataGridViewTextBoxColumn)
{
col.DefaultCellStyle.WrapMode = DataGridViewTriState.True;
}
}
this.dataGridView1.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.AllCells;
}
this.bindingNavigatorAddNewItem.Enabled = !ReadOnly;
this.bindingNavigatorDeleteItem.Enabled = !ReadOnly;
this.toolStripButton1.Enabled = !ReadOnly;
this.dataGridView1.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText;
this.dataGridView1.AllowUserToOrderColumns = true;
this.dataGridView1.MultiSelect = false;
//if (Properties.Settings.Default.ShowNullValuesAsNULL)
//{
// this.dataGridView1.DefaultCellStyle.NullValue = "NULL";
//}
this.dataGridView1.KeyDown += new KeyEventHandler(dataGridView1_KeyDown);
//this.dataGridView1.CellContentClick += new DataGridViewCellEventHandler(dataGridView1_CellContentClick);
dgs = new DataGridViewSearch(this.dataGridView1);
if (ReadOnly)
{
this.dataGridView1.DefaultCellStyle.ForeColor = SystemColors.GrayText;
EnvDTEHelper.ShowError("No primary keys on table, data is read-only");
}
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseInfo.DatabaseType, false);
}
}
public void ImportData(object sender, ExecutedRoutedEventArgs e)
{
var menuInfo = ValidateMenuInfo(sender);
if (menuInfo == null)
{
return;
}
try
{
using (var repository = DataConnectionHelper.CreateRepository(menuInfo.DatabaseInfo))
{
var generator = DataConnectionHelper.CreateGenerator(repository, menuInfo.DatabaseInfo.DatabaseType);
var imo = new ImportDialog
{
SampleHeader = generator.GenerateTableColumns(menuInfo.Name),
Separator =
System.Globalization.CultureInfo.CurrentCulture.TextInfo.ListSeparator.ToCharArray()[0]
};
if (imo.ShowModal() != true)
{
return;
}
if (string.IsNullOrWhiteSpace(imo.File) || !System.IO.File.Exists(imo.File))
{
return;
}
using (var reader = new CsvReader(imo.File, Encoding.UTF8))
{
reader.ValueSeparator = imo.Separator;
var hr = reader.ReadHeaderRecord();
if (generator.ValidColumns(menuInfo.Name, hr.Values))
{
var i = 1;
foreach (var record in reader.DataRecords)
{
generator.GenerateTableInsert(menuInfo.Name, hr.Values, record.Values, i);
i++;
}
}
}
OpenSqlEditorToolWindow(menuInfo, generator.GeneratedScript);
DataConnectionHelper.LogUsage("TableImport");
}
}
catch (System.IO.IOException iox)
{
EnvDTEHelper.ShowError(iox.Message);
}
catch (Exception ex)
{
DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType, false);
}
}
public void ReportTableData(object sender, ExecutedRoutedEventArgs e)
{
string sqlText = null;
var menuItem = sender as MenuItem;
var ds = new DataSet();
if (menuItem == null)
{
return;
}
var menuInfo = menuItem.CommandParameter as MenuCommandParameters;
if (menuInfo == null)
{
return;
}
try
{
using (IRepository repository = Helpers.DataConnectionHelper.CreateRepository(menuInfo.DatabaseInfo))
{
sqlText = string.Format(Environment.NewLine + "SELECT * FROM [{0}]", menuInfo.Name)
+ Environment.NewLine + "GO";
ds = repository.ExecuteSql(sqlText);
}
var pkg = ParentWindow.Package as SqlCeToolboxPackage;
Debug.Assert(pkg != null, "Package property of the Explorere Tool Window should never be null, have you tried to create it manually and not through FindToolWindow()?");
string dbName = System.IO.Path.GetFileNameWithoutExtension(menuInfo.DatabaseInfo.Caption);
var window = pkg.CreateWindow <ReportWindow>(Math.Abs(menuInfo.Name.GetHashCode() - dbName.GetHashCode()));
window.Caption = menuInfo.Name + " (" + dbName + ")";
pkg.ShowWindow(window);
var control = window.Content as ReportControl;
control.DatabaseInfo = menuInfo.DatabaseInfo;
control.TableName = menuInfo.Name;
control.DataSet = ds;
control.ShowReport();
DataConnectionHelper.LogUsage("ViewReport");
}
catch (System.IO.FileNotFoundException)
{
EnvDTEHelper.ShowError("Microsoft Report Viewer 2010 not installed, please download and install to use this feature http://www.microsoft.com/en-us/download/details.aspx?id=6442");
return;
}
catch (Exception ex)
{
DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType, false);
}
ds.Dispose();
}
private void TryLaunchSqlplan(string showPlan)
{
if (!string.IsNullOrWhiteSpace(showPlan))
{
if (DatabaseInfo.DatabaseType == DatabaseType.SQLite)
{
var textBox = new TextBox();
textBox.FontFamily = fontFamiliy;
textBox.FontSize = fontSize;
textBox.Text = showPlan;
ClearResults();
this.Resultspanel.Children.Add(textBox);
this.tab1.Visibility = System.Windows.Visibility.Collapsed;
resultsTabControl.SelectedIndex = 1;
}
else
{
var fileName = System.IO.Path.GetTempFileName();
fileName = fileName + ".sqlplan";
System.IO.File.WriteAllText(fileName, showPlan);
// If Data Dude is available
var pkg = _parentWindow.Package as SqlCeToolboxPackage;
if (pkg.VSSupportsSqlPlan())
{
dte.ItemOperations.OpenFile(fileName);
dte.ActiveDocument.Activate();
}
else
{
// Just try to start SSMS
using (RegistryKey rkRoot = Registry.ClassesRoot)
{
RegistryKey rkFileType = rkRoot.OpenSubKey(".sqlplan");
if (rkFileType != null)
{
System.Diagnostics.Process.Start(fileName);
}
else
{
EnvDTEHelper.ShowError("No application that can open .sqlplan files is installed, you could install SSMS 2012 SP1 Express");
}
}
}
}
}
}
public void CheckCeVersion(object sender, ExecutedRoutedEventArgs e)
{
var helper = Helpers.DataConnectionHelper.CreateEngineHelper(DatabaseType.SQLCE40);
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = DataConnectionHelper.GetSqlCeFileFilter();
ofd.CheckFileExists = true;
ofd.Multiselect = false;
ofd.ValidateNames = true;
if (ofd.ShowDialog() == true)
{
try
{
var sdfVersion = helper.DetermineVersion(ofd.FileName);
string found = "Unknown";
switch (sdfVersion)
{
case SQLCEVersion.SQLCE20:
found = "2.0";
break;
case SQLCEVersion.SQLCE30:
found = "3.0/3.1";
break;
case SQLCEVersion.SQLCE35:
found = "3.5";
break;
case SQLCEVersion.SQLCE40:
found = "4.0";
break;
default:
break;
}
EnvDTEHelper.ShowMessage(string.Format("{0} is SQL Server Compact version {1}", Path.GetFileName(ofd.FileName), found));
Helpers.DataConnectionHelper.LogUsage("DatabaseVersionDetect");
}
catch (Exception ex)
{
EnvDTEHelper.ShowError(ex.Message);
}
}
}
public void ModifyColumn(object sender, ExecutedRoutedEventArgs e)
{
var menuItem = sender as MenuItem;
if (menuItem == null)
{
return;
}
var menuInfo = menuItem.CommandParameter as MenuCommandParameters;
if (menuInfo == null)
{
return;
}
try
{
using (IRepository repository = Helpers.DataConnectionHelper.CreateRepository(menuInfo.DatabaseInfo))
{
var generator = Helpers.DataConnectionHelper.CreateGenerator(repository, menuInfo.DatabaseInfo.DatabaseType);
List <Column> columns = repository.GetAllColumns();
var col = columns.SingleOrDefault(c => c.TableName == menuInfo.Description && c.ColumnName == menuInfo.Name);
if (col == null)
{
EnvDTEHelper.ShowError("Could not find the column in the table, has it been dropped?");
return;
}
TableBuilderDialog tbd = new TableBuilderDialog(menuInfo.Description, menuInfo.DatabaseInfo.DatabaseType);
tbd.TableColumns = new List <Column> {
col
};
tbd.Mode = 2;
if (tbd.ShowModal() == true && tbd.TableColumns.Count == 1)
{
generator.GenerateColumnAlterScript(tbd.TableColumns[0]);
var script = generator.GeneratedScript.ToString();
OpenSqlEditorToolWindow(menuInfo, script);
Helpers.DataConnectionHelper.LogUsage("TableBuildColumnEdit");
}
}
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType);
}
}
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
if (cmbColumns.SelectedIndex == -1)
{
EnvDTEHelper.ShowError("Please select a column");
return;
}
if (string.IsNullOrEmpty(dataSourceTextBox.Text))
{
EnvDTEHelper.ShowError("Please enter an index name");
return;
}
newIndex.IndexName = dataSourceTextBox.Text;
newIndex.ColumnName = cmbColumns.SelectedItem.ToString();
newIndex.TableName = _tableName;
newIndex.Unique = chkUnique.IsChecked.Value;
this.DialogResult = true;
Close();
}
public void ScriptAsCreate(object sender, ExecutedRoutedEventArgs e)
{
var menuItem = sender as MenuItem;
if (menuItem == null)
{
return;
}
var menuInfo = menuItem.CommandParameter as MenuCommandParameters;
if (menuInfo == null)
{
return;
}
try
{
using (IRepository repository = Helpers.DataConnectionHelper.CreateRepository(menuInfo.DatabaseInfo))
{
var generator = Helpers.DataConnectionHelper.CreateGenerator(repository, menuInfo.DatabaseInfo.DatabaseType);
List <Column> columns = repository.GetAllColumns();
var col = columns.SingleOrDefault(c => c.TableName == menuInfo.Description && c.ColumnName == menuInfo.Name);
if (col == null)
{
EnvDTEHelper.ShowError("Could not find the column in the table, has it been dropped?");
return;
}
else
{
generator.GenerateColumnAddScript(col);
}
OpenSqlEditorToolWindow(menuInfo, generator.GeneratedScript);
Helpers.DataConnectionHelper.LogUsage("ColumnScriptAsCreate");
}
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType, false);
}
}
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(dataSourceTextBox.Text))
{
EnvDTEHelper.ShowError("Please enter a foreign key name");
return;
}
if (cmbFkColumn.SelectedIndex == -1)
{
EnvDTEHelper.ShowError("Please select a foreign key column");
return;
}
if (cmbPrimaryKeyTableAndColumn.SelectedIndex == -1)
{
EnvDTEHelper.ShowError("Please select a primary key");
return;
}
newKey.ColumnName = cmbFkColumn.SelectedItem.ToString();
newKey.Columns = new ColumnList {
cmbFkColumn.SelectedItem.ToString()
};
newKey.ConstraintName = dataSourceTextBox.Text;
newKey.ConstraintTableName = _tableName;
newKey.DeleteRule = cmbDeleteAction.SelectedItem.ToString();
newKey.UpdateRule = cmbUpdateAction.SelectedItem.ToString();
PrimaryKey pk = (PrimaryKey)cmbPrimaryKeyTableAndColumn.SelectedValue;
newKey.UniqueColumns = new ColumnList {
pk.ColumnName
};
newKey.UniqueConstraintTableName = pk.TableName;
this.DialogResult = true;
Close();
}
public void SyncFxGenerateLocalDatabaseCacheCode(object sender, ExecutedRoutedEventArgs e)
{
// http://www.mztools.com/articles/2007/MZ2007011.aspx
var menuItem = sender as MenuItem;
if (menuItem == null)
{
return;
}
Scope scope = (Scope)menuItem.Tag;
var dte = package.GetServiceHelper(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
var dteH = new Helpers.EnvDTEHelper();
var project = dteH.GetProject(dte);
if (project == null)
{
EnvDTEHelper.ShowError("Please select a project in Solution Explorer, where you want the SyncFx classes to be placed");
return;
}
if (!dteH.AllowedProjectKinds.Contains(new Guid(project.Kind)))
{
EnvDTEHelper.ShowError("The selected project type does not support Sync Framework (please let me know if I am wrong)");
return;
}
if (project.CodeModel.Language != CodeModelLanguageConstants.vsCMLanguageCSharp)
{
EnvDTEHelper.ShowError("Unsupported code language, only C# is currently supported");
return;
}
if (project.Properties.Item("TargetFrameworkMoniker") == null)
{
EnvDTEHelper.ShowError("The selected project type does not support Sync Framework - missing TargetFrameworkMoniker");
return;
}
if (!project.Properties.Item("TargetFrameworkMoniker").Value.ToString().Contains(".NETFramework"))
{
EnvDTEHelper.ShowError("The selected project type does not support .NET Desktop - wrong TargetFrameworkMoniker: " + project.Properties.Item("TargetFrameworkMoniker").Value.ToString());
return;
}
try
{
string serverConnectionString = DataConnectionHelper.PromptForConnectionString(package);
if (!string.IsNullOrEmpty(serverConnectionString))
{
string clientConnectionString = string.Empty;
//grab target SQL CE Database
var dialog = new ConnectionDialog();
dialog.DbType = DatabaseType.SQLCE35;
bool?result = dialog.ShowModal();
if (result.HasValue && result.Value == true && !string.IsNullOrWhiteSpace(dialog.ConnectionString))
{
clientConnectionString = dialog.ConnectionString;
}
else
{
return;
}
string model = string.Empty;
SyncFxDialog sfd = new SyncFxDialog();
int totalCount = 0;
var databaseInfo = new DatabaseMenuCommandParameters
{
DatabaseInfo = new DatabaseInfo
{
ConnectionString = serverConnectionString,
DatabaseType = DatabaseType.SQLServer
}
};
totalCount = SyncFxGetObjectsForSync(sfd, databaseInfo);
sfd.ModelName = model;
bool?res = sfd.ShowModal();
if (res.HasValue && res.Value == true && (sfd.Tables.Count > 0) && !string.IsNullOrWhiteSpace(sfd.ModelName))
{
model = sfd.ModelName;
var defaultNamespace = project.Properties.Item("DefaultNamespace").Value.ToString();
var columns = sfd.Columns.Where(c => sfd.Tables.Contains(c.TableName)).ToList();
var classes = new SyncFxHelper().GenerateCodeForScope(serverConnectionString, clientConnectionString, "SQL", model, columns, defaultNamespace);
var projectPath = project.Properties.Item("FullPath").Value.ToString();
foreach (var item in classes)
{
string fileName = Path.Combine(projectPath, item.Key + ".cs");
if (File.Exists(fileName))
{
File.Delete(fileName);
}
File.WriteAllText(fileName, item.Value);
project.ProjectItems.AddFromFile(fileName);
}
//Adding references - http://blogs.msdn.com/b/murat/archive/2008/07/30/envdte-adding-a-refernce-to-a-project.aspx
EnvDTEHelper.AddReference(project, "System.Data.SqlServerCe, Version=3.5.1.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91");
EnvDTEHelper.AddReference(project, "Microsoft.Synchronization, Version=2.1.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91");
EnvDTEHelper.AddReference(project, "Microsoft.Synchronization.Data, Version=3.1.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91");
EnvDTEHelper.AddReference(project, "Microsoft.Synchronization.Data.SqlServer, Version=3.1.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91");
EnvDTEHelper.AddReference(project, "Microsoft.Synchronization.Data.SqlServerCe, Version=3.1.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91");
EnvDTEHelper.ShowMessage("Scope: " + model + " code generated.");
Helpers.DataConnectionHelper.LogUsage("DatabasesSyncAddLocalDBCache");
}
}
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLServer);
}
}
public void EditTableData(object sender, ExecutedRoutedEventArgs e)
{
string sqlText = null;
var menuInfo = ValidateMenuInfo(sender);
if (menuInfo == null)
{
return;
}
bool dbProviderPresent = menuInfo.DatabaseInfo.DatabaseType == DatabaseType.SQLCE35 && Helpers.DataConnectionHelper.IsV35DbProviderInstalled();
if (menuInfo.DatabaseInfo.DatabaseType == DatabaseType.SQLCE40 && Helpers.DataConnectionHelper.IsV40DbProviderInstalled())
{
dbProviderPresent = true;
}
if (menuInfo.DatabaseInfo.DatabaseType == DatabaseType.SQLite)
{
dbProviderPresent = true;
}
if (!dbProviderPresent)
{
EnvDTEHelper.ShowError("The required DbProvider registration is not present, please re-install/repair the SQL Server Compact runtime");
return;
}
try
{
bool readOnly = false;
List <int> readOnlyColumns = new List <int>();
using (IRepository repository = Helpers.DataConnectionHelper.CreateRepository(menuInfo.DatabaseInfo))
{
List <PrimaryKey> pks = repository.GetAllPrimaryKeys();
var tpks = repository.GetAllPrimaryKeys().Where(pk => pk.TableName == menuInfo.Name).ToList();
if (tpks.Count == 0)
{
readOnly = true;
}
List <Column> cols = repository.GetAllColumns();
cols = cols.Where(c => c.TableName == menuInfo.Name).ToList();
int x = 0;
foreach (Column col in cols)
{
if (col.AutoIncrementBy > 0 || col.RowGuidCol)
{
readOnlyColumns.Add(x);
}
x++;
}
var generator = Helpers.DataConnectionHelper.CreateGenerator(repository, menuInfo.DatabaseInfo.DatabaseType);
generator.GenerateTableSelect(menuInfo.Name);
sqlText = generator.GeneratedScript.Replace(";" + Environment.NewLine + "GO", "");
sqlText = sqlText.Replace(";" + Environment.NewLine, "");
if (menuInfo.DatabaseInfo.DatabaseType == DatabaseType.SQLite)
{
sqlText = sqlText + string.Format(" LIMIT {0}", Properties.Settings.Default.MaxRowsToEdit);
}
else
{
sqlText = sqlText.Replace(Environment.NewLine + "SELECT ", string.Format(Environment.NewLine + "SELECT TOP({0}) ", Properties.Settings.Default.MaxRowsToEdit));
}
}
var pkg = ParentWindow.Package as SqlCeToolboxPackage;
Debug.Assert(pkg != null, "Package property of the Explorere Tool Window should never be null, have you tried to create it manually and not through FindToolWindow()?");
string dbName = System.IO.Path.GetFileNameWithoutExtension(menuInfo.DatabaseInfo.Caption);
var window = pkg.CreateWindow <DataGridViewWindow>(Math.Abs(menuInfo.Name.GetHashCode() - dbName.GetHashCode()));
window.Caption = menuInfo.Name + " (" + dbName + ")";
pkg.ShowWindow(window);
var control = window.Content as DataEditControl;
control.DatabaseInfo = menuInfo.DatabaseInfo;
control.TableName = menuInfo.Name;
control.ReadOnly = readOnly;
control.ReadOnlyColumns = readOnlyColumns;
control.SqlText = sqlText;
control.ShowGrid();
DataConnectionHelper.LogUsage("TableEdit");
}
catch (Exception ex)
{
DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType, false);
}
}
public void GenerateDataDiffScript(object sender, ExecutedRoutedEventArgs e)
{
try
{
var menuInfo = ValidateMenuInfo(sender);
var package = ParentWindow.Package as SqlCeToolboxPackage;
if (menuInfo == null)
{
return;
}
Dictionary <string, DatabaseInfo> databaseList = Helpers.DataConnectionHelper.GetDataConnections(package, true, false);
foreach (KeyValuePair <string, DatabaseInfo> info in Helpers.DataConnectionHelper.GetOwnDataConnections())
{
if (!databaseList.ContainsKey(info.Key))
{
databaseList.Add(info.Key, info.Value);
}
}
foreach (KeyValuePair <string, DatabaseInfo> info in databaseList)
{
string sourceType = string.Empty;
switch (info.Value.DatabaseType)
{
case DatabaseType.SQLCE35:
sourceType = "3.5";
break;
case DatabaseType.SQLCE40:
sourceType = "4.0";
break;
case DatabaseType.SQLServer:
sourceType = "Server";
break;
}
info.Value.Caption = string.Format("{0} ({1})", info.Value.Caption, sourceType);
}
CompareDialog cd = new CompareDialog(menuInfo.DatabaseInfo.Caption, databaseList, menuInfo.Name);
bool?result = cd.ShowModal();
if (result.HasValue && result.Value == true && (cd.TargetDatabase.Key != null))
{
var target = cd.TargetDatabase;
var source = new KeyValuePair <string, DatabaseInfo>(menuInfo.DatabaseInfo.ConnectionString, menuInfo.DatabaseInfo);
var editorTarget = target;
if (editorTarget.Value.DatabaseType == DatabaseType.SQLServer)
{
editorTarget = source;
}
using (IRepository sourceRepository = Helpers.DataConnectionHelper.CreateRepository(source.Value))
{
using (IRepository targetRepository = Helpers.DataConnectionHelper.CreateRepository(target.Value))
{
var generator = Helpers.DataConnectionHelper.CreateGenerator(targetRepository, target.Value.DatabaseType);
try
{
var script = SqlCeDiff.CreateDataDiffScript(sourceRepository, menuInfo.Name, targetRepository, menuInfo.Name, generator);
var sqlEditorWindow = package.CreateWindow <SqlEditorWindow>();
var editorControl = sqlEditorWindow.Content as SqlEditorControl;
editorControl.ExplorerControl = ParentWindow.Content as ExplorerControl;
Debug.Assert(editorControl != null);
editorControl.DatabaseInfo = editorTarget.Value;
editorControl.SqlText = script;
Helpers.DataConnectionHelper.LogUsage("TableScriptDataDiff");
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, source.Value.DatabaseType, false);
}
}
}
}
}
catch (ArgumentException ae)
{
EnvDTEHelper.ShowError(ae.Message);
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLCE35, false);
}
}
