//private static SqlCeDatabase GetDatabase(string generatedNamespace, string connectionString)
//{
// var database = new SqlCeDatabase(generatedNamespace, connectionString);
// database.Verify();
// database.AnalyzeDatabase();
// return database;
//}
public static ISqlCeDatabase GetDatabase(string fileNameSpace, string inputFileName, string password = null)
{
try
{
var fi = new FileInfo(inputFileName);
var generatedNamespace = fileNameSpace + "." +
fi.Name.Replace(fi.Extension, string.Empty).Replace(" ", string.Empty);
var connectionString = GetConnectionString(inputFileName, password);
var database = SqlCeDatabaseFactory.Create(generatedNamespace, connectionString);
database.DatabaseFilename = inputFileName;
database.Verify();
database.AnalyzeDatabase();
return(database);
}
catch (SqlCeException e)
{
if (e.NativeError == 25028 || e.NativeError == 25140 || e.Message.ToLower().Contains("password"))
{
var passwordResult = PromptForPassword();
if (!string.IsNullOrEmpty(passwordResult))
{
return(GetDatabase(fileNameSpace, inputFileName, passwordResult));
}
}
throw;
}
}
public void DatabaseConstructorWithConnectionStringAndNamespaceTest()
{
string defaultNamespace = "SqlCeCodeGenTest";
var target = SqlCeDatabaseFactory.Create(defaultNamespace, connectionString);
Assert.AreEqual(defaultNamespace, target.DefaultNamespace);
}
private static ISqlCeDatabase GetDatabase(string defaultNamespace, string connectionString)
{
var database = SqlCeDatabaseFactory.Create(defaultNamespace, connectionString);
database.AnalyzeDatabase();
return(database);
}
protected static ISqlCeDatabase GetDatabase()
{
var defaultNamespace = typeof(CodeGenTest).Namespace;
const string connectionString = "Data Source=Northwind.sdf;";
return(SqlCeDatabaseFactory.Create(defaultNamespace, connectionString));
}
private void AnalyzeDatabase()
{
Task.Factory.StartNew(() =>
{
try
{
if (!File.Exists(dataSource))
{
throw new InvalidOperationException("Unable to find " + dataSource);
}
Text = "SQL Compact Query Analyzer" + " - " + dataSource;
var fileInfo = new FileInfo(dataSource);
fileInfo.Attributes &= ~FileAttributes.ReadOnly;
database = SqlCeDatabaseFactory.Create(GetConnectionString());
while (!database.VerifyConnectionStringPassword())
{
bool?result = null;
PasswordWindow window = null;
Application.Current.Dispatcher.Invoke((Action) delegate
{
window = new PasswordWindow();
result = window.ShowDialog();
});
if (result != true)
{
return;
}
password = window.Password;
database.ConnectionString = GetConnectionString(4091);
}
AnalyzingTablesIsBusy = true;
var stopwatch = Stopwatch.StartNew();
database.AnalyzeDatabase();
ResultSetMessages = "Analyzed database in " + stopwatch.Elapsed;
stopwatch.Stop();
Application.Current.Dispatcher.Invoke((Action)PopulateTables);
AddRecentFile(dataSource);
}
catch (Exception e)
{
ResultSetErrors = e.ToString();
CurrentResultsTabIndex = 3;
}
finally
{
AnalyzingTablesIsBusy = false;
}
});
}
public void TablesNotNullTest()
{
var target = SqlCeDatabaseFactory.Create(connectionString);
target.AnalyzeDatabase();
Assert.IsNotNull(target.Tables);
CollectionAssert.AllItemsAreNotNull(target.Tables);
}
public void TableNameNotNullTest()
{
var target = SqlCeDatabaseFactory.Create(connectionString);
target.AnalyzeDatabase();
foreach (var table in target.Tables)
{
Assert.IsFalse(string.IsNullOrEmpty(table.Name));
}
}
public void CodeGeneratorFactoryStaticCreateCsharpTest()
{
var defaultNamespace = typeof(CodeGenTest).Namespace;
var connectionString = "Data Source=Northwind.sdf";
var database = SqlCeDatabaseFactory.Create(defaultNamespace, connectionString);
var codeGenerator = CodeGeneratorFactory.Create(database, "CSharp");
Assert.IsNotNull(codeGenerator);
Assert.IsInstanceOfType(codeGenerator, typeof(CodeGenerator));
Assert.IsInstanceOfType(codeGenerator, typeof(CSharpCodeGenerator));
}
public void CodeGeneratorFactoryCreateVisualBasicTest()
{
var defaultNamespace = typeof(CodeGenTest).Namespace;
var connectionString = "Data Source=Northwind.sdf";
var database = SqlCeDatabaseFactory.Create(defaultNamespace, connectionString);
var factory = new CodeGeneratorFactory(database);
var codeGenerator = factory.Create("VB");
Assert.IsNotNull(codeGenerator);
Assert.IsInstanceOfType(codeGenerator, typeof(CodeGenerator));
//Assert.IsInstanceOfType(codeGenerator, typeof(VisualBasicCodeGenerator));
}
public void ColumnsNotNullTest()
{
var target = SqlCeDatabaseFactory.Create(connectionString);
target.AnalyzeDatabase();
foreach (var table in target.Tables)
{
Assert.IsNotNull(table.Columns);
CollectionAssert.AllItemsAreNotNull(table.Columns);
}
}
public void ColumnOrdinalTest()
{
var target = SqlCeDatabaseFactory.Create(connectionString);
target.AnalyzeDatabase();
foreach (var table in target.Tables)
{
foreach (var column in table.Columns)
{
Assert.AreNotEqual(0, column.Value.Ordinal);
}
}
}
public void UnitTestCodeGeneratorFactoryCreateMSTestTest()
{
var defaultNamespace = typeof(CodeGenTest).Namespace;
const string connectionString = "Data Source=Northwind.sdf";
var database = SqlCeDatabaseFactory.Create(defaultNamespace, connectionString);
var factory = new UnitTestCodeGeneratorFactory(database);
var codeGenerator = factory.Create("MSTest");
Assert.IsNotNull(codeGenerator);
Assert.IsInstanceOfType(codeGenerator, typeof(CodeGenerator));
Assert.IsInstanceOfType(codeGenerator, typeof(CSharpCodeGenerator));
Assert.IsInstanceOfType(codeGenerator, typeof(CSharpUnitTestCodeGenerator));
Assert.IsInstanceOfType(codeGenerator, typeof(MSTestUnitTestCodeGenerator));
}
public void IndexColumnNotNullTest()
{
var target = SqlCeDatabaseFactory.Create(connectionString);
target.AnalyzeDatabase();
foreach (var table in target.Tables)
{
foreach (var index in table.Indexes)
{
Assert.IsNotNull(index.Column);
}
}
}
public void ColumnDatabaseTypeNotNullTest()
{
var target = SqlCeDatabaseFactory.Create(connectionString);
target.AnalyzeDatabase();
foreach (var table in target.Tables)
{
foreach (var column in table.Columns)
{
Assert.IsFalse(string.IsNullOrEmpty(column.Value.DatabaseType));
}
}
}
public void ColumnManagedTypeNotNullTest()
{
var target = SqlCeDatabaseFactory.Create(connectionString);
target.AnalyzeDatabase();
foreach (var table in target.Tables)
{
foreach (var column in table.Columns)
{
Assert.IsNotNull(column.Value.ManagedType);
}
}
}
public void Connect(string path)
{
dataSource = path;
if (!File.Exists(dataSource))
{
throw new InvalidOperationException("Unable to find Windows Live Photo Gallery database file:" + dataSource);
}
var connstr = string.Format("Data Source={0}; Password={1};", path, "");
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
database = SqlCeDatabaseFactory.Create(connstr);
stopwatch.Stop();
if (stopwatch.ElapsedMilliseconds > 200)
{
Logger.Info("Connect Compact SQL CE " + stopwatch.ElapsedMilliseconds.ToString());
}
}
public void CreateDatabase()
{
ISqlCeDatabase database = null;
switch (SelectedIndex)
{
case 0:
database = SqlCeDatabaseFactory.Create(SupportedVersions.SqlCe31);
break;
case 1:
database = SqlCeDatabaseFactory.Create(SupportedVersions.SqlCe35);
break;
case 2:
database = SqlCeDatabaseFactory.Create(SupportedVersions.SqlCe40);
break;
}
if (database != null)
{
database.CreateDatabase(Filename, Password, MaxDatabaseSize);
}
}
public void DatabaseConstructorWithConnectionStringTest()
{
var target = SqlCeDatabaseFactory.Create(connectionString);
Assert.AreEqual("SqlCeCodeGen", target.DefaultNamespace);
}
private TreeViewItem GetDatabaseInformationTree()
{
try
{
var fileInfo = new FileInfo(dataSource);
var propertiesNode = new TreeViewItem {
Header = "Database Information"
};
propertiesNode.Selected += OnTreeViewItemSelected;
propertiesNode.Items.Add(new TreeViewItem {
Header = "File name: " + fileInfo.Name
});
propertiesNode.Items.Add(new TreeViewItem {
Header = "Date Created: " + fileInfo.CreationTime
});
propertiesNode.Items.Add(new TreeViewItem {
Header = "Last Modified: " + fileInfo.LastWriteTime
});
propertiesNode.Items.Add(new TreeViewItem {
Header = "Version: " + SqlCeDatabaseFactory.GetRuntimeVersion(dataSource)
});
propertiesNode.Items.Add(new TreeViewItem {
Header = "Password Protected: " + !string.IsNullOrEmpty(password)
});
propertiesNode.Items.Add(new TreeViewItem {
Header = string.Format(new FileSizeFormatProvider(), "File size: {0:fs}", fileInfo.Length)
});
propertiesNode.ExpandSubtree();
var schemaSummaryNode = new TreeViewItem {
Header = "Schema Summary"
};
schemaSummaryNode.Selected += OnTreeViewItemSelected;
schemaSummaryNode.Items.Add(new TreeViewItem {
Header = "Tables: " + database.Tables.Count
});
schemaSummaryNode.Items.Add(new TreeViewItem {
Header = "Columns: " + database.Tables.Sum(c => c.Columns.Count)
});
schemaSummaryNode.Items.Add(new TreeViewItem {
Header = "Primary keys: " + database.Tables.Count(c => !string.IsNullOrEmpty(c.PrimaryKeyColumnName))
});
//schemaSummaryNode.Items.Add(new TreeViewItem { Header = "Foreign keys: " + database.Tables.Sum(c => c.Columns.Where(x => x.Value.IsForeignKey).Count()) });
schemaSummaryNode.Items.Add(new TreeViewItem {
Header = "Identity fields: " + database.Tables.Sum(c => c.Columns.Count(x => x.Value.IdentityIncrement.HasValue))
});
schemaSummaryNode.Items.Add(new TreeViewItem {
Header = "Nullable fields: " + database.Tables.Sum(c => c.Columns.Count(x => x.Value.AllowsNull))
});
propertiesNode.Items.Add(schemaSummaryNode);
var schemaInformationNode = new TreeViewItem {
Header = "Schema Information"
};
schemaInformationNode.Items.Add(CreateSchemaInformationNode("Columns", "INFORMATION_SCHEMA.COLUMNS"));
schemaInformationNode.Items.Add(CreateSchemaInformationNode("Indexes", "INFORMATION_SCHEMA.INDEXES"));
schemaInformationNode.Items.Add(CreateSchemaInformationNode("Key Column Usage", "INFORMATION_SCHEMA.KEY_COLUMN_USAGE"));
schemaInformationNode.Items.Add(CreateSchemaInformationNode("Tables", "INFORMATION_SCHEMA.TABLES"));
schemaInformationNode.Items.Add(CreateSchemaInformationNode("Table Constraints", "INFORMATION_SCHEMA.TABLE_CONSTRAINTS"));
schemaInformationNode.Items.Add(CreateSchemaInformationNode("Provider Types", "INFORMATION_SCHEMA.PROVIDER_TYPES"));
schemaInformationNode.Items.Add(CreateSchemaInformationNode("Referential Constraints", "INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS"));
propertiesNode.Items.Add(schemaInformationNode);
return(propertiesNode);
}
catch (Exception e)
{
Debug.WriteLine(e);
return(new TreeViewItem
{
Header = "Unable to retrieve database information",
FontStyle = FontStyles.Italic
});
}
}
public void AnalyzeDatabaseTest()
{
var target = SqlCeDatabaseFactory.Create(connectionString);
target.AnalyzeDatabase();
}
