private void FillDatabase(EsentDatabase db)
{
Properties.Rows.Add(nameof(db.Name), db.Name);
Properties.Rows.Add(nameof(db.Opened), db.Opened);
Properties.Rows.Add(nameof(db.FilePath), db.FilePath);
Properties.Rows.Add(nameof(db.Tables), db.Tables.Count);
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
EsentDatabase.Settings settings = new EsentDatabase.Settings()
{
maxConcurrentSessions = 1,
folderLocation = Environment.ExpandEnvironmentVariables(@"%APPDATA%\EsentDemoApp")
};
using (var pool = EsentDatabase.open(settings, typeof(Program).Assembly))
using (var sess = pool.GetSession())
{
if (pool.isNewDatabase)
{
Person.populateWithDebugData(sess);
}
using (var trans = sess.BeginTransaction())
{
using (var frm = new Form1(sess))
{
if (DialogResult.OK == frm.ShowDialog())
{
trans.Commit();
}
}
}
}
}
public EsentDatabaseRepository(ILogger logger, IOptions options)
{
_logger = logger;
_options = options;
_database = new EsentDatabase(_options.Name, Path.Combine(_options.DatabasePath, DATABASE_NAME));
_database.Open();
}
public DemoDictionary(string folder)
{
EsentDatabase.Settings settings = new EsentDatabase.Settings()
{
folderLocation = folder,
folderName = null,
};
sessionPool = EsentDatabase.open(settings, typeof(DictionaryEntry));
}
public static object Execute(string expression, EsentDatabase db, out bool success)
{
try
{
success = true;
var provider = CodeDomProvider.CreateProvider("CSharp");
var parameters = new CompilerParameters
{
CompilerOptions = "/t:library",
GenerateInMemory = true
};
var assemblies = AppDomain.CurrentDomain
.GetAssemblies()
.Where(a => !a.IsDynamic)
.Select(a => a.Location);
parameters.ReferencedAssemblies.AddRange(assemblies.ToArray());
var code = @"
using FourToolkit.Esent;
using System;
using System.Data;
using System.Linq;
using System.Xml;
namespace TempAssembly
{
public class CodeRunner
{
public object Execute(EsentDatabase db)
{
return " + expression + @";
}
}
}";
var compilationResult = provider.CompileAssemblyFromSource(parameters, code);
if (compilationResult.Errors.HasErrors)
throw new Exception(compilationResult.Errors[0].ErrorText);
var assembly = compilationResult.CompiledAssembly;
var instance = assembly.CreateInstance("TempAssembly.CodeRunner");
if (instance != null)
{
var type = instance.GetType();
var method = type.GetMethod("Execute");
return method.Invoke(instance, new object[] { db });
}
return null;
}
catch (TargetInvocationException targetException)
{
success = false;
return $"Exception: {targetException.InnerException?.Message} {targetException.InnerException?.StackTrace}";
}
catch (Exception exception)
{
success = false;
return $"Exception: {exception.Message} {exception.StackTrace}";
}
}
public DB()
{
// This demo app opens/closes the database with each test.
// That's not normally done: usually, the database is initialized only once when application is launched.
// To optimize for such unusual use case, we're tuning a few advanced DB parameters here.
EsentDatabase.Settings settings = new EsentDatabase.Settings();
settings.advanced.EnableFileCache = true; // Use Windows file cache
settings.advanced.EnableViewCache = true; // Read directly from the memory-mapped DB
pool = EsentDatabase.open(settings, typeof(Record));
// Precompile query to filter records by that random column.
qBetween = pool.filter((Record r, int from, int to) => r.randomInt >= from && r.randomInt <= to);
}
static void Main(string[] args)
{
EsentDatabase.Settings settings = new EsentDatabase.Settings()
{
maxConcurrentSessions = 1,
folderLocation = Environment.ExpandEnvironmentVariables(@"%APPDATA%\EsentDemoApp")
};
using (var pool = EsentDatabase.open(settings, typeof(Program).Assembly))
using (var sess = pool.GetSession())
{
if (pool.isNewDatabase)
{
Person.populateWithDebugData(sess);
FiltersTest.populateWithDebugData(sess);
}
RunTests(sess);
}
}
private void Page_Loaded(object sender, RoutedEventArgs e)
{
try
{
using (var db = EsentDatabase.open(typeof(Person).GetTypeInfo().Assembly))
using (var sess = db.GetSession())
{
if (db.isNewDatabase)
{
Person.populateWithDebugData(sess);
FiltersTest.populateWithDebugData(sess);
}
testPersons(sess);
// testFilters( sess );
}
}
catch (Exception ex)
{
Debug.WriteLine("Failed: {0}", ex.Message);
}
}
static void Main(string[] args)
{
Console.WriteLine("Starting the service...");
EsentDatabase.Settings settings = new EsentDatabase.Settings()
{
maxConcurrentSessions = 16,
folderLocation = Environment.ExpandEnvironmentVariables(@"%APPDATA%\EsentDemoApp")
};
using (SessionPool pool = EsentDatabase.open(settings, typeof(Person)))
{
if (pool.isNewDatabase)
{
using (var sess = pool.GetSession())
PopulateDemoDatabase(sess);
}
Service singletoneInstance = new Service(pool);
using (ServiceHost host = new ServiceHost(singletoneInstance, ServiceConfig.baseAddress))
{
host.AddServiceEndpoint(typeof(iPersonsService), new NetNamedPipeBinding(), ServiceConfig.pipeName);
host.Open();
ServiceConfig.eventServerReady.Set();
try
{
Console.WriteLine("Server running. Press any key to shut down");
Console.ReadKey(true);
Console.WriteLine("Shutting down...");
}
finally
{
ServiceConfig.eventServerReady.Reset();
}
}
}
Console.WriteLine("The service has stopped.");
}
static void Main(string[] args)
{
using (var pool = EsentDatabase.open(typeof(Record)))
{
while (true)
{
Console.WriteLine("c = create, r = read, u = update, d = delete, s = search, a = all, q = quit");
char c = char.ToLower(Console.ReadKey().KeyChar);
Console.WriteLine();
if ('q' == c)
{
return;
}
tAction act;
if (!actions.TryGetValue(c, out act))
{
continue;
}
using (var sess = pool.GetSession())
using (var trans = sess.BeginTransaction())
{
try
{
if (act(sess))
{
trans.Commit();
}
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}", ex.Message);
}
}
}
}
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
EsentDatabase.Settings settings = new EsentDatabase.Settings(Environment.ExpandEnvironmentVariables(@"%APPDATA%\EseFileSystemDemo"));
settings.PresetMedium();
using (var sp = EsentDatabase.open(settings, typeof(EseFileSystem.EfsEntry)))
{
if (sp.isNewDatabase)
{
using (var sess = sp.GetSession())
using (var trans = sess.BeginTransaction())
{
var cur = sess.Cursor <EseFileSystem.EfsEntry>();
cur.Add(EseFileSystem.EfsEntry.NewRoot());
trans.Commit();
}
}
Application.Run(new Form1(sp));
}
}
public void Test()
{
var dbdef = new DatabaseDefinition()
.Table("KV")
.Column("Key").AsString().NotNull().Table
.Column("Value").AsText().NotNull().Table
.Index("IX_KV_Key").Asc("Key").Primary().Table
.Database;
var db = new EsentDatabase(@"c:\temp\fluesent\a.db");
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession(false))
{
session.CreateDatabase(null, CreateDatabaseGrbit.OverwriteExisting);
using (var transaction = session.CreateTransaction())
{
dbdef.Create(transaction);
transaction.Commit();
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
using (var transaction = session.CreateTransaction())
{
using (var table = transaction.OpenTable("KV"))
{
table.CreateInsertRecord()
.AddString("Key", "A")
.AddString("Value", "Some text")
.Insert();
table.CreateInsertRecord()
.AddString("Key", "B")
.AddString("Value", "Another text")
.Insert();
table.CreateInsertRecord()
.AddString("Key", "C")
.AddString("Value", "Text for C")
.Insert();
}
transaction.Commit();
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
using (var transaction = session.CreateTransaction())
{
var stopwatch = new EsentStopwatch();
stopwatch.Start();
const int n = 100000;
using (var table = transaction.OpenTable("KV"))
{
foreach (var i in Enumerable.Range(0, n))
{
table.CreateInsertRecord()
.AddString("Key", "key" + i)
.AddString("Value", "akjsdhakhdkadhkajhd")
.Insert();
if ((i % 1000) == 999)
{
transaction.Pulse();
}
}
}
transaction.Commit();
stopwatch.Stop();
Console.Out.WriteLine("Inserted {0} records in {1}", n, stopwatch.Elapsed);
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
using (var transaction = session.CreateTransaction())
{
using (var table = transaction.OpenTable("KV"))
{
var mapper = new RecordMapper<KvRecord>()
.String("Key", (o, s) => o.Key = s)
.String("Value", (o, s) => o.Value = s);
//var search = table.CreateSearch(mapper);
//var a = search.FindEq(
// table.CreateKey().String("A")
// )
// .ToArray();
//var b = search.FindEq(
// table.CreateKey().String("B")
// )
// .ToArray();
}
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
session.AttachDatabase();
session.OpenDatabase();
using (var transaction = session.CreateTransaction())
{
using (var table = transaction.OpenTable("KV"))
{
var mapper = new RecordMapper<KvRecord>()
.String("Key", (o, s) => o.Key = s)
.String("Value", (o, s) => o.Value = s);
//var search = table.CreateSearch(mapper);
//foreach (var record in search.FindAll().Take(100))
//{
// Console.Out.WriteLine("({0},{1})",record.Key,record.Value);
//}
}
}
}
}
}
