public void MultiRSSqlCE()
{
if (File.Exists("Test.sdf"))
File.Delete("Test.sdf");
var cnnStr = "Data Source = Test.sdf;";
var engine = new SqlCeEngine(cnnStr);
engine.CreateDatabase();
using (var cnn = new SqlCeConnection(cnnStr))
{
cnn.Open();
cnn.Execute("create table Posts (ID int, Title nvarchar(50), Body nvarchar(50), AuthorID int)");
cnn.Execute("create table Authors (ID int, Name nvarchar(50))");
cnn.Execute("insert Posts values (1,'title','body',1)");
cnn.Execute("insert Posts values(2,'title2','body2',null)");
cnn.Execute("insert Authors values(1,'sam')");
var data = cnn.Query<PostCE, AuthorCE, PostCE>(@"select * from Posts p left join Authors a on a.ID = p.AuthorID", (post, author) => { post.Author = author; return post; }).ToList();
var firstPost = data.First();
firstPost.Title.IsEqualTo("title");
firstPost.Author.Name.IsEqualTo("sam");
data[1].Author.IsNull();
cnn.Close();
}
}
public virtual void Initialize()
{
TestHelper.SetupLog4NetForTests();
TestHelper.InitializeContentDirectories();
Path = TestHelper.CurrentAssemblyDirectory;
AppDomain.CurrentDomain.SetData("DataDirectory", Path);
Resolution.Freeze();
//Delete database file before continueing
string filePath = string.Concat(Path, "\\UmbracoPetaPocoTests.sdf");
if (File.Exists(filePath))
{
File.Delete(filePath);
}
//Get the connectionstring settings from config
var settings = ConfigurationManager.ConnectionStrings[Core.Configuration.GlobalSettings.UmbracoConnectionName];
//Create the Sql CE database
var engine = new SqlCeEngine(settings.ConnectionString);
engine.CreateDatabase();
SqlSyntaxContext.SqlSyntaxProvider = SqlCeSyntax.Provider;
}
private void btnconectar_Click(object sender, EventArgs e)
{
string baseDados = Application.StartupPath + @"\db\DBSQLServer.sdf"; // caminho do BD
string strConnection = @"DataSource = " + baseDados + "; Password = '******'";
SqlCeEngine db = new SqlCeEngine(strConnection);
if (!File.Exists(baseDados))
{
db.CreateDatabase();
}
db.Dispose();
SqlCeConnection conexao = new SqlCeConnection(strConnection);
try
{
conexao.Open();
resultado.Text = "Banco de Dados Conectado";
}
catch (Exception ex)
{
resultado.Text = "ERRO, não conectado! \n" + ex;
}
finally
{
conexao.Close();
}
}
public static SqlCeConnection CreateDBConnection()
{
if (!File.Exists(Path.Combine(Application.StartupPath, "db.sdf")))
{
using (SqlCeEngine eng = new SqlCeEngine(dbPath))
eng.CreateDatabase();
using (SqlCeConnection conn = new SqlCeConnection(dbPath))
{
conn.Open();
using (SqlCeCommand cmd = conn.CreateCommand())
{
cmd.CommandText = "CREATE TABLE [Beatmaps] " +
"(" +
"[Hash] nvarchar(32) NOT NULL, " +
"[Filename] nvarchar(500) NOT NULL" +
")";
cmd.ExecuteNonQuery();
cmd.CommandText = "ALTER TABLE [Beatmaps] ADD CONSTRAINT [PK_Beatmaps] PRIMARY KEY ([Hash]) ";
cmd.ExecuteNonQuery();
}
}
}
return new SqlCeConnection(dbPath);
}
private void CreateDirectories()
{
// public static string conString = @"Data Source=C:\transporter\wimea.sdf;Password=wimea; Persist Security Info=True;";
string path = @"c:\amMessage";
if (Directory.Exists(path))
{
return;
}
// Try to create the directory.
DirectoryInfo di = Directory.CreateDirectory(path);
string paths = @"c:\amMessage\images";
if (Directory.Exists(paths))
{
return;
}
// Try to create the directory.
DirectoryInfo dim = Directory.CreateDirectory(paths);
Console.WriteLine("The directory was created successfully at {0}.",
Directory.GetCreationTime(paths));
string con;
con = string.Format(@"Data Source=C:\amMessage\amMessage.sdf;Password=access; Persist Security Info=True;");
SqlCeEngine en = new SqlCeEngine(con);
en.CreateDatabase();
}
public string GetConnectionString(string appName = null)
{
if (_c.ConnectionString != string.Empty)
{
return(_c.ConnectionString);
}
var file = new FileInfo(_c.File == string.Empty ? _c.Database : _c.File);
var cs = _c.ConnectionString = new SqlCeConnectionStringBuilder {
DataSource = file.FullName,
Password = _c.Password
}.ConnectionString;
// not sure if this is the right place to do this, probably isn't...
if (file.Exists)
{
return(cs);
}
using (var engine = new SqlCeEngine(cs)) {
engine.CreateDatabase();
}
return(cs);
}
//@Brief Crea una BD
public bool CreateDB()
{
// delete if exists
try
{
System.IO.File.Delete(m_sqlDB);
}
catch (Exception)
{
// Already exists. Cannot delete.
return(false);
}
// create blank DB
try
{
SqlCeEngine engine = new SqlCeEngine(m_sqlConnectionString);
engine.CreateDatabase();
}
catch (Exception)
{
// Cannot create database
return(false);
}
return(true);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Creates SQL Server CE database using specified file path.
/// Executes SQL script using specified script value if not null.
/// </summary>
/// <param name="path">
/// Database file path.
/// </param>
/// <param name="createScript">
/// Transact SQL script to execute. Optional (can be null).
/// Provided script must conform to SQL Server CE.
/// </param>
public static void CreateDatabase(string path, string createScript)
{
Debug.Assert(path != null);
bool dbCreated = false;
try
{
// check if specified file exists
if (File.Exists(path))
throw new DataException(Properties.Messages.Error_DbFileExists);
// build connection string
string connStr = DatabaseHelper.BuildSqlConnString(path, false);
// create database
SqlCeEngine engine = new SqlCeEngine(connStr);
engine.CreateDatabase();
dbCreated = true;
// execute SQL script
if (createScript != null)
ExecuteScript(connStr, createScript, null);
}
catch (Exception e)
{
Logger.Error(e);
if (dbCreated)
DeleteDatabase(path);
throw;
}
}
public static void CreateDatabaseIfRequired(string connection, string applicationName)
{
string dataDirectory = AppDomain.CurrentDomain.GetData("DataDirectory") as string;
string physConnectionString = connection.Replace("|DataDirectory|" + System.IO.Path.DirectorySeparatorChar, dataDirectory + System.IO.Path.DirectorySeparatorChar);
physConnectionString = physConnectionString.Replace("|DataDirectory|", dataDirectory + System.IO.Path.DirectorySeparatorChar);
string sdfPath = string.Empty;
lock (_lock)
{
SqlCeConnectionStringBuilder builder = new SqlCeConnectionStringBuilder();
builder.ConnectionString = physConnectionString;
sdfPath = builder.DataSource;
if (string.IsNullOrWhiteSpace(sdfPath))
return;
if (!System.IO.File.Exists(sdfPath))
{
//OK, try to create the database file
using (var engine = new SqlCeEngine(connection))
{
engine.CreateDatabase();
}
}
ValidateDatabase(connection, applicationName);
}
}
private void SetupSqlCe(string path, ILogger logger)
{
var dbName = string.Concat("Umb", Guid.NewGuid(), ".sdf");
AppDomain.CurrentDomain.SetData("DataDirectory", path);
var sqlCeConnectionString = $"Datasource=|DataDirectory|\\{dbName};Flush Interval=1;";
_dbFile = Path.Combine(path, dbName);
//only create the db one time
if (_initDbBytes == null)
{
using (var engine = new SqlCeEngine(sqlCeConnectionString))
{
engine.CreateDatabase();
}
//use the db to create the initial schema so we can reuse in each bench
using (_dbSqlCe = GetSqlCeDatabase(sqlCeConnectionString, logger))
{
var creation = new DatabaseSchemaCreator(_dbSqlCe, logger);
creation.InitializeDatabaseSchema();
}
_initDbBytes = File.ReadAllBytes(_dbFile);
}
else
{
File.WriteAllBytes(_dbFile, _initDbBytes);
}
//create the db
_dbSqlCe = GetSqlCeDatabase(sqlCeConnectionString, logger);
}
public static bool existe_db()
{
msj = null;
try
{
if (!System.IO.File.Exists(System.IO.Directory.GetCurrentDirectory() + "\\DB.sdf"))
{
string connectionString = ConfigurationManager.ConnectionStrings["RSSFeed.Properties.Settings.DBConnectionString"].ConnectionString;
SqlCeEngine en = new SqlCeEngine(connectionString);
en.CreateDatabase();
var conexion = new SqlCeConnection(connectionString);
conexion.Open();
var ruta = System.IO.Directory.GetCurrentDirectory() + "DBCreation.sql";
var contenido = System.IO.File.ReadAllText(ruta);
var comando = new SqlCeCommand(contenido, conexion);
comando.ExecuteNonQuery();
conexion.Close();
en.Dispose();
return(true);
}
else
{
return(false);
}
}
catch (Exception f)
{
msj = f;
}
return(false);
}
public void MultiRSSqlCE()
{
if (File.Exists("Test.DB.sdf"))
{
File.Delete("Test.DB.sdf");
}
const string cnnStr = "Data Source = Test.DB.sdf;";
var engine = new SqlCeEngine(cnnStr);
engine.CreateDatabase();
using (var cnn = new SqlCeConnection(cnnStr))
{
cnn.Open();
cnn.Execute("create table Posts (ID int, Title nvarchar(50), Body nvarchar(50), AuthorID int)");
cnn.Execute("create table Authors (ID int, Name nvarchar(50))");
cnn.Execute("insert Posts values (1,'title','body',1)");
cnn.Execute("insert Posts values(2,'title2','body2',null)");
cnn.Execute("insert Authors values(1,'sam')");
var data = cnn.Query <PostCE, AuthorCE, PostCE>("select * from Posts p left join Authors a on a.ID = p.AuthorID", (post, author) => { post.Author = author; return(post); }).ToList();
var firstPost = data[0];
Assert.Equal("title", firstPost.Title);
Assert.Equal("sam", firstPost.Author.Name);
Assert.Null(data[1].Author);
}
}
//=======================================
//criar um metodo ára criar o DB
public static void CriarBaseDados()
{
//nosso motor
SqlCeEngine motor = new SqlCeEngine("Data source = " + base_dados); //fonte DB = local da pasta \+dados.sdf
motor.CreateDatabase(); //entao cria uma stancia desse objeto que é o motor
//criar extrutura da base de dados
SqlCeConnection ligacao = new SqlCeConnection(); //essa conextionstring poderia ser digitada diretamente aqui
ligacao.ConnectionString = "Data source = " + base_dados;
//abrir
ligacao.Open();
//comando
SqlCeCommand comando = new SqlCeCommand(); //commandtext poderia ser digitado diretamente aqui//comando de criação tabela
comando.CommandText =
"CREATE TABLE contatos(" +
"id_contato int not null primary key, "+
"nome nvarchar(50), "+
"telefone nvarchar(20), "+
"atualizacao datetime)";
//conexao
comando.Connection = ligacao;
comando.ExecuteNonQuery();
//uma query que nao devolve resultado apenas vai executar comando dentro da DB
comando.Dispose();
ligacao.Dispose(); //eliminar lixo de memoria restado
}
/// <summary>
/// Creates a <c>SqlCe</c> file database named after <typeparamref name="T"/>, returning the connection string to the database.
/// </summary>
/// <typeparam name="T">The type to create a database for (used in file naming)</typeparam>
/// <param name="deleteIfExists">Whether to delete the existing database (if present)</param>
/// <param name="sqlToExecute">The SQL to run after creating a database</param>
public static string CreateSqlCeDatabase <T>(bool deleteIfExists = false, string[] sqlToExecute = null)
{
var filename = GetSqlCeFileNameFor <T>();
var connString = GetSqlCeConnectionStringFor <T>();
if (File.Exists(filename))
{
if (deleteIfExists)
{
File.Delete(filename);
}
else
{
return(connString);
}
}
var engine = new SqlCeEngine(connString);
engine.CreateDatabase();
if (sqlToExecute != null)
{
foreach (var statement in sqlToExecute)
{
using (var conn = GetOpenSqlCeConnection <T>())
{
conn.Execute(statement);
}
}
}
return(connString);
}
public Boolean Connect(ServerInfo sinfo)
{
//seems like both sqlite and sqlce don't like the word database...
WorkDirectory wd = new WorkDirectory(sinfo);
String path = wd.GetFullPath(sinfo.dbInfo.sqldb);
String conString = "data source=" + path + ";";
if (!File.Exists(path))
{
using(SqlCeEngine engine = new SqlCeEngine(conString))
{
engine.CreateDatabase();
}
}
sqlceConnection = new SqlCeConnection(conString);
try
{
sqlceConnection.Open();
}
catch (Exception e)
{
Console.WriteLine("Connection error: " + e.Message);
return false;
}
return true;
}
public void Can_Assert_Created_Database()
{
string path = TestHelper.CurrentAssemblyDirectory;
AppDomain.CurrentDomain.SetData("DataDirectory", path);
//Delete database file before continueing
string filePath = string.Concat(path, "\\UmbracoPetaPocoTests.sdf");
if (File.Exists(filePath))
{
File.Delete(filePath);
}
//Get the connectionstring settings from config
var settings = ConfigurationManager.ConnectionStrings[Core.Configuration.GlobalSettings.UmbracoConnectionName];
//Create the Sql CE database
var engine = new SqlCeEngine(settings.ConnectionString);
engine.CreateDatabase();
SqlSyntaxContext.SqlSyntaxProvider = SqlCeSyntax.Provider;
//Create the umbraco database
_dbContext.Database.CreateDatabaseSchema(false);
bool umbracoNodeTable = _dbContext.Database.TableExist("umbracoNode");
bool umbracoUserTable = _dbContext.Database.TableExist("umbracoUser");
bool cmsTagsTable = _dbContext.Database.TableExist("cmsTags");
Assert.That(umbracoNodeTable, Is.True);
Assert.That(umbracoUserTable, Is.True);
Assert.That(cmsTagsTable, Is.True);
}
public void CreateDatabase(string connectionString)
{
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
{
engine.CreateDatabase();
}
}
public SqlCERepository(string basePath, string tableName)
{
// create directory
if (!Directory.Exists(basePath))
{
Directory.CreateDirectory(basePath);
}
if (string.IsNullOrEmpty(tableName))
{
tableName = typeof(T).Name;
}
this.Table = tableName;
// assign file paths
dataFile = Path.Combine(basePath, String.Format(@"{0}.sdf", tableName));
if (!File.Exists(dataFile))
{
var engine = new SqlCeEngine(ConnectionString);
engine.CreateDatabase();
CreateTable();
}
}
public void TestFixtureSetup()
{
// Initialize the database.
if (File.Exists("Test.sdf")) {
File.Delete("Test.sdf");
}
using (var engine = new SqlCeEngine(ConfigurationManager.ConnectionStrings["Test"].ConnectionString)) {
engine.CreateDatabase();
}
using (var conn = new SqlCeConnection(ConfigurationManager.ConnectionStrings["Test"].ConnectionString)) {
var cmd = conn.CreateCommand();
conn.Open();
cmd.CommandText = "create table Users (Id int identity, Name nvarchar(250))";
cmd.ExecuteNonQuery();
cmd.CommandText = "create table ManualIdUser (Id int, Name nvarchar(250))";
cmd.ExecuteNonQuery();
cmd.CommandText =
"create table CompositeKeyUser (Id int not null, Id2 nvarchar(250) not null, Name nvarchar(250), primary key (Id, Id2)) ";
cmd.ExecuteNonQuery();
}
}
public static void CreateDatabaseIfRequired(string connection, string applicationName)
{
lock (_lock)
{
SqlCeConnectionStringBuilder builder = new SqlCeConnectionStringBuilder();
builder.ConnectionString = connection;
string sdfPath = ReplaceDataDirectory(builder.DataSource);
if (string.IsNullOrWhiteSpace(sdfPath))
return;
if (!System.IO.File.Exists(sdfPath))
{
//OK, try to create the database file
using (var engine = new SqlCeEngine(connection))
{
engine.CreateDatabase();
}
Util.ExecuteSqlUpgradeScript(GalleryDataSchemaUpgradeScript.SqlCeInstallScript);
}
ValidateDatabase(connection, applicationName);
}
}
public override void Initialize(string name, NameValueCollection config)
{
try
{
// Initialize connection string.
string path = config["path"];
if (string.IsNullOrEmpty(path))
path = "~/App_Data/DynamicImage/DynamicImageCache.sdf";
string absolutePath = HttpContext.Current.Server.MapPath(path);
if (!Directory.Exists(Path.GetDirectoryName(absolutePath)))
Directory.CreateDirectory(Path.GetDirectoryName(absolutePath));
_connectionString = string.Format("Data Source={0}", absolutePath);
if (!File.Exists(absolutePath))
{
using (SqlCeEngine en = new SqlCeEngine(_connectionString))
en.CreateDatabase();
UseConnection(conn =>
{
using (DbCommand comm = conn.CreateCommand())
{
// Create the Version table if it doesn't already exist.
comm.CommandText = "CREATE TABLE Version (VersionNumber INT)";
comm.ExecuteNonQuery();
}
});
}
}
catch (Exception ex)
{
throw new ConfigurationErrorsException("Could not initialize connection string.", ex);
}
base.Initialize(name, config);
}
private void SetupSqlCeDatabase(string connectionString)
{
this.SetupOrmConfiguration(SqlDialect.MsSql);
connectionString = string.Format(
CultureInfo.InvariantCulture,
connectionString,
Path.Combine(Path.GetDirectoryName(typeof(DatabaseSteps).Assembly.Location), $"{DatabaseName}.sdf"));
// create the database
using (var sqlCeEngine = new SqlCeEngine(connectionString))
{
sqlCeEngine.CreateDatabase();
}
_testContext.DatabaseConnection = new SqlCeConnection(connectionString);
_testContext.DatabaseConnection.Open();
using (var command = _testContext.DatabaseConnection.CreateCommand())
{
command.CommandText = @"CREATE TABLE [SimpleBenchmarkEntities](
[Id] [int] IDENTITY(2,1) PRIMARY KEY,
[FirstName] [nvarchar](50) NULL,
[LastName] [nvarchar](50) NOT NULL,
[DateOfBirth] [datetime] NULL
)";
command.ExecuteNonQuery();
}
}
public override void Initialize()
{
TestHelper.SetupLog4NetForTests();
TestHelper.InitializeContentDirectories();
string path = TestHelper.CurrentAssemblyDirectory;
AppDomain.CurrentDomain.SetData("DataDirectory", path);
//Delete database file before continueing
string filePath = string.Concat(path, "\\test.sdf");
if (File.Exists(filePath))
{
File.Delete(filePath);
}
//Create the Sql CE database
var engine = new SqlCeEngine("Datasource=|DataDirectory|test.sdf");
engine.CreateDatabase();
RepositoryResolver.Current = new RepositoryResolver(
new RepositoryFactory());
Resolution.Freeze();
ApplicationContext.Current = new ApplicationContext(
//assign the db context
new DatabaseContext(new DefaultDatabaseFactory()),
//assign the service context
new ServiceContext(new PetaPocoUnitOfWorkProvider(), new FileUnitOfWorkProvider(), new PublishingStrategy())) { IsReady = true };
SqlSyntaxContext.SqlSyntaxProvider = SqlCeSyntax.Provider;
_database = new Database("Datasource=|DataDirectory|test.sdf",
"System.Data.SqlServerCe.4.0");
}
//=============================================================
public static void CriarBaseDados()
{
//criação da base de dados "Data source" é a connection string !!!
SqlCeEngine motor = new SqlCeEngine("Data source = " + base_dados); //sempre coloque "Data source" se não, não da certo
motor.CreateDatabase(); // dentro desse () /\ é uma string de conexao para criar o banco de dados
//conectar a base de dados
SqlCeConnection conectar = new SqlCeConnection();
conectar.ConnectionString = "Data source = " + base_dados;
conectar.Open();
//criar o operario para criar as estruturas(colunas) de dentro da base de dados como nome,telefone,endereço etc
SqlCeCommand operario = new SqlCeCommand();
operario.CommandText =
"CREATE TABLE contatos(" +
"id_contato int not null primary key, " +
"nome nvarchar(50), " +
"telefone nvarchar(20), " +
"atualizacao DateTime)";
//coloquei assim acima para organização, mas pode ser feito em uma linha apenas(mas não é indicado)
operario.Connection = conectar;
operario.ExecuteNonQuery(); //não retorna resultados
operario.Dispose(); //sempre colocar
conectar.Dispose(); //esses dois comandos não deixa o app na memoria, ele apaga então ao abrir de novo ele vai carregar todo denovo
}
public void EnsureDatabase()
{
try
{
if (sqlCeFilePath.Length > 0)
{
//string connectionString = "Data Source=" + sqlCeFilePath + ";Persist Security Info=False;";
if (!File.Exists(sqlCeFilePath))
{
lock (theLock)
{
if (!File.Exists(sqlCeFilePath))
{
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
{
engine.CreateDatabase();
}
}
}
}
}
}
catch (Exception ex)
{
log.LogError("SqlCe database file is not present, tried to create it but this error occurred.", ex);
}
}
/// <summary>
/// Creates the underlying DataStore
/// </summary>
public override void CreateStore()
{
if (StoreExists)
{
throw new StoreAlreadyExistsException();
}
// create the file
using (SqlCeEngine engine = new SqlCeEngine(ConnectionString))
{
engine.CreateDatabase();
}
var connection = GetConnection(true);
try
{
foreach (var entity in this.Entities)
{
CreateTable(connection, entity);
}
}
finally
{
DoneWithConnection(connection, true);
}
}
public static void CreateDB()
{
SqlCeEngine engine = new SqlCeEngine(ConStrDB);
engine.CreateDatabase();
engine.Dispose();
}
public void SetupSQLCEDatabase()
{
// Discard the previous iteration of this test database.
if (File.Exists(sqlCEDatabaseName))
{
File.Delete(sqlCEDatabaseName);
}
// Connect to SQL CE, and create the new database
sqlCEEngine = new SqlCeEngine(StaticTestUtilities.connectionString(sqlCEDatabaseName, sqlCEPassword));
sqlCEEngine.CreateDatabase();
// Connect to the sucker
SqlCeConnection connection = new SqlCeConnection(StaticTestUtilities.connectionString(sqlCEDatabaseName, sqlCEPassword));
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
// Create the table with the test results.
String tableCreate = "CREATE TABLE [TestRecords] ([StringData] nvarchar(255), [MoreString] nvarchar(255), [DateColumn] DATETIME, [IntegerColumn] bigint, [NumericColumn] numeric(15,2), [RipeMD160BinaryOutput] varbinary(20), [RipeMD160HexOutput] nvarchar(42), [RipeMD160BaseOutput] nvarchar(28))";
SqlCeCommand command = new SqlCeCommand(tableCreate, connection);
command.ExecuteNonQuery();
// Diconnect from the SQL CE database
connection.Close();
sqlCEEngine.Dispose();
}
public static void CreateDatabase(string dataFile, string connectionString)
{
var dir = Path.GetDirectoryName(dataFile);
IO.IOUtility.EnsureDirectoryExists(dir);
SqlCeEngine engine = new SqlCeEngine(connectionString);
engine.CreateDatabase();
}
static SqlCETestSuite()
{
if (File.Exists(FileName))
{
File.Delete(FileName);
}
var engine = new SqlCeEngine(ConnectionString);
engine.CreateDatabase();
using (var connection = new SqlCeConnection(ConnectionString))
{
connection.Open();
connection.Execute(@"CREATE TABLE Stuff (TheId int IDENTITY(1,1) not null, Name nvarchar(100) not null, Created DateTime null) ");
connection.Execute(@"CREATE TABLE People (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null) ");
connection.Execute(@"CREATE TABLE Users (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null, Age int not null) ");
connection.Execute(@"CREATE TABLE Automobiles (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null) ");
connection.Execute(@"CREATE TABLE Results (Id int IDENTITY(1,1) not null, Name nvarchar(100) not null, [Order] int not null) ");
connection.Execute(@"CREATE TABLE ObjectX (ObjectXId nvarchar(100) not null, Name nvarchar(100) not null) ");
connection.Execute(@"CREATE TABLE ObjectY (ObjectYId int not null, Name nvarchar(100) not null) ");
connection.Execute(@"CREATE TABLE ObjectZ (Id int not null, Name nvarchar(100) not null) ");
connection.Execute(@"CREATE TABLE GenericType (Id nvarchar(100) not null, Name nvarchar(100) not null) ");
connection.Execute(@"CREATE TABLE NullableDates (Id int IDENTITY(1,1) not null, DateValue DateTime null) ");
}
Console.WriteLine("Created database");
}
public override void DatabaseSpecificSetUp()
{
string filePath = string.Concat(Path, "\\UmbracoPetaPocoTests.sdf");
if (!File.Exists(filePath))
{
try
{
//Delete database file before continueing
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
catch (Exception)
{
//if this doesn't work we have to make sure everything is reset! otherwise
// well run into issues because we've already set some things up
TearDown();
throw;
}
//Create the Sql CE database
//Get the connectionstring settings from config
var settings = ConfigurationManager.ConnectionStrings[Core.Configuration.GlobalSettings.UmbracoConnectionName];
var engine = new SqlCeEngine(settings.ConnectionString);
engine.CreateDatabase();
}
else
{
TestHelper.ClearDatabase();
}
}
public bool Create()
{
bool ret = true;
// Проверяем если файла нет в наличии то создаем базу данных
if (!File.Exists(FileName))
{
//Создание файла базы данных !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
SqlCeEngine engine = new SqlCeEngine();
//engine.
try
{
engine.LocalConnectionString = connString;
engine.CreateDatabase();
}
catch
{
ret = false;
}
finally
{
if (engine != null)
{
engine.Dispose();
}
}
}
return(ret);
}
/// <summary>
/// Configure a ConnectionString for the embedded database.
/// </summary>
public void ConfigureEmbeddedDatabaseConnection()
{
const string providerName = "System.Data.SqlServerCe.4.0";
var connectionString = GetEmbeddedDatabaseConnectionString();
SaveConnectionString(connectionString, providerName);
var path = Path.Combine(GlobalSettings.FullpathToRoot, "App_Data", "Umbraco.sdf");
if (File.Exists(path) == false)
{
var engine = new SqlCeEngine(connectionString);
engine.CreateDatabase();
// SD: Pretty sure this should be in a using clause but i don't want to cause unknown side-effects here
// since it's been like this for quite some time
//using (var engine = new SqlCeEngine(connectionString))
//{
// engine.CreateDatabase();
//}
}
Initialize(providerName);
}
public SqlServerCeStorageFixture()
{
Skip.IfNoConfig(nameof(TestConfig.Current.SQLServerCeConnectionString), TestConfig.Current.SQLServerCeConnectionString);
var connString = TestConfig.Current.SQLServerCeConnectionString;
var csb = new SqlCeConnectionStringBuilder(connString);
var filename = csb.DataSource;
Storage = new SqlServerCeStorage(
connString,
"MPTest" + TestId,
"MPTimingsTest" + TestId,
"MPClientTimingsTest" + TestId);
try
{
try
{
File.Delete(filename);
}
catch { /* expected */ }
var engine = new SqlCeEngine(connString);
engine.CreateDatabase();
Storage.CreateSchema();
}
catch (Exception e)
{
ShouldSkip = true;
SkipReason = e.Message;
}
}
public void Can_Assert_Created_Database()
{
string path = TestHelper.CurrentAssemblyDirectory;
AppDomain.CurrentDomain.SetData("DataDirectory", path);
//Delete database file before continueing
string filePath = string.Concat(path, "\\UmbracoPetaPocoTests.sdf");
if (File.Exists(filePath))
{
File.Delete(filePath);
}
//Get the connectionstring settings from config
var settings = ConfigurationManager.ConnectionStrings[Core.Configuration.GlobalSettings.UmbracoConnectionName];
//Create the Sql CE database
var engine = new SqlCeEngine(settings.ConnectionString);
engine.CreateDatabase();
SqlSyntaxContext.SqlSyntaxProvider = SqlCeSyntax.Provider;
//Create the umbraco database
_dbContext.Database.CreateDatabaseSchema(false);
bool umbracoNodeTable = _dbContext.Database.TableExist("umbracoNode");
bool umbracoUserTable = _dbContext.Database.TableExist("umbracoUser");
bool cmsTagsTable = _dbContext.Database.TableExist("cmsTags");
Assert.That(umbracoNodeTable, Is.True);
Assert.That(umbracoUserTable, Is.True);
Assert.That(cmsTagsTable, Is.True);
}
public override string CreateDatabaseFile(string fileName)
{
using (var engine = new SqlCeEngine("Data Source=" + fileName)) {
engine.CreateDatabase();
return(engine.LocalConnectionString);
}
}
public static void Open()
{
string filePath = Path.Combine(Environment.CurrentDirectory, "Scores.sdf");
string connectionString = String.Format("Data Source={0}", filePath);
if (!File.Exists(filePath))
{
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
{
engine.CreateDatabase();
}
//scores
using (SqlCeConnection conn = new SqlCeConnection(connectionString))
using (SqlCeCommand cmd = new SqlCeCommand("CREATE TABLE Scores (Name NVARCHAR(255), Points INT, Picture IMAGE);", conn))
{
conn.Open();
cmd.ExecuteNonQuery();
}
//funds
using (SqlCeConnection conn = new SqlCeConnection(connectionString))
using (SqlCeCommand cmd = new SqlCeCommand("CREATE TABLE Funds (Amount MONEY);", conn))
{
conn.Open();
cmd.ExecuteNonQuery();
}
}
_conn = new SqlCeConnection(connectionString);
_conn.Open();
}
public static void CreateDatabase()
{
if (File.Exists(DatabaseFilePath))
{
return;
}
SqlCeEngine engine = new SqlCeEngine(ConnectionString);
engine.CreateDatabase();
using (SqlCeConnection connection = new SqlCeConnection(ConnectionString))
{
connection.Open();
using (SqlCeCommand createCmd = new SqlCeCommand("CREATE TABLE Beers(ID int identity, Brewery nvarchar(500), Name nvarchar(500), IsLager bit)", connection))
{
createCmd.ExecuteNonQuery();
}
using (SqlCeCommand insertCmd = new SqlCeCommand("INSERT INTO Beers (Brewery, Name, IsLager) VALUES (?, ?, ?)", connection))
{
insertCmd.Parameters.Add("brewery", SqlDbType.NVarChar);
insertCmd.Parameters.Add("name", SqlDbType.NVarChar);
insertCmd.Parameters.Add("isLager", SqlDbType.Bit);
insertCmd.Prepare();
using (SqlCeCommand identityCmd = new SqlCeCommand("SELECT @@IDENTITY", connection))
{
identityCmd.Prepare();
int identity = -1;
foreach (Beer beer in SampleData)
{
insertCmd.Parameters["brewery"].Value = beer.Brewery;
insertCmd.Parameters["name"].Value = beer.Name;
insertCmd.Parameters["isLager"].Value = beer.IsLager;
if (insertCmd.ExecuteNonQuery() != 1)
{
throw new Exception("Insert failed");
}
identity = Convert.ToInt32(identityCmd.ExecuteScalar());
}
} // using (SqlCeCommand identityCmd...
} // using (SqlCeCommand insertCmd...
using (SqlCeCommand indexCmd = new SqlCeCommand())
{
indexCmd.Connection = connection;
indexCmd.CommandText = "CREATE INDEX IDX_Brewery ON Beers (Brewery)";
indexCmd.ExecuteNonQuery();
indexCmd.CommandText = "CREATE INDEX IDX_Name ON Beers (Name)";
indexCmd.ExecuteNonQuery();
} // using (SqlCeCommand indexCmd
} // using (SqlCeConnection connection...
}
public void RunApplication(string[] args)
{
// example command line args:
// ClearCanvas.Dicom.DataStore.SetupApplication.Application "<TrunkPath>\Dicom\DataStore\AuxiliaryFiles\empty_viewer.sdf" "<TrunkPath>\Dicom\DataStore\AuxiliaryFiles\CreateTables.clearcanvas.dicom.datastore.ddl"
string databaseFile = args[0];
string scriptFile = args[1];
File.Delete(databaseFile);
string connectionString = String.Format("Data Source=\"{0}\"", databaseFile);
SqlCeEngine engine = new SqlCeEngine(connectionString);
engine.CreateDatabase();
engine.Dispose();
StreamReader reader = new StreamReader(scriptFile);
string scriptText = reader.ReadToEnd();
reader.Close();
SqlCeConnection connection = new SqlCeConnection(connectionString);
connection.Open();
SqlCeTransaction transaction = connection.BeginTransaction();
SqlCeCommand command = new SqlCeCommand();
command.Connection = connection;
command.CommandText = scriptText;
command.ExecuteNonQuery();
transaction.Commit();
connection.Close();
}
public void EnsureDatabase()
{
try
{
if (sqlCeFilePath.Length > 0)
{
//string connectionString = "Data Source=" + sqlCeFilePath + ";Persist Security Info=False;";
string folderPath = Path.GetDirectoryName(sqlCeFilePath);
if (!Directory.Exists(folderPath))
{
Directory.CreateDirectory(folderPath);
}
if (!File.Exists(sqlCeFilePath))
{
lock (theLock)
{
if (!File.Exists(sqlCeFilePath))
{
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
{
engine.CreateDatabase();
}
}
}
}
}
}
catch (Exception ex)
{
log.LogError("SqlCe database file is not present, tried to create it but this error occurred.", ex);
}
}
/// <summary>
///
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public static string CreateDatabase(string fileName)
{
try
{
using (SqlCeEngine sqlCeEngine = new SqlCeEngine(GetConnectionString(fileName)))
{
sqlCeEngine.CreateDatabase();
using (SqlCeConnection connection = new SqlCeConnection(GetConnectionString(fileName)))
{
connection.Open();
using (SqlCeCommand command = new SqlCeCommand(SQL_TABLE_SESSION, connection))
{
command.ExecuteNonQuery();
}
using (SqlCeCommand command = new SqlCeCommand(SQL_TABLE_SESSION_PK, connection))
{
command.ExecuteNonQuery();
}
}
}
return string.Empty;
}
catch (Exception ex)
{
return ex.Message;
}
}
public static void Initialize()
{
string dbFile = ConfigurationManager.AppSettings["ARQUIVO_BANCO"];
string dbDirectory = AppDomain.CurrentDomain.BaseDirectory;
string dbPath = $"{dbDirectory}{dbFile}";
ConnectionString = $"DataSource=\"{dbPath}\";Max Database Size=4091;Case Sensitive=False;Locale Identifier=1046";
if (!File.Exists(dbPath))
{
using (SqlCeEngine engine = new SqlCeEngine(ConnectionString)) {
engine.CreateDatabase();
}
string scriptFile = ConfigurationManager.AppSettings["ARQUIVO_SCRIPT"];
string scriptPath = $"{dbDirectory}{scriptFile}";
string scriptText;
using (StreamReader streamReader = new StreamReader(scriptPath, Encoding.UTF8)) {
scriptText = streamReader.ReadToEnd();
}
using (SqlCeConnection connection = CreateConnection()) {
foreach (string commandText in scriptText.Split(';'))
{
if (!string.IsNullOrWhiteSpace(commandText))
{
using (SqlCeCommand command = new SqlCeCommand()) {
command.Connection = connection;
command.CommandType = CommandType.Text;
command.CommandText = commandText;
command.ExecuteNonQuery();
}
}
}
}
}
}
/// <summary>
/// 创建新数据源。
/// </summary>
public void CreateDatabase()
{
using(SqlCeEngine engine = new SqlCeEngine(this.ConnectionString))
{
engine.CreateDatabase();
}
}
private void _CreateDatabase(string historyDBPath)
{
bool dbCreated = false;
try
{
string connectionString = _BuildConnectionString(historyDBPath);
SqlCeEngine engine = new SqlCeEngine(connectionString);
engine.CreateDatabase();
dbCreated = true;
// get creation script
Assembly assembly = Assembly.GetExecutingAssembly();
Stream txtStream = assembly.GetManifestResourceStream("ESRI.ArcLogistics.App.Resources.Historydb_create.sql");
StreamReader streamReader = new StreamReader(txtStream);
string script = streamReader.ReadToEnd();
_CreateDatabaseStructure(connectionString, script);
}
catch
{
if (dbCreated)
{
File.Delete(historyDBPath);
}
throw;
}
}
private static void CreateDatabase()
{
if (File.Exists(_fileName))
File.Delete(_fileName);
using (var engine = new SqlCeEngine(_connectionString))
engine.CreateDatabase();
}
public virtual void Initialize()
{
TestHelper.SetupLog4NetForTests();
TestHelper.InitializeContentDirectories();
Path = TestHelper.CurrentAssemblyDirectory;
AppDomain.CurrentDomain.SetData("DataDirectory", Path);
Resolution.Freeze();
//Delete database file before continueing
string filePath = string.Concat(Path, "\\UmbracoPetaPocoTests.sdf");
if (File.Exists(filePath))
{
File.Delete(filePath);
}
//Get the connectionstring settings from config
var settings = ConfigurationManager.ConnectionStrings[Core.Configuration.GlobalSettings.UmbracoConnectionName];
//Create the Sql CE database
var engine = new SqlCeEngine(settings.ConnectionString);
engine.CreateDatabase();
SqlSyntaxContext.SqlSyntaxProvider = SqlCeSyntax.Provider;
}
public override void DatabaseSpecificSetUp()
{
string filePath = string.Concat(Path, "\\UmbracoPetaPocoTests.sdf");
if (!File.Exists(filePath))
{
try
{
//Delete database file before continueing
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
catch (Exception)
{
//if this doesn't work we have to make sure everything is reset! otherwise
// well run into issues because we've already set some things up
TearDown();
throw;
}
//Create the Sql CE database
//Get the connectionstring settings from config
var settings = ConfigurationManager.ConnectionStrings[Core.Configuration.GlobalSettings.UmbracoConnectionName];
var engine = new SqlCeEngine(settings.ConnectionString);
engine.CreateDatabase();
}
else
{
TestHelper.ClearDatabase();
}
}
/// <summary>
/// Private method to install the umbraco database schema in an empty database
/// </summary>
/// <param name="database"></param>
/// <param name="databaseProvider"></param>
/// <param name="dataDirectory"></param>
private static void CreateDatabaseSchema(Database database, DatabaseProviders databaseProvider, string dataDirectory)
{
Console.WriteLine("Please note that installing the umbraco database schema requires an empty database configured in config.");
Console.WriteLine("The 'umbracoConfigurationStatus' under appSettings should be left blank.");
Console.WriteLine("If you are using Sql Ce an empty Umbraco.sdf file should exist in the DataDictionary.");
Console.WriteLine("Press y to continue");
var input = Console.ReadLine();
if (string.IsNullOrEmpty(input) == false && input.ToLowerInvariant().Equals("y"))
{
try
{
if (databaseProvider == DatabaseProviders.SqlServerCE)
{
var dbPath = Path.Combine(dataDirectory, "Umbraco.sdf");
if (File.Exists(dbPath) == false)
{
var engine = new SqlCeEngine(@"Data Source=|DataDirectory|\Umbraco.sdf;Flush Interval=1;");
engine.CreateDatabase();
}
}
database.CreateDatabaseSchema(false);
Console.WriteLine("The database schema has been installed");
Console.WriteLine("Note: This is just an example, so no backoffice user has been created.");
}
catch (Exception e)
{
Console.WriteLine("An error occured while trying to install the database schema");
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
}
}
public override bool CheckConnectionString(string connectionString)
{
try
{
var builder = new SqlConnectionStringBuilder(connectionString);
if (File.Exists(builder.DataSource) == false)
{
var containingFolder = builder.DataSource.Substring(0, builder.DataSource.LastIndexOf("\\"));
if (Directory.Exists(containingFolder) == false)
{
GenericUtils.CreateFolderStructure(containingFolder);
}
var engine = new SqlCeEngine(connectionString);
engine.CreateDatabase();
}
}
catch (Exception ex) { Console.WriteLine("Unable to create SQL CE database automatically. The database should be created manually. Error Details : " + ex.Message); }
var connectionCretead = CreateConnection(null, connectionString);
if (connectionCretead != null && connectionCretead.State == System.Data.ConnectionState.Open)
{
connectionCretead.Close();
return true;
}
return false;
}
protected override void CreateDatabase()
{
using (var engine = new SqlCeEngine(ConnectionString))
{
engine.CreateDatabase();
}
}
public void Can_Assert_Created_Database()
{
string path = TestHelper.CurrentAssemblyDirectory;
AppDomain.CurrentDomain.SetData("DataDirectory", path);
//Delete database file before continueing
//NOTE: we'll use a custom db file for this test since we're re-using the one created with BaseDatabaseFactoryTest
string filePath = string.Concat(path, "\\DatabaseContextTests.sdf");
if (File.Exists(filePath))
{
File.Delete(filePath);
}
//Get the connectionstring settings from config
var settings = ConfigurationManager.ConnectionStrings[Core.Configuration.GlobalSettings.UmbracoConnectionName];
//by default the conn string is: Datasource=|DataDirectory|UmbracoPetaPocoTests.sdf;Flush Interval=1;
//we'll just replace the sdf file with our custom one:
//Create the Sql CE database
var engine = new SqlCeEngine(settings.ConnectionString.Replace("UmbracoPetaPocoTests", "DatabaseContextTests"));
engine.CreateDatabase();
SqlSyntaxContext.SqlSyntaxProvider = SqlCeSyntax.Provider;
//Create the umbraco database
_dbContext.Database.CreateDatabaseSchema(false);
bool umbracoNodeTable = _dbContext.Database.TableExist("umbracoNode");
bool umbracoUserTable = _dbContext.Database.TableExist("umbracoUser");
bool cmsTagsTable = _dbContext.Database.TableExist("cmsTags");
Assert.That(umbracoNodeTable, Is.True);
Assert.That(umbracoUserTable, Is.True);
Assert.That(cmsTagsTable, Is.True);
}
private void TestConnection(bool showMessage)
{
try
{
if (createDb)
{
if (!System.IO.File.Exists(builder.DataSource))
{
using (var eng = new SqlCeEngine(builder.ConnectionString))
{
eng.CreateDatabase();
}
}
}
using (var conn = new SqlCeConnection(builder.ConnectionString))
{
conn.Open();
this.ConnectionString = builder.ConnectionString;
if (showMessage)
{
MessageBox.Show("Test succeeded!");
}
else
{
this.DialogResult = true;
}
}
}
catch (Exception ex)
{
MessageBox.Show(Helpers.DataConnectionHelper.ShowErrors(ex));
}
}
private static void CreateDatabase()
{
string appDir = Application.Current.GetUserAppDataPath();
string connString = String.Format("Data Source={0}agent.sdf", appDir);
try {
var engine = new SqlCeEngine();
if(!Directory.Exists(appDir))
Directory.CreateDirectory(appDir);
engine.LocalConnectionString = connString;
engine.CreateDatabase();
}
catch(Exception exception) {
MessageBox.Show("Failed creating database: \n" + exception.Message, "Agent Error");
}
try{
connection = new SqlCeConnection();
connection.ConnectionString = connString;
connection.Open();
}
catch(Exception exception) {
MessageBox.Show("Failed opening database: \n" + exception.Message, "Agent Error");
}
}
public void CreateDatabase(string fileName, string password)
{
string connectionString;
if (System.IO.File.Exists(fileName))
return;
//System.IO.File.Delete(fileName);
// The DataSource must be surrounded with double quotes. The Password, on the other hand, must be surrounded
// with single quotes
connectionString = string.Format(
"DataSource=\"{0}\"; Password='******'", fileName, password);
// we'll use the SqlServerCe connection object to get the database file path
using (SqlCeConnection localConnection = new SqlCeConnection(connectionString))
{
// The SqlCeConnection.Database property contains the file parth portion
// of the database from the full connectionstring
if (!System.IO.File.Exists(localConnection.Database))
{
using (SqlCeEngine sqlCeEngine = new SqlCeEngine(connectionString))
{
sqlCeEngine.CreateDatabase();
CreateInitialDatabaseObjects(connectionString);
}
}
}
}
public ctlrptActiveCall()
{
try
{
InitializeComponent();
ConnectionString = VMuktiAPI.VMuktiInfo.MainConnectionString;
if (System.IO.File.Exists(AppDomain.CurrentDomain.BaseDirectory.ToString() + "rptActiveCall.sdf"))
{
System.IO.File.Delete(AppDomain.CurrentDomain.BaseDirectory.ToString() + "rptActiveCall.sdf");
}
SqlCeEngine clientEngine = new SqlCeEngine(ClientConnectionString);
clientEngine.CreateDatabase();
LocalSQLConn = new SqlCeConnection();
LocalSQLConn.ConnectionString = ClientConnectionString;
LocalSQLConn.Open();
fncActiveCallTable();
LocalSQLConn.Close();
objRefreshReport = new delRefreshReport(fncRefreshReport);
NetPeerClient npcActiveCall = new NetPeerClient();
((NetP2PBootStrapActiveCallReportDelegates)objActiveCall).EntsvcJoinCall += new NetP2PBootStrapActiveCallReportDelegates.DelsvcJoinCall(ctlrptActiveCall_EntsvcJoinCall);
((NetP2PBootStrapActiveCallReportDelegates)objActiveCall).EntsvcGetCallInfo += new NetP2PBootStrapActiveCallReportDelegates.DelsvcGetCallInfo(ctlrptActiveCall_EntsvcGetCallInfo);
((NetP2PBootStrapActiveCallReportDelegates)objActiveCall).EntsvcActiveCalls += new NetP2PBootStrapActiveCallReportDelegates.DelsvcActiveCalls(ctlrptActiveCall_EntsvcActiveCalls);
((NetP2PBootStrapActiveCallReportDelegates)objActiveCall).EntsvcSetDuration += new NetP2PBootStrapActiveCallReportDelegates.DelsvcSetDuration(ctlrptActiveCall_EntsvcSetDuration);
((NetP2PBootStrapActiveCallReportDelegates)objActiveCall).EntsvcUnJoinCall += new NetP2PBootStrapActiveCallReportDelegates.DelsvcUnJoinCall(ctlrptActiveCall_EntsvcUnJoinCall);
channelNetTcpActiveCall = (INetP2PBootStrapReportChannel)npcActiveCall.OpenClient<INetP2PBootStrapReportChannel>("net.tcp://" + VMuktiAPI.VMuktiInfo.BootStrapIPs[0] + ":6000/NetP2PBootStrapActiveCallReport", "ActiveCallMesh", ref objActiveCall);
channelNetTcpActiveCall.svcJoinCall(VMuktiAPI.VMuktiInfo.CurrentPeer.DisplayName);
}
catch (Exception ex)
{
VMuktiAPI.VMuktiHelper.ExceptionHandler(ex, "ctlrptActiveCall", "ctlrptActiveCall.xaml.cs");
}
}
public static ISessionFactory BootstrapSqlServerCe()
{
return Bootstrap(new CreateSchema_SqlServerCe(), DbAdapter.SqlServerCe, cs =>
{
var engine = new SqlCeEngine(cs);
engine.CreateDatabase();
});
}
private static void CreateDatabase()
{
if (!File.Exists(Path.Combine(AppDomain.CurrentDomain.GetData("DataDirectory").ToString(), "FastEasyPizza.sdf")))
{
var engine = new SqlCeEngine(connectionString);
engine.CreateDatabase();
}
}
protected override DbConnection CreateDatabase()
{
using (var sqlCeEngine = new SqlCeEngine(this.ConnectionString))
{
sqlCeEngine.CreateDatabase();
}
return new SqlCeConnection(this.ConnectionString);
}
/// <summary>
/// Create the initial database
/// </summary>
private void CreateDB()
{
var connection = new SqlCeConnection(this.path);
try
{
var eng = new SqlCeEngine(this.path);
var cleanup = new System.Threading.Tasks.Task(eng.Dispose);
eng.CreateDatabase();
cleanup.Start();
}
catch (Exception e)
{
EventLogging.WriteError(e);
}
connection.Open();
var usersDB =
new SqlCeCommand(
"CREATE TABLE Users_DB("
+ "UserID int IDENTITY (100,1) NOT NULL UNIQUE, "
+ "UserName nvarchar(128) NOT NULL UNIQUE, "
+ "PassHash nvarchar(128) NOT NULL, "
+ "Friends varbinary(5000), "
+ "PRIMARY KEY (UserID));",
connection);
usersDB.ExecuteNonQuery();
usersDB.Dispose();
connection.Dispose();
connection.Close();
}
public SQLCEDatabase()
{
try
{
IPathManager pathManager = ServiceRegistration.Get<IPathManager>();
string dataDirectory = pathManager.GetPath("<DATABASE>");
string databaseFile = Path.Combine(dataDirectory, DEFAULT_DATABASE_FILE);
int databaseSize = INITIAL_MAX_DATABASE_SIZE;
FileInfo databaseFileInfo = new FileInfo(databaseFile);
if (databaseFileInfo.Exists)
{
int bufferFileSize = (int) (databaseFileInfo.Length/(1024*1024)) + DATABASE_SIZE_BUFFER;
if (bufferFileSize > databaseSize)
databaseSize = bufferFileSize;
}
_connectionString = "Data Source='" + databaseFile + "'; Default Lock Timeout=" + LOCK_TIMEOUT + "; Max Buffer Size = " + MAX_BUFFER_SIZE + "; Max Database Size = " + databaseSize;
SqlCeEngine engine = new SqlCeEngine(_connectionString);
if (File.Exists(databaseFile))
CheckUpgrade(engine);
else
{
Directory.CreateDirectory(dataDirectory);
engine.CreateDatabase();
engine.Dispose();
}
}
catch (Exception e)
{
ServiceRegistration.Get<ILogger>().Critical("Error establishing database connection", e);
throw;
}
}
